Cómo generar una cadena aleatoria en Rubí

Actualmente estoy generando un carácter de 8 pseudo-aleatorio en mayúsculas de la cadena para la «A» .. «Z»:

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

pero no se ve limpio, y no puede ser pasado como argumento, ya que no es una sola instrucción. Para obtener un caso mixto de cadena «a» .. «z» plus «A» .. «Z», he cambiado a:

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

pero se ve como basura.

¿Alguien tiene un método mejor?

  • No entiendo por qué te importa que «ya no es una sola declaración no puede ser pasado como argumento». ¿Por qué no acaba de llegar una utilidad o método helper?
  • Supongamos que hay un método para restablecer la contraseña de un usuario y que tiene un argumento para la nueva contraseña. Me gustaría pasar una cadena aleatoria, en el código de arriba necesito una variable, mientras que en la sola declaración de los ejemplos de abajo que puedo hacer toda la cosa como un forro. Seguro que un método de utilidad podría ser bueno en el largo plazo, esp si yo estoy necesitando similar aquí y allá, pero a veces usted sólo quiere en su lugar, un tiempo, de hecho.
  • No, usted no tiene que usar una variable temporal. Intente esto: reset_user_password!(random_string) donde def random_string; SecureRandom.urlsafe_base64(20) end
  • 8 cartas es vergonzosamente contraseña débil. Dada la suma de control md5 de un PC moderno podría recuperar la contraseña en 30 segundos. ¿Algo más securerandom.urlsafe_base64
  • Lol, aceptar que se le pidió en 2008, que le permite golpe que hasta el 15 o así.
  • ¿Por qué tiene tantas respuestas? No es que no es una pregunta útil, pero tengo curiosidad por cómo ha atraído la atención.
  • bien, poner un diseñador de páginas web en frente de VIM y le pide que le guarde y salga; Bromas aparte. require 'securerandom'; SecureRandom.hex(15) debería funcionar bien

50 Kommentare

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

    Puedo dedicar demasiado tiempo a jugar al golf.

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

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

    o = [('a'..'z'), ('A'..'Z')].map(&:to_a).flatten
    string = (0...50).map { o[rand(o.length)] }.join
    • 34 caracteres y asombrosamente rápido: ('a'..'z').to_a.shuffle[0,8].join. Nota necesitará Ruby >=1.9 a shuffle.
    • primer ejemplo debe ser rand(26) de lo contrario nunca aparece la letra ‘Z’
    • El aprovechamiento de las bibliotecas existentes es preferible a menos que usted tiene una licencia de rodar sus propios. Ver SecureRandom como un ejemplo, en las otras respuestas.
    • su método no es funcionalmente a la misma, no al azar con reemplazo.
    • Touche @michaeltwofish. He aquí el menor y más eficiente de una línea que podía reunir: [].fill(0,l){rand(65..90).chr}.join (35 caracteres). fill es más rápido que map, pero para un rendimiento real, la caída del campo de golf y crear previamente la matriz con un correcto el uso de sample: chars=["A", "B", "C", "D", "E", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"];[].fill(0,l){chars.sample}.join Que ni siquiera significativamente más rápido de 8 caracteres. Con 8 caracteres, no se preocupe. Nada moscas. 😉 A ver mi lleno de puntos de referencia para obtener más detalles.
    • [*('a'..'z'),*('0'..'9')].shuffle[0,8].join para generar una cadena aleatoria con letras y números.
    • rand es determinista y predecible. No los utilice para la generación de contraseñas! Utilice uno de los SecureRandom soluciones en su lugar.
    • el último ejemplo que debe leer (0...50).map { [('a'..'z'),('A'..'Z')].flat_map(&:to_a).sample }.join definitivamente no gastado también mucho tiempo de golf xD
    • más reducido de Dennis respuesta (0..50).map { [*'a'..'z',*'A'..'Z'].sample }.join
    • Acabo de crear un módulo RandomString que resume las tres principales técnicas que se mencionan en todas las respuestas: gist.github.com/jopotts/8706578
    • Utilice siempre las soluciones existentes, como SecureRandom en favor de cosecha propia «al azar» de soluciones. En serio, ellos están ahí por una razón.
    • Como el OP de esta respuesta estoy de acuerdo con todos los sentimientos con respecto a la «utilización demostrado herramientas probadas». Justo en el momento de esta respuesta, tales herramientas no eran fundamentales, sin embargo, y autor parecía haber golf como un objetivo. La comprensión de cómo su funciona el lenguaje es tan importante como el uso de herramientas escritas en el idioma.
    • Las soluciones con shuffle no ser que impresionante, como se había generar cadenas con una aparición de un personaje ( por lo de la cadena, tales como «gbalgqut» sería imposible – doble «g» )
    • Si el golf es el objetivo, ('a'..'z') es idéntica a (?a..?z); dos caracteres que se almacenan.

  2. 785

    ¿Por qué no utilizar 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
    • random_number

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

    • Esto genera cadenas que no son seguros para pasar como obtener las variables para sitios web – por ejemplo, usted puede conseguir cadena=+fGH1 (+ se lee como un espacio), y la cadena de=fyhi/ (la barra se utiliza para la navegación)
    • base64, pero no hexadecimal como en su ejemplo
    • Por el camino, es parte de la stdlib en 1.9 y reciente 1.8 versiones, así que uno sólo puede require 'securerandom' para obtener esta limpia SecureRandom helper 🙂
    • no, eso es incorrecto. SecureRandom.base64 => "7p0lfNClJwolM9BJcgG5lQ==" como se puede ver, hay = en ella. Método hex sólo devuelve 0-9a-f
    • BTW SecureRandom fue retirado de ActiveSupport en la versión 3.2. El changelog: «Quita ActiveSupport::SecureRandom en favor de SecureRandom de la biblioteca estándar».
    • SecureRandom.random_number(36**12).to_s(36).rjust(12, "0") generará una cadena con 0-9a-z (36 caracteres) que SIEMPRE es de 12 caracteres de largo. Cambio de 12 a cualquier longitud que usted desea. Por desgracia no acaba de llegar a a la Z el uso de Integer#to_s.
    • que está mal. Si quería pasar +fGH1 a través de una URL, solo necesitas la URL de codificar como lo haría con CUALQUIER valor que va a través de una URL: %2BfGH1
    • Para generar una cadena que contiene sólo 5 caracteres alfanuméricos que usted podría hacer esto SecureRandom.hex.gsub(/\d/, "")[0..4]
    • Hola, me gusta SecureRandom, pero ¿cómo puedo obtener una cadena de 6 números, cada dígito con rango de 0-9. Y me gustaría que de una manera que es fácil para auxiliar en mi Rieles controlador de especificación.
    • Traté de ‘SecureRandom.random_number(9**6)’ pero a veces devuelve 5 números, pero a veces devuelve 6 números.
    • ¿Cuáles son las posibilidades de conseguir un duplicado?

  3. 246

    Puedo usar esto para la generación aleatoria de URL amigable cadenas con un garantizado longitud máxima:

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

    Se genera al azar cadenas de caracteres a-z y 0-9. No es muy personalizable, pero es corto y limpio.

    • +1 para el menor de la versión (que no llame a los binarios externos ^^). Si la cadena de caracteres aleatoria no está a la vista del público, a veces incluso sólo uso rand.to_s; feo, pero funciona.
    • Esta es una gran solución (y rápido, demasiado), pero ocasionalmente se producen una cadena de en length de longitud, aproximadamente una vez en ~40
    • E este sería garantía de los dígitos que desea: (36**(length-1) + rand(36**length)).to_s(36). 36**(longitud-1) convierten a 36 base es de 10**(longitud-1), que es el valor más pequeño que tiene la longitud de dígitos que desee.
    • Estás solución también producir fichas de más de length.
    • Aquí está la versión siempre la producción de fichas de la longitud deseada: (36**(length-1) + rand(36**length - 36**(length-1))).to_s(36)
    • Sí, +1 de la brevedad y la falta de dependencias.
    • La solución no siempre producen los tokens de la longitud deseada
    • Este escupe un error para mí en Rails 4 y Ruby 2.1.1: NameError: undefined local variable or method longitud » principal:el Objeto`
    • Se me acaba la paciencia antes de que termine de: while true do v = rand(36 ** 2); l = v.to_s(36).length; if l > 2 then puts v end end
    • Eso es porque no prueba para las cadenas de bajo de la longitud deseada…
    • Esto le dará una longitud exacta: Random.new.rand( 36**(length-1) ... 36**length ).to_s( 36 )
    • Si usted necesita la velocidad y la longitud exacta, también puede utilizar este, que corre alrededor de 20 veces más rápido que en mi último comentario: ( rand * (36**length - 36**(length-1) ) + 36**(length-1) ).floor.to_s( 36 ). No es tan legible aunque, por lo que la colocaría en una función. Probablemente la más sencilla sería la de generar algo que está garantizado a ser para largo, y luego truncar.
    • Estoy usando esto para generar 6 char fichas de una manera muy simple: rand(36**11).to_s(36).upcase[0,6] es decir, hacer de la cadena original de forma segura el tiempo suficiente y, a continuación, tomar cualquier N caracteres de ella

  4. 172

    Esta solución genera una cadena de caracteres fácilmente legibles para los códigos de activación; no quería que la gente confunde con 8 B, 1 con I, 0 con S, 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
    • Gracias, esto es exactamente lo que yo quería hacer.
    • No podía usted sólo tiene que utilizar charset.sample en lugar de charset.to_a[rand(charset.size)?
    • si usted está usando Ruby 1.9 o Rieles, a continuación, sí. Llanura 1.8.7, a continuación, no.
    • Es la ‘U’ ambiguo o que es un error tipográfico?
    • Yep. U y V son ambigvovs.
    • V en allí, sin embargo.
    • Para ser seguro que usted también desea utilizar SecureRandom.random_number(charset.size) en lugar de rand(charset.size)
    • Yo sólo estaba tratando de mejorar en esto, mediante la adición de minúsculas y/o algunos caracteres especiales (shift+num), y tiene las siguientes listas: %w{ A C D E F G H J K L M N P Q R T W X Y Z 2 3 4 6 7 9 ! @ # $ % ^ & * +} y %w{ A D E F G H J L N Q R T Y a d e f h n r y 2 3 4 7 ! @ # $ % ^ & * } (primera lista no incluye el menor caso, pero es más largo) un Poco interesante la forma en que salió.

  5. 128

    Otros han mencionado algo similar, pero este usa la URL de la caja fuerte de la función.

    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 «_». «=» se utiliza también si el relleno es cierto.

    • Esto es exactamente lo que yo estaba buscando. Gracias!
  6. 61

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

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

    Se genera al azar cadenas que contiene a-Z, a-z y 0-9 y por lo tanto debe ser aplicable en la mayoría de los casos de uso. Y que se genera de forma aleatoria segura, lo que podría ser un beneficio, también.


    Este es un punto de referencia para comparar con la solución de tener la mayoría de upvotes:

    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)

    Por lo que el rand solución, sólo toma alrededor de 3/4 de tiempo de SecureRandom. Que podría importa si se genera una gran cantidad de cadenas de caracteres, pero si usted acaba de crear algunos cadena aleatoria de vez en cuando me gustaría ir siempre con la más segura de la aplicación ya que también es más fácil llamar y más explícita.

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

    Generar al azar 8 de la carta de la cadena (por ejemplo, NVAYXHGR)

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

    Generar al azar 8 cadena de caracteres (por ejemplo, 3PH4SWF2), excluye 0/1/I/O. Ruby 1.9

    • El único problema es que cada carácter en el resultado es único. Los límites de los valores posibles.
    • Si esto función de solicitud pasa a través de, Ruby 1.9.x puede terminar con #de muestra para muestreo sin sustitución y #elección para el muestreo con reemplazo.
    • Esto es un error, creo que usted necesita … [*("A".."Z")]' ; ((no solo qoutes))
    • puede usted decirme cómo puedo stub esta para rspec a pasar.
  8. 31

    No recuerdo donde he encontrado esto, pero parece que la mejor y la menos proceso intensivo para mí:

    def random_string(length=10)
      chars = 'abcdefghjkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ0123456789'
      password = ''
      length.times { password << chars[rand(chars.size)] }
      password
    end
    • Tal vez usted se encuentra aquí? travisonrails.com/2007/06/07/generate-random-text-with-ruby
    • No hay un 0 y 1 falta de esto?
    • Parece que podría ser donde lo he encontrado.
    • Y ya, no se ve igual que 0 y 1 son los que faltan.
    • El 0 y 1 y O y I fueron intencionalmente falta porque los personajes son ambiguos. Si este tipo de código se utiliza para generar un conjunto de caracteres que un usuario necesita para copia, es mejor excluir caracteres que pueden ser difíciles de distinguir fuera de contexto.
  9. 27
    require 'securerandom'
    SecureRandom.urlsafe_base64(9)
    • SecureRandom es una excelente lib. Yo no sabía que estaba allí. Gracias.
    • old skool (y feo) alternativa: Random.new.bytes(9)
    • por cierto, urlsafe_base64 devuelve una cadena alrededor de 4/3 de la longitud indicada. Para obtener una cadena de exactamente n caracteres de largo, trate de n=9 ; SecureRandom.urlsafe_base64(n)[0..n-1]
  10. 25

    Si quieres una cadena de longitud especificada, uso:

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

    Va a generar una cadena aleatoria de longitud 2n que contiene 0-9 y a-f

    • Que no genera una cadena de longitud n, en realidad genera una cadena de 4/3 de n.
  11. 11
    require 'sha1'
    srand
    seed = "--#{rand(10000)}--#{Time.now}--"
    Digest::SHA1.hexdigest(seed)[0,8]
    • Interesante, pero un poco más costosas computacionalmente
    • También la capacidad de alcance limitado de caracteres.
    • Tenga en cuenta que un hex de digerir devuelve sólo 0-9 y a-f caracteres.
  12. 10

    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"
    • El map solución es muy bonito!
    • Usted puede pedir #sample de cómo muchos de los elementos que desee. E. g. ALPHABET.sample(10).joinruby-doc.org/core-2.4.0/Array.html#method-i-sample
    • Que es realmente malo. sample(10) da 10 muestras únicas. Pero desea permitir que repita. Pero me gustaría utilizar Array.new(10).map para el rendimiento
    • Yo quería alfanumérico con tanto superior e inferior de los casos. También he cambiado para utilizar Array.new y su bloque de sintaxis. Array.new(20) { [*'0'..'9', *'a'..'z', *'A'..'Z'].sample }.join
  13. 10

    Aquí es una línea de código sencillo para cadena aleatoria con una longitud de 8:

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

    También se puede utilizar para la contraseña aleatoria que tienen una longitud de 8:

    random_password = ('0'..'z').to_a.shuffle.first(8).join
    • Usted no debe usar este para generar usted mismo una contraseña, ya que este método nunca se repita un personaje. Por lo tanto, sólo está utilizando P(36, 8) / 36^8 = 0.4 de la posible carácter de espacio de 8 caracteres (~2x más fácil a la fuerza bruta) o P(36, 25) / 36^25 = 0.00001 de los caracteres posibles de espacio para 25 caracteres (~100.000 x más fácil a la fuerza bruta).
  14. 8

    Ser consciente: rand es predecible para un atacante y por lo tanto probablemente inseguro. Definitivamente, usted debe utilizar SecureRandom si esto es para la generación de 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
    • Este es probablemente el «más seguro» de solución. SecureRandom intenta utilizar subyacente de seguridad de la Api proporcionada por el sistema operativo. Si usted tiene OpenSSL se va a utilizar, si estás en Windows va a ir la mejor opción que hay. Me gusta especialmente esta solución, ya que le permite especificar un conjunto de caracteres para su uso. A pesar de que no va a funcionar si el conjunto de caracteres es mayor que el máximo valor de un byte: 255. Recomiendo ver el código fuente para SecureRandom en el doc: ruby-doc.org/stdlib-1.9.3/libdoc/securerandom/rdoc/…
  15. 8

    Aquí es un simple código de contraseña aleatoria con una longitud de 8:

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

    Otro método me gusta usar:

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

    Agregar ljust si eres muy paranoico acerca de la correcta longitud de la cadena:

     rand(2**256).to_s(36).ljust(8,'a')[0..7]
    • Incluso mejor para agarrar la parte menos significativa del número aleatorio usando el lado derecho de la cadena de: rand(2**64).to_s(36)[-10,10]
  17. 6
    SecureRandom.base64(15).tr('+/=lIO0', 'pqrsxyz')

    Algo de Idear

    • ¿Por qué es la sustitución de la cadena de caracteres utilizando .tr('+/=lIO0', 'pqrsxyz')?
    • Los caracteres especiales porque no están en la dirección URL segura. Y l/I o O/0, porque son de muy fácil confundirse si se utiliza la técnica para generar legible contraseñas de usuario.
    • Que función tiene un poco de inclinación hacia ciertos personajes. También para otras longitudes (por ejemplo, 16), el último carácter no será al azar. He aquí una manera de evitar eso. SecureRandom.base64(64).tr(‘+/=lIO01’, «)[0,16]
  18. 5

    Creo que este es un buen equilibrio de la concisión, la claridad y la 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

    Fácilmente modificado

    Incluyendo, por ejemplo, los dígitos:

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

    Mayúsculas hexadecimal:

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

    Para un verdaderamente impresionante variedad de personajes:

    characters = (32..126).to_a.pack('U*').chars.to_a
    • lo recomiendo solo usar letras mayúsculas + números, también eliminar el «confuso» queridos charset = (1..9).to_a.concat((‘A’..’Z’).to_a).rechazar{ |a| [0, 1, ‘O’, ‘I’].incluir?(a) } (0…tamaño).mapa{ charset[rand(charset.tamaño)] }.únete
  19. 5

    Sólo añadir mi centavos aquí…

    def random_string(length = 8)
      rand(32**length).to_s(32)
    end
    • PD: esto no siempre devuelven un string exactamente +longitud+ de larga puede ser más breve. Depende de la cantidad devuelta por rand
  20. 5

    Puede utilizar String#random de las Facetas de la Gema de Ruby facets.

    Que 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
  21. 4

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

  22. 4

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

    1. Instalar la gema faker
    2. Faker::Lorem.characters(10) # => "ang9cbhoa8"
  23. 4

    Dado:

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

    Sola expresión, puede ser pasado como argumento, permite duplicar personajes:

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

    Me gusta Radar respuesta mejor, hasta ahora, creo. Me gustaría retocar un poco como esto:

    CHARS = ('a'..'z').to_a + ('A'..'Z').to_a
    def rand_string(length=8)
      s=''
      length.times{ s << CHARS[rand(CHARS.length)] }
      s
    end
    • ¿Por qué no utilizar (CHARS*length).sample(length).join?
    • Esta sugerencia podría generar un ponderado de la cadena, en favor de la no-caracteres repetidos. Por ejemplo, si CHARS=['a','b'], a continuación, su método podría generar "aa" o "bb" sólo el 33% del tiempo, pero "ab" o "ba" el 67% del tiempo. Tal vez eso no es un problema, pero vale la pena teniendo en mente!
    • buen punto, @TomLord, creo que en realidad no se dan cuenta de que cuando me envió la propuesta (aunque debo admitir que no recuerdo la publicación de que a todos :D)
  25. 3

    Mis 2 centavos:

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

    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)*""

    Uno de los personajes de cada uno de ellos.

    Y si es necesario al menos un personaje de cada gama, tales como la creación de una contraseña aleatoria que tiene una mayúscula, una letra minúscula y un dígito, usted 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"
    • Y si desea aplicar un cierto número de cada intervalo, se podría hacer algo como esto: ( ('a'..'z').to_a.sample(8) + ('A'..'Z').to_a.sample(8) + (0..9).to_a.sample(8) + [ "%", "!", "*" ].sample(8) ).shuffle.join #=> "Kc5zOGtM0*H796QgPp%!8u2Sxo1"
  27. 3

    Yo estaba haciendo algo como esto recientemente para generar un byte de 8 cadena aleatoria de 62 caracteres. Los caracteres 0-9,a-z,A-Z. tuve una variedad de ellos, como fue el bucle de 8 veces y escoger un valor aleatorio de la matriz. Este 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 tengo buen número de duplicados. Ahora al azar esta debe bastante mucho nunca sucederá. 62^8 es enorme, pero fuera de 1200 o así los códigos en el db he tenido un buen número de duplicados. Me di cuenta de que se están realizando en la hora de los límites de cada uno de los otros. En otras palabras, se podría ver un duple 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 fue en el antes de crear un objeto ActiveRecord. Antes de que se creó el registro de este código se ejecuta y generar la «única» del código. Las entradas en la base de datos se produce siempre de forma fiable, pero el código (str en la línea anterior), se duplican demasiado a menudo.

    He creado un script para que se ejecute a través de 100000 iteraciones de esta línea de arriba con un pequeño retraso, por lo que podría tomar de 3-4 horas con la esperanza de ver algún tipo de repetición del patrón en una hora, pero no vi nada. No tengo idea de por qué estaba pasando esto en mi aplicación Rails.

  28. 2

    Con este método se puede pasar en un abitrary de longitud. Se establece como predeterminado 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
  29. 2

    Aquí es otro método:

    • Utiliza el seguro generador de números aleatorios en lugar de rand()
    • Puede ser utilizado en las direcciones Url y los nombres de archivo
    • Contiene mayúsculas, minúsculas y números
    • Tiene la opción de no incluir personajes ambiguos I0l01

    Necesidades 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{I O 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
  30. 2

    probar esto

    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

    Me encanta las respuestas del hilo, han sido de mucha ayuda, de verdad!, pero si puedo decir, ninguno de ellos satisface mis ayes, tal vez es el rand() método. simplemente no parece correcto para mí, ya que tenemos la Matriz#método de elección para esa materia.

  31. 2

    Si usted está en UNIX y aún debe utilizar Ruby 1.8 (no SecureRandom) sin Rieles, también puede utilizar este:

    random_string = `openssl rand -base64 24`

    Nota este modo, se genera nuevo shell, este es muy lento y puede ser recomendado solo para secuencias de comandos.

  32. 2

    Otro truco que funciona con Ruby 1.8+ y es rápido es de:

    >> require "openssl"
    >> OpenSSL::Random.random_bytes(20).unpack('H*').join
    => "2f3ff53dd712ba2303a573d9f9a8c1dbc1942d28"

    Es al azar hex. De manera Similar, usted debe ser capaz de generar la cadena base64 (‘M*’).

  33. 1

    Esto se basa en un par de otras respuestas, pero añade un poco más de complejidad:

    def random_password
      specials = ((32..47).to_a + (58..64).to_a + (91..96).to_a + (123..126).to_a).pack('U*').chars.to_a
      numbers  = (0..9).to_a
      alpha    = ('a'..'z').to_a + ('A'..'Z').to_a
      %w{i I l L 1 O o 0}.each{ |ambiguous_character| 
        alpha.delete ambiguous_character 
      }
      characters = (alpha + specials + numbers)
      password = Random.new.rand(8..18).times.map{characters.sample}
      password << specials.sample unless password.join =~ Regexp.new(Regexp.escape(specials.join))
      password << numbers.sample  unless password.join =~ Regexp.new(Regexp.escape(numbers.join))
      password.shuffle.join
    end

    Esencialmente garantiza una contraseña que es de 8 a 20 caracteres de longitud, y que contiene al menos un número y un carácter especial.

  34. 1
    10.times do 
      alphabet = ('a'..'z').to_a
      string += alpha[rand(alpha.length)]
    end
  35. 1

    Para idear secure_validatable puede utilizar este

    (0…8).mapa { ([65, 97].muestra + rand(26)).chr }.push(rand(99)).únete a

    • Para generar una contraseña aleatoria utilizando mayúsculas, minúsculas, números y caracteres especiales, he utilizado algo como: random_ascii_character = -> { (33..126).to_a.sample.chr }; 8.times.map { random_ascii_character.call }.shuffle.join
  36. 0

    Para hacer su primera vez en una declaración:

    (0...8).collect { |n| value  << (65 + rand(25)).chr }.join()
  37. 0

    Hemos estado usando este código:

    class String
    
      def self.random(length=10)
        ('a'..'z').sort_by {rand}[0,length].join
      end
    
    end

    La longitud máxima soportada es de 25 (sólo estamos utilizando con el valor predeterminado de todos modos, así que no ha sido un problema).

    Alguien mencionó que ‘a’..’z’ es óptimo si desea evitar completamente la generación de palabras ofensivas. Una de las ideas que tuvimos fue la eliminación de las vocales, pero todavía puede terminar con WTFBBQ etc.

    • Su enfoque no puede devolver la repetición de caracteres (e.g, uuunMoBldj)… Es esto lo que quería?
    • Sí, supongo que técnicamente no es realmente una cadena aleatoria ya, bueno encontrar webmat.
  38. 0
    `pwgen 8 1`.chomp
    • Errno::ENOENT: No tal archivo o directorio – pwgen 8 1
  39. 0

    Crear una cadena vacía o una pre-revisión si requieren:

    myStr = "OID-"

    Utilizar este código para rellenar la cadena con números aleatorios:

    begin; n = ((rand * 43) + 47).ceil; myStr << n.chr if !(58..64).include?(n); end while(myStr.length < 12)

    Notas:

    (rand * 43) + 47).ceil

    Va a generar números al azar de 48-91 (0,1,2..Y,Z)

    !(58..64).include?(n)

    Que se utiliza para omitir los caracteres especiales (como no me interesa para incluirlos)

    while(myStr.length < 12)

    Generará un total de 12 caracteres de la cadena, incluyendo prefijo.

    Ejemplo De Salida:

    "OID-XZ2J32XM"
  40. 0

    He aquí una solución que es flexible y permite que los paquetes de actualización de dell:

    class String
      # generate a random string of length n using current string as the source of characters
      def random(n)
        return "" if n <= 0
        (chars * (n / length + 1)).shuffle[0..n-1].join  
      end
    end

    Ejemplo:

    "ATCG".random(8) => "CGTGAAGA"

    También puede permitir un cierto carácter a aparecer con más frecuencia:

    "AAAAATCG".random(10) => "CTGAAAAAGC"

    Explicación:
    El método anterior tiene los caracteres de una cadena dada y genera una lo suficientemente grande como matriz. Luego se baraja es, toma los primeros n elementos, entonces se une a ellos.

  41. 0
    Array.new(8).inject(""){|r|r<<('0'..'z').to_a.shuffle[0]}  # 57
    (1..8).inject(""){|r|r<<('0'..'z').to_a.shuffle[0]}        # 51
    e="";8.times{e<<('0'..'z').to_a.shuffle[0]};e              # 45
    (1..8).map{('0'..'z').to_a.shuffle[0]}.join                # 43
    (1..8).map{rand(49..122).chr}.join                         # 34
  42. 0
    a='';8.times{a<<[*'a'..'z'].sample};p a

    o

    8.times.collect{[*'a'..'z'].sample}.join
  43. 0

    Aquí es una mejora de @Travis R respuesta:

     def random_string(length=5)
        chars = 'abdefghjkmnpqrstuvwxyzABDEFGHJKLMNPQRSTUVWXYZ'
        numbers = '0123456789'
        random_s = ''
        (length/2).times { random_s << numbers[rand(numbers.size)] }
        (length - random_s.length).times { random_s << chars[rand(chars.size)] }
        random_s.split('').shuffle.join
      end

    A @Travis R respuesta caracteres y números estaban juntos, así que a veces random_string podría volver solo números o sólo los personajes. Con esto mejorar al menos la mitad de random_string serán los caracteres y el resto son números. En caso de que si usted necesita una cadena aleatoria con números y caracteres

  44. 0

    El Uso De ‘SafeRandom’ Joya GithubLink

    Proporcionará la forma más sencilla de generar valores aleatorios para Rails2, Rails 3, Carriles 4, 5 Rieles compatible.

  45. -1

    Esto es casi tan feo, pero tal vez como paso en la dirección correcta?

     (1..8).map{|i| ('a'..'z').to_a[rand(26)]}.join
    • 🙂 Me encanta la pistola más rápida, de una manera perversa
  46. -1

    En ruby 1.9 se puede utilizar la Matriz de la elección del método que devuelve al azar elemento de la matriz

  47. -10

    No sé ruby, así que no te puedo dar la sintaxis exacta, pero yo le pondría una cadena constante con la lista de caracteres aceptables, a continuación, utilizar la subcadena operador para elegir un carácter aleatorio de ella.

    La ventaja aquí es que si la cadena se supone que el usuario enterable, entonces usted puede excluir fácilmente confundido personajes como l y 1 y i, 0 y S, 5 S, etc.

    • Si usted no sabe Ruby, ¿por qué molestarse en contestar? :/
    • Debido a que la generación de usuario enterable azar cadenas que parecen 0OiIlZ25S hace llorar al niño Jesús, y yo quería señalar que si la cadena de caracteres aleatoria, era algo que los seres humanos necesitan reflexionar, a continuación, SÓLO tal vez podría tocaría a alguien que considere que, el Señor Hall Monitor.

Kommentieren Sie den Artikel

Bitte geben Sie Ihren Kommentar ein!
Bitte geben Sie hier Ihren Namen ein

Pruebas en línea