Come generare una stringa casuale in Ruby

Attualmente sto generando una stringa maiuscola pseudo-casuale di 8 caratteri per "A" .. "Z":

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

ma non sembra pulito e non può essere passato come argomento poiché non è una singola istruzione. Per ottenere una stringa in maiuscolo "a" .. "z" più "A" .. "Z", l'ho cambiata in:

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

ma sembra spazzatura.

Qualcuno ha un metodo migliore?

(0...8).map { (65 + rand(26)).chr }.join

Passo troppo tempo a giocare a golf.

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

E l'ultimo che è ancora più confuso, ma più flessibile e spreca meno cicli:

o = [('a'..'z'), ('A'..'Z')].map(&:to_a).flatten
string = (0...50).map { o[rand(o.length)] }.join

Perché non usare SecureRandom?

require 'securerandom'
random_string = SecureRandom.hex

# outputs: 5b5cd0da3121fc53b4bc84d0c8af2e81 (i.e. 32 chars of 0..9, a..f)

SecureRandom ha anche metodi per:

• Base64
• random_bytes
• numero casuale

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

Lo uso per generare stringhe casuali compatibili con URL con una lunghezza massima garantita:

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

Genera stringhe casuali di az minuscole e 0-9. Non è molto personalizzabile ma è corto e pulito.

Questa soluzione genera una stringa di caratteri facilmente leggibili per i codici di attivazione; Non volevo che le persone confondessero 8 con B, 1 con I, 0 con O, L con 1, ecc.

# 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 A C D E F G H J K M N P Q R T V W X Y Z}
  (0...size).map{ charset.to_a[rand(charset.size)] }.join
end

Altri hanno menzionato qualcosa di simile, ma questo utilizza la funzione sicura URL.

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

Il risultato può contenere AZ, az, 0-9, “-” e “_”. “=” Viene utilizzato anche se il riempimento è vero.

Da Ruby 2.5, è davvero facile con SecureRandom.alphanumeric:

len = 8
SecureRandom.alphanumeric(len)
=> "larHSsgL"

Genera stringhe casuali contenenti AZ, az e 0-9 e pertanto dovrebbe essere applicabile nella maggior parte dei casi d'uso. E sono generati in modo casuale sicuro, il che potrebbe anche essere un vantaggio.

Questo è un punto di riferimento per confrontarlo con la soluzione con il maggior numero di voti:

require 'benchmark'
require 'securerandom'

len = 10
n = 100_000

Benchmark.bm(12) do |x|
  x.report('SecureRandom') { n.times { SecureRandom.alphanumeric(len) } }
  x.report('rand') do
    o = [('a'..'z'), ('A'..'Z'), (0..9)].map(&:to_a).flatten
    n.times { (0...len).map { o[rand(o.length)] }.join }
  end
end

                   user     system      total        real
SecureRandom   0.429442   0.002746   0.432188 (  0.432705)
rand           0.306650   0.000716   0.307366 (  0.307745)

Quindi la randsoluzione richiede solo circa 3/4 del tempo di SecureRandom. Ciò potrebbe importare se generi molte stringhe, ma se di tanto in tanto creo qualche stringa casuale, andrei sempre con l'implementazione più sicura poiché è anche più facile da chiamare ed più esplicito.

[*('A'..'Z')].sample(8).join

Genera una stringa casuale di 8 lettere (ad esempio NVAYXHGR)

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

Genera una stringa casuale di 8 caratteri (ad es. 3PH4SWF2), esclude 0/1 / I / O. Ruby 1.9

Non riesco a ricordare dove l'ho trovato, ma mi sembra il processo migliore e meno intenso:

def random_string(length=10)
  chars = 'abcdefghjkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ0123456789'
  password = ''
  length.times { password << chars[rand(chars.size)] }
  password
end

require 'securerandom'
SecureRandom.urlsafe_base64(9)

Se si desidera una stringa di lunghezza specificata, utilizzare:

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

Genererà una stringa casuale di lunghezza 2ncontenente 0-9ea-f

Array.new(n){[*"0".."9"].sample}.join, dove n=8nel tuo caso.

Generalizzato:, Array.new(n){[*"A".."Z", *"0".."9"].sample}.joinecc.

Da: " Genera AZ stringa pseudo casuale, 0-9 ".

require 'sha1'
srand
seed = "--#{rand(10000)}--#{Time.now}--"
Digest::SHA1.hexdigest(seed)[0,8]

Ecco un codice semplice di una riga per stringa casuale con lunghezza 8:

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

Puoi anche usarlo per password casuali di lunghezza 8:

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

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"

Attenzione: randè prevedibile per un aggressore e quindi probabilmente insicuro. Dovresti assolutamente usare SecureRandom se questo è per generare password. Uso qualcosa del genere:

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

Ecco un semplice codice per password casuale con lunghezza 8:

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

Un altro metodo che mi piace usare:

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

Aggiungi ljustse sei davvero paranoico sulla lunghezza della stringa corretta:

 rand(2**256).to_s(36).ljust(8,'a')[0..7]

SecureRandom.base64(15).tr('+/=lIO0', 'pqrsxyz')

Qualcosa da Devise

Penso che questo sia un buon equilibrio tra concisione, chiarezza e facilità di modifica.

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

Facilmente modificato

Ad esempio, comprese le cifre:

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

Esadecimale maiuscolo:

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

Per una gamma davvero impressionante di personaggi:

characters = (32..126).to_a.pack('U*').chars.to_a

Sto solo aggiungendo i miei centesimi qui ...

def random_string(length = 8)
  rand(32**length).to_s(32)
end

È possibile utilizzare String#randomdalle Sfaccettature di Ruby Gem facets.

Fondamentalmente lo fa:

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

Il mio preferito è (:A..:Z).to_a.shuffle[0,8].join. Nota che shuffle richiede Ruby> 1.9.

Questa soluzione richiede dipendenza esterna, ma sembra più bella di un'altra.

1. Installa gemmafaker
2. Faker::Lorem.characters(10) # => "ang9cbhoa8"

Dato:

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

L'espressione singola, può essere passata come argomento, consente caratteri duplicati:

Array.new(len) { chars.sample }.join

Mi piace la risposta di Radar meglio, finora, penso. Modificherei un po 'così:

CHARS = ('a'..'z').to_a + ('A'..'Z').to_a
def rand_string(length=8)
  s=''
  length.times{ s << CHARS[rand(CHARS.length)] }
  s
end

''.tap {|v| 4.times { v << ('a'..'z').to_a.sample} }

I miei 2 centesimi:

  def token(length=16)
    chars = [*('A'..'Z'), *('a'..'z'), *(0..9)]
    (0..length).map {chars.sample}.join
  end

Scrivo solo una piccola gemma random_tokenper generare token casuali per la maggior parte dei casi d'uso, buon divertimento ~

https://github.com/sibevin/random_token

2 soluzioni per una stringa casuale composta da 3 intervalli:

(('a'..'z').to_a + ('A'..'Z').to_a + (0..9).to_a).sample(8).join

([*(48..57),*(65..90),*(97..122)]).sample(8).collect(&:chr)*""

Un personaggio per ogni intervallo.

E se hai bisogno di almeno un carattere per ogni intervallo, come la creazione di una password casuale con una lettera maiuscola, una lettera minuscola e una cifra, puoi fare qualcosa del genere:

( ('a'..'z').to_a.sample(8) + ('A'..'Z').to_a.sample(8) + (0..9).to_a.sample(8) ).shuffle.join 
#=> "Kc5zOGtM0H796QgPp8u2Sxo1"

Recentemente stavo facendo qualcosa del genere per generare una stringa casuale di 8 byte da 62 caratteri. I personaggi erano 0-9, az, AZ. Ne ho avuti un array come 8 volte in loop e selezionando un valore casuale dall'array. Questo era all'interno di un'app Rails.

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

La cosa strana è che ho ottenuto un buon numero di duplicati. Ora a caso questo non dovrebbe praticamente mai accadere. 62 ^ 8 è enorme, ma su circa 1200 codici nel db ho avuto un buon numero di duplicati. Ho notato che stavano accadendo a ore di distanza l'una dall'altra. In altre parole, potrei vedere un duplicato alle 12:12:23 e 2:12:22 o qualcosa del genere ... non sono sicuro che il problema sia il tempo.

Questo codice era nella creazione precedente di un oggetto ActiveRecord. Prima della creazione del record, questo codice veniva eseguito e generava il codice "univoco". Le voci nel DB venivano sempre prodotte in modo affidabile, ma il codice ( strnella riga sopra) veniva duplicato troppo spesso.

Ho creato uno script per eseguire 100000 iterazioni di questa riga sopra con un piccolo ritardo, quindi ci vorrebbero 3-4 ore sperando di vedere un qualche tipo di ripetizione su base oraria, ma non ho visto nulla. Non ho idea del perché ciò stesse accadendo nella mia app Rails.