Cómo generar una cadena aleatoria en Ruby

Actualmente estoy generando una cadena mayúscula pseudoaleatoria de 8 caracteres para "A" .. "Z":

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

pero no se ve limpio, y no se puede pasar como argumento ya que no es una sola declaración. Para obtener una cadena de mayúsculas y minúsculas "a" .. "z" más "A" .. "Z", la cambié a:

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

Pero parece basura.

¿Alguien tiene un mejor método?

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

Paso demasiado tiempo jugando al golf.

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

Y una última que es aún más confusa, pero más flexible y desperdicia menos ciclos:

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

¿Por qué no usar SecureRandom?

require 'securerandom'
random_string = SecureRandom.hex

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

SecureRandom también tiene métodos para:

• base64
• random_bytes
• número aleatorio

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

Lo uso para generar cadenas aleatorias de URL amigables con una longitud máxima garantizada:

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

Genera cadenas aleatorias de minúsculas az y 0-9. No es muy personalizable, pero es corto y limpio.

Esta solución genera una cadena de caracteres fácilmente legibles para los códigos de activación; No quería que las personas confundieran 8 con B, 1 con I, 0 con O, L con 1, etc.

# 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

Otros han mencionado algo similar, pero esto utiliza la función segura de URL.

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

El resultado puede contener AZ, az, 0-9, "-" y "_". "=" También se usa si el relleno es verdadero.

Desde Ruby 2.5, es realmente fácil con SecureRandom.alphanumeric:

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

Genera cadenas aleatorias que contienen AZ, az y 0-9 y, por lo tanto, deberían ser aplicables en la mayoría de los casos de uso. Y se generan aleatoriamente seguros, lo que también podría ser un beneficio.

Este es un punto de referencia para compararlo con la solución que tiene más votos a favor:

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)

Entonces, la randsolución solo toma alrededor de 3/4 del tiempo de SecureRandom. Eso podría importar si genera muchas cadenas, pero si solo crea alguna cadena aleatoria de vez en cuando, siempre iría con la implementación más segura, ya que también es más fácil de llamar y más explícita.

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

Genere una cadena aleatoria de 8 letras (por ejemplo, NVAYXHGR)

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

Genere una cadena aleatoria de 8 caracteres (por ejemplo, 3PH4SWF2), excluye 0/1 / I / O. Ruby 1.9

No recuerdo dónde encontré esto, pero me parece el mejor y el menos intenso proceso:

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

require 'securerandom'
SecureRandom.urlsafe_base64(9)

Si desea una cadena de longitud especificada, use:

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

Generará una cadena aleatoria de longitud que 2ncontiene 0-9ya-f

Array.new(n){[*"0".."9"].sample}.join, dónde n=8 en tu caso.

Generalizado: Array.new(n){[*"A".."Z", *"0".."9"].sample}.join etc.

De: " Generar cadena pseudoaleatoria AZ, 0-9 ".

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

Aquí hay un código simple de una línea para una cadena aleatoria con longitud 8:

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

También puede usarlo para una contraseña aleatoria que tenga una longitud 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"

Tenga en cuenta: randes predecible para un atacante y, por lo tanto, probablemente inseguro. Definitivamente debe usar SecureRandom si esto es para generar contraseñas. Yo uso algo como esto:

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

Aquí hay un código simple para contraseña aleatoria con longitud 8:

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

Otro método que me gusta usar:

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

Agregue ljustsi está realmente paranoico sobre la longitud correcta de la cadena:

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

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

Algo de idear

Creo que este es un buen equilibrio de concisión, claridad y facilidad de modificación.

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

Modificado fácilmente

Por ejemplo, incluidos los dígitos:

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

Hexadecimal mayúscula:

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

Para una variedad realmente impresionante de personajes:

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

Solo agrego mis centavos aquí ...

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

Puedes usar String#randomdesde Facets of Ruby Gemfacets .

Básicamente hace esto:

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

Mi favorito es (:A..:Z).to_a.shuffle[0,8].join. Tenga en cuenta que barajar requiere Ruby> 1.9.

Esta solución necesita dependencia externa, pero parece más bonita que otra.

1. Instalar falsificador de gemas
2. Faker::Lorem.characters(10) # => "ang9cbhoa8"

Dado:

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

La expresión única, se puede pasar como argumento, permite caracteres duplicados:

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

Me gusta más la respuesta de Radar, hasta ahora, creo. Ajustaría un poco así:

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} }

Mis 2 centavos:

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

Acabo de escribir una pequeña gema random_tokenpara generar tokens aleatorios para la mayoría de los casos de uso, disfruta ~

https://github.com/sibevin/random_token

2 soluciones para una cadena aleatoria que consta de 3 rangos:

(('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 personaje de cada rango.

Y si necesita al menos un carácter de cada rango, como crear una contraseña aleatoria que tenga una letra mayúscula, una letra minúscula y un dígito, puede hacer algo como esto:

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

Estaba haciendo algo como esto recientemente para generar una cadena aleatoria de 8 bytes a partir de 62 caracteres. Los caracteres fueron 0-9, az, AZ. Tuve una matriz de ellos, ya que estaba haciendo un bucle 8 veces y seleccionando un valor aleatorio de la matriz. Esto estaba dentro de una aplicación Rails.

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

Lo extraño es que obtuve una buena cantidad de duplicados. Ahora al azar esto casi nunca debería suceder. 62 ^ 8 es enorme, pero de 1200 más o menos códigos en la base de datos tuve una buena cantidad de duplicados. Me di cuenta de que ocurrían en límites de horas entre sí. En otras palabras, podría ver un duplicado a las 12:12:23 y 2:12:22 o algo así ... no estoy seguro si el tiempo es el problema o no.

Este código estaba en la creación anterior de un objeto ActiveRecord. Antes de que se creara el registro, este código se ejecutaría y generaría el código 'único'. Las entradas en el DB siempre se produjeron de manera confiable, pero el código (str en la línea anterior) se duplicaba con demasiada frecuencia.

Creé un script para ejecutar 100000 iteraciones de esta línea anterior con un pequeño retraso, por lo que tomaría de 3 a 4 horas con la esperanza de ver algún tipo de patrón de repetición por hora, pero no vi nada. No tengo idea de por qué sucedía esto en mi aplicación Rails.