Kaip sukurti atsitiktinę eilutę rubinu

Šiuo metu generuoju pseudo-atsitiktinę 8 ženklų eilutę „A“ .. „Z“:

 value = ""; 8.times{value << (65 + rand(25)).chr} 

tačiau ji neatrodo gryna ir negali būti perduodama kaip argumentas, nes tai nėra viena išraiška. Jei norite gauti mišrių atvejų eilutę "a" .. "z" ir "A" .. "Z", aš jį pakeitiau į:

 value = ""; 8.times{value << ((rand(2)==1?65:97) + rand(25)).chr} 

bet atrodo, kad ši šiukšliadėžė.

Ar kas nors turi geresnį metodą?

623
18 сент. Jeffas yra nustatytas rugsėjo 18 d. 2008-09-18 01:24 '08 ne 1:24 2008-09-18 01:24
@ 47 atsakymai
  • 1
  • 2
 (0...8).map { (65 + rand(26)).chr }.join 

Per daug laiko praleidžiu žaisti golfą.

 (0...50).map { ('a'..'z').to_a[rand(26)] }.join 

Ir paskutinis, kuris yra dar painesnis, bet lankstesnis ir kuriame yra mažiau ciklų:

 o = [('a'..'z'), ('A'..'Z')].map( string = (0...50).map { o[rand(o.length)] }.join 
824
18 сент. Kent Fredric rugsėjo 18 d. Atsakymas 2008-09-18 01:29 '08 1:29 am 2008-09-18 01:29

Kodėl gi ne naudoti SecureRandom?

 require 'securerandom' random_string = SecureRandom.hex # outputs: 5b5cd0da3121fc53b4bc84d0c8af2e81 (ie 32 chars of 0..9, a..f) 

SecureRandom taip pat turi metodų:

border=0
  • base64
  • atsitiktinai_bitai
  • atsitiktinis numeris

žr. http://ruby-doc.org/stdlib-1.9.2/libdoc/securerandom/rdoc/SecureRandom.html

691
25 окт. Atsakymas suteiktas Christopherstyles 25 oct. 2009-10-25 03:32 '09 3:32 am 2009-10-25 03:32

Naudoju tai generuoti atsitiktinius URL.

 rand(36**length).to_s(36) 

Jis generuoja atsitiktines mažąsias eilutes az ir 0-9. Jis nėra labai pritaikomas, bet trumpas ir švarus.

211
26 авг. Christoffero Möllerio atsakymas 26 rug. 2010-08-26 10:34 '10, 10:34, 2010-08-26 10:34

Šis sprendimas sukuria lengvai įskaitomų simbolių eilutę aktyvinimo kodams; Aš nenorėjau, kad žmonės supainiotų 8 su B, 1 su I, 0 su O, L su 1 ir tt

 # Generates a random string from a set of easily readable characters def generate_activation_code(size = 6) charset = %w{ 2 3 4 6 7 9 ACDEFGHJKMNPQRTVWXYZ} (0...size).map{ charset.to_a[rand(charset.size)] }.join end 
152
29 янв. Atsakymas pateikiamas ImNotQuiteJack 29 d 2009-01-29 23:20 '09, 23:20 2009-01-29 23:20

Kiti paminėjo kažką panašaus, tačiau naudoja URL saugią funkciją.

 require 'securerandom' p SecureRandom.urlsafe_base64(5) #=> "UtM7aa8" p SecureRandom.urlsafe_base64 #=> "UZLdOkzop70Ddx-IJR0ABg" p SecureRandom.urlsafe_base64(nil, true) #=> "i0XQ-7gglIsHGV2_BNPrdQ==" 

Rezultate gali būti AZ, az, 0-9, "-" ir "_". "=" taip pat naudojamas, jei užpildymas yra teisingas.

110
28 авг. atsakymą pateikė Travis R 28 rug. 2011-08-28 21:21 '11, 21:21, 2011-08-28 21:21
 [*('A'..'Z')].sample(8).join 

Sukurkite atsitiktinę 8 raidžių eilutę (pvz., NVAYXHGR)

 ([*('A'..'Z'),*('0'..'9')]-%w(0 1 IO)).sample(8).join 

Sukurkite atsitiktinę 8 skaitmenų eilutę (pvz., 3PH4SWF2), išskyrus 0/1 / I / O. Ruby 1.9

37
04 янв. Atsakymą pateikė Shai Coleman Jan 04 2012-01-04 19:41 '12 at 7:41 pm 2012-01-04 19:41

Negaliu prisiminti, kur jį rasti, bet man atrodo, kad tai yra geriausias ir mažiausiai intensyvus procesas man:

 def random_string(length=10) chars = 'abcdefghjkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ0123456789' password = '' length.times { password << chars[rand(chars.size)] } password end 
26
13 июля '09 в 0:40 2009-07-13 00:40 atsakymą pateikė Travis R liepos 13 d., 09:40 2009-07-13 00:40
 require 'securerandom' SecureRandom.urlsafe_base64(9) 
25
13 июля '12 в 3:34 2012-07-13 03:34 atsakymą pateikė LENZCOM liepos 12 d. 12 d. 3:34 2012-07-13 03:34

Jei reikia tam tikro ilgio eilutės, naudokite:

 require 'securerandom' randomstring = SecureRandom.hex(n) 

Jis generuos atsitiktinę eilutę, kurios ilgis yra 2n turintis 0-9 ir af

18
11 июля '13 в 17:36 2013-07-11 17:36 atsakymą pateikė Srikanta Mahapatro, liepos 11 d., 13 d., 17:36 val. 2013-07-11 17:36

Array.new(n){[*"0".."9"].sample}.join kur n = 8 jūsų atveju.

Array.new(n){[*"A".."Z", *"0".."9"].sample}.join : Array.new(n){[*"A".."Z", *"0".."9"].sample}.join - iš šio atsakymo

10
29 сент. atsakymas pateikiamas gr8scott06 29 sep . 2014-09-29 22:51 '14, 10:51 pm 2014-09-29 22:51
 require 'sha1' srand seed = "--#{rand(10000)}--#{Time.now}--" Digest::SHA1.hexdigest(seed)[0,8] 
10
18 сент. atsakymą pateikė 18 sėklų. 2008-09-18 01:40 '08 ne 1:40 2008-09-18 01:40

Ruby 1.9 +:

 ALPHABET = ('a'..'z').to_a #=> ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"] 10.times.map { ALPHABET.sample }.join #=> "stkbssowre" # or 10.times.inject('') { |s| s + ALPHABET.sample } #=> "fdgvacnxhc" 
8
25 июля '10 в 0:04 2010-07-25 00:04 atsakymas į „ Ragmaanir“ pateikiamas liepos 25 d. 10 val. 0:04 2010-07-25 00:04

Čia yra viena paprasto kodo eilutė, skirta atsitiktinei 8 eilutės eilutei

  random_string = ('0'..'z').to_a.shuffle.first(8).join 

Taip pat galite jį naudoti 8 ilgio atsitiktiniam slaptažodžiui

 random_password = ('0'..'z').to_a.shuffle.first(8).join 

Tikiuosi, kad tai padės ir yra nuostabi.

8
19 нояб. atsakymas pateikiamas Awais 19 lapkričio. 2014-11-19 09:12 '14 at 9:12 am 2014-11-19 09:12

Atkreipkite dėmesį, kad rand yra nuspėjamas įsibrovėliui ir todėl tikriausiai nėra saugus. Turėtumėte tikrai naudoti „SecureRandom“, jei jis skirtas slaptažodžių generavimui. Aš naudoju kažką panašaus:

 length = 10 characters = ('A'..'Z').to_a + ('a'..'z').to_a + ('0'..'9').to_a password = SecureRandom.random_bytes(length).each_char.map do |char| characters[(char.ord % characters.length)] end.join 
7
30 марта '13 в 17:30 2013-03-30 17:30 atsakymas pateikiamas pieštuku, kovo 30 d., 13 val., 17.30 val. 2013-03-30 17:30

Čia yra vienas paprastas kodas atsitiktiniam slaptažodžiui su lenth 8

 rand_password=('0'..'z').to_a.shuffle.first(8).join 

Tikiuosi, kad tai padės.

7
15 окт. Atsakymas suteiktas Thaha kp 15 oct. 2012-10-15 09:51 '12 ne 9:51 2012-10-15 09:51

Galite naudoti „ String#random iš „Ruby Gem“ facets :

https://github.com/rubyworks/facets/blob/126a619fd766bc45588cac18d09c4f1927538e33/lib/core/facets/string/random.rb

iš esmės jis:

 class String def self.random(len=32, character_set = ["A".."Z", "a".."z", "0".."9"]) characters = character_set.map { |i| i.to_a }.flatten characters_len = characters.length (0...len).map{ characters[rand(characters_len)] }.join end end 
5
23 авг. atsakymą pateikė Tilo 23 rug. 2014-08-23 01:53 '14 ne 1:53 2014-08-23 01:53
 SecureRandom.base64(15).tr('+/=lIO0', 'pqrsxyz') 

Kažkas iš Devise

5
19 апр. atsakymą pateikė Thorpe Obazee . 2012-04-19 03:25 '12 at 3:25 2012-04-19 03:25

Tiesiog pridėkite mano centus ...

 def random_string(length = 8) rand(32**length).to_s(32) end 
5
27 мая '12 в 13:27 2012-05-27 13:27 atsakymą pateikė pduersteler gegužės 27 d., 12 val. 13:27. 2012-05-27 13:27

Kitas būdas, kurį norėčiau naudoti

  rand(2**256).to_s(36)[0..7] 

Pridėkite „ljust“, jei esate tikrai paranojikas apie teisingą eilutės ilgį:

  rand(2**256).to_s(36).ljust(8,'a')[0..7] 
5
09 янв. atsakymas, kurį pateikė user163365 Jan 09 2010-01-09 02:17 '10, 2:17, 2010-01-09 02:17

Manau, kad tai geras glaustumo, aiškumo ir paprastumo modifikavimo balansas.

 characters = ('a'..'z').to_a + ('A'..'Z').to_a # Prior to 1.9, use .choice, not .sample (0..8).map{characters.sample}.join 

Lengvai keičiamos

Pavyzdžiui, įskaitant numerius:

 characters = ('a'..'z').to_a + ('A'..'Z').to_a + (0..9).to_a 

Aukščiausio šešioliktainio indekso indeksas:

 characters = ('A'..'F').to_a + (0..9).to_a 

Dėl tikrai įspūdingo simbolių masyvo:

 characters = (32..126).to_a.pack('U*').chars.to_a 
5
20 июня '11 в 16:48 2011-06-20 16:48 atsakymą pateikė Nathan Long birželio 20 d. 11 val. 16:48 2011-06-20 16:48

Mano mėgstamiausia (:A..:Z).to_a.shuffle[0,8].join . Atkreipkite dėmesį, kad maišymui reikalingas Ruby> 1.9.

4
28 нояб. Atsakymą pateikė Josh . 2013-11-28 21:18 '13, 21:18, 2013-11-28 21:18

Šis sprendimas reikalauja išorinės priklausomybės, tačiau atrodo gražesnis nei kitas.

  • Įdiekite gem faker
  • Faker::Lorem.characters(10) # => "ang9cbhoa8"
4
18 сент. atsakymas davė asiniy 18 sep . 2015-09-18 19:12 '15 19:12 2015-09-18 19:12

Aš tiesiog random_token nedidelį random_token akmenį, kad sukurtume atsitiktinius žetonus daugumai naudojimo būdų

https://github.com/sibevin/random_token

3
03 дек. atsakymą pateikė Sibevin Wang 03 d. 2013-12-03 07:01 '13, 07:01 am 2013-12-03 07:01

Atsižvelgiant į:

 chars = [*('a'..'z'),*('0'..'9')].flatten 

Viena išraiška, kuri gali būti perduodama kaip argumentas, leidžia dublikatus simbolius:

 Array.new(len) { chars.sample }.join 
3
20 апр. Tim James atsakymas, pateiktas balandžio 20 d 2011-04-20 22:58 '11, 10:58 val. 2011-04-20 22:58
 ''.tap {|v| 4.times { v << ('a'..'z').to_a.sample} } 
3
04 окт. atsakymas suteiktas eric 04 oct. 2011-10-04 22:55 '11, 10:55 val. 2011-10-04 22:55

Neseniai aš kažką panašaus, kad generuotų 8 baitų atsitiktinę eilutę iš 62 simbolių. Simboliai buvo 0-9, az, AZ. Aš turėjau jų masyvą, kilpa buvo 8 kartus ir atsitiktinės vertės pasirinkimas iš masyvo. Tai buvo bėgių programoje.

str = '' 8.times {|i| str << ARRAY_OF_POSSIBLE_VALUES[rand(SIZE_OF_ARRAY_OF_POSSIBLE_VALUES)] }

Keista, kad gavau daug dublikatų. Dabar atsitiktine tvarka tai niekada nebus. 62 ^ 8 yra didžiulis, bet iš 1200 ar taip kodų, aš turėjau daug dublikatų. Pastebėjau, kad jie atsitinka vienas kito stebėjimo ribose. Kitaip tariant, aš galėjau pamatyti dublikatą 12:12:23 ir 2:12:22 arba kažką panašaus ... nežinote, ar laikas ar problema.

Šis kodas buvo sukurtas prieš kuriant aktyvintuvo turinį. Prieš kuriant šį įrašą šis kodas buvo pradėtas ir sukurtas „unikalus“ kodas. „Db“ įrašai visada buvo patikimai sukurti, tačiau kodas (str eilutėje) buvo pernelyg dažnai perduotas.

Sukūriau scenarijų, kad galėčiau šiek tiek vėluoti 100 000 šios eilutės iteracijų, todėl truktų 3-4 valandas tikėdamiesi, kad kas valandą matysiu kartotinį modelį, bet nieko nematau. Aš nežinau, kodėl tai vyksta mano bėgiai.

2
07 авг. atsakymas pateikiamas erik 07 rug. 2010-08-07 23:16 '10, 11:16 PM 2010-08-07 23:16

pabandykite

 def rand_name(len=9) ary = [('0'..'9').to_a, ('a'..'z').to_a, ('A'..'Z').to_a] name = '' len.times do name << ary.choice.choice end name end 

Man patinka atsakymai į temą, iš tiesų buvo labai naudingi! Bet jei galiu pasakyti, kad nė vienas iš jų neatitinka mano ayams, galbūt tai yra randas () metodas. man atrodo, kad tai nėra teisinga, nes turime būdą pasirinkti Array #.

2
22 февр. Manuel A. Guilamo atsakymas vasario 22 d 2011-02-22 07:08 '11 at 7:08 2011-02-22 07:08

Čia yra dar vienas būdas:

  • Jis naudoja saugų atsitiktinių skaičių generatorių vietoj „rand“ ()
  • Galima naudoti URL ir failų pavadinimuose.
  • Sudėtyje yra didžiosios ir mažosios raidės ir skaičiai.
  • Ar galima įtraukti dviprasmiškus simbolius I0l01

Reikalaujama require "securerandom"

 def secure_random_string(length = 32, non_ambiguous = false) characters = ('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a %w{IO l 0 1}.each{ |ambiguous_character| characters.delete ambiguous_character } if non_ambiguous (0...length).map{ characters[ActiveSupport::SecureRandom.random_number(characters.size)] }.join end 
2
24 авг. Atsakymas duotas Evgenii 24 rug. 2011-08-24 12:42 '11 at 12:42 2011-08-24 12:42

Naudodami šį metodą galite pereiti savavališkai. Jis nustatytas pagal nutylėjimą iki 6.

 def generate_random_string(length=6) string = "" chars = ("A".."Z").to_a length.times do string << chars[rand(chars.length-1)] end string end 
2
18 сент. Atsakymą pateikė Ryan Bigg . 2008-09-18 03:53 '08 at 3:53 2008-09-18 03:53

Man patinka, kad radaras atsako geriausiai, kol kas manau. Aš šiek tiek pakeisiu:

 CHARS = ('a'..'z').to_a + ('A'..'Z').to_a def rand_string(length=8) s='' length.times{ s << CHARS[rand(CHARS.length)] } s end 
2
18 сент. atsakymas pateikiamas webmat 18 sep . 2008-09-18 05:35 '08, 5:35 2008-09-18 05:35
  • 1
  • 2

Kiti klausimai apie žymas arba Užduoti klausimą