Pregunta 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 un 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?


673


origen


Respuestas:


(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

876



¿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


734



Utilizo esto para generar cadenas aleatorias de URL aleatorias con una duración máxima garantizada:

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

Genera cadenas aleatorias de a-z en minúscula y 0-9. No es muy personalizable, pero es corto y limpio.


225



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

162



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

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 A-Z, a-z, 0-9, "-" y "_". "=" También se usa si el relleno es verdadero.


120



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

Genera 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


41



No recuerdo dónde encontré esto, pero parece ser el mejor y el menos intenso para mí:

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

29



require 'securerandom'
SecureRandom.urlsafe_base64(9)

27



Si quieres una cadena de longitud especificada, utiliza:

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

Generará una cadena aleatoria de longitud 2n conteniendo 0-9 y a-f


22