Como gerar uma string aleatória no Ruby

No momento, estou gerando uma sequência maiúscula pseudo-aleatória de 8 caracteres para "A" .. "Z":

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

mas não parece limpo e não pode ser passado como argumento, pois não é uma declaração única. Para obter uma sequência de maiúsculas e minúsculas "a" .. "z" mais "A" .. "Z", mudei para:

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

mas parece lixo.

Alguém tem um método melhor?

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

Eu gasto muito tempo jogando golfe.

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

E um último que é ainda mais confuso, mas mais flexível e gasta menos ciclos:

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

Por que não usar o SecureRandom?

require 'securerandom'
random_string = SecureRandom.hex

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

O SecureRandom também possui métodos para:

• base64
• random_bytes
• número aleatório

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

Eu uso isso para gerar seqüências amigáveis ​​de URL aleatórias com um comprimento máximo garantido:

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

Ele gera seqüências aleatórias de az minúsculas e 0-9. Não é muito personalizável, mas é curto e limpo.

Esta solução gera uma cadeia de caracteres facilmente legíveis para códigos de ativação; Não queria que as pessoas confundissem 8 com B, 1 com I, 0 com O, L com 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

Outros mencionaram algo semelhante, mas isso usa a função 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=="

O resultado pode conter AZ, az, 0-9, "-" e "_". "=" Também é usado se o preenchimento for verdadeiro.

Desde o Ruby 2.5, é realmente fácil com SecureRandom.alphanumeric:

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

Ele gera seqüências aleatórias contendo AZ, az e 0-9 e, portanto, deve ser aplicável na maioria dos casos de uso. E eles são gerados aleatoriamente seguros, o que também pode ser um benefício.

Esta é uma referência para compará-la com a solução com mais votos positivos:

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)

Portanto, a randsolução leva apenas cerca de 3/4 do tempo de SecureRandom. Isso pode importar se você gerar muitas strings, mas se você criar algumas strings aleatórias de vez em quando, eu sempre utilizarei uma implementação mais segura, pois também é mais fácil chamar e mais explícito.

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

Gere uma sequência aleatória de 8 letras (por exemplo, NVAYXHGR)

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

Gere uma sequência aleatória de 8 caracteres (por exemplo, 3PH4SWF2), excluindo 0/1 / I / O. Ruby 1.9

Não me lembro onde encontrei isso, mas parece o melhor e o menos intensivo para mim:

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

require 'securerandom'
SecureRandom.urlsafe_base64(9)

Se você deseja uma sequência de comprimento especificado, use:

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

Irá gerar uma sequência aleatória de comprimento 2ncontendo 0-9ea-f

Array.new(n){[*"0".."9"].sample}.join, onde n=8no seu caso.

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

De: " Gere a seqüência pseudo-aleatória AZ, 0-9 ".

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

Aqui está um código simples de uma linha para sequência aleatória com comprimento 8:

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

Você também pode usá-lo para senha aleatória com tamanho 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"

Esteja ciente: randé previsível para um invasor e, portanto, provavelmente inseguro. Você definitivamente deve usar o SecureRandom se isso for para gerar senhas. Eu uso algo como isto:

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

Aqui está um código simples para senha aleatória com comprimento 8:

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

Outro método que eu gosto de usar:

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

Adicione ljustse você é realmente paranóico sobre o comprimento correto da string:

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

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

Algo do Devise

Penso que este é um bom equilíbrio entre concisão, clareza e facilidade de modificação.

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

Modificado facilmente

Por exemplo, incluindo dígitos:

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

Hexadecimal maiúsculo:

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

Para uma variedade verdadeiramente impressionante de caracteres:

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

Apenas adicionando meus centavos aqui ...

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

Você pode usar String#randomas Facets of Ruby Gem facets.

Basicamente, faz isso:

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

O meu favorito é (:A..:Z).to_a.shuffle[0,8].join. Observe que o shuffle requer Ruby> 1.9.

Essa solução precisa de dependência externa, mas parece mais bonita que outra.

1. Instalar gem faker
2. Faker::Lorem.characters(10) # => "ang9cbhoa8"

Dado:

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

Expressão única, pode ser transmitida como argumento, permite caracteres duplicados:

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

Eu gosto da resposta do Radar melhor, até agora, eu acho. Eu mexeria um pouco assim:

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

Meus 2 centavos:

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

Acabei de escrever uma pequena gema random_tokenpara gerar tokens aleatórios para a maioria dos casos de uso, aproveite ~

https://github.com/sibevin/random_token

2 soluções para uma sequência aleatória composta por 3 intervalos:

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

Um personagem de cada intervalo.

E se você precisar de pelo menos um caractere de cada intervalo, como criar uma senha aleatória com uma letra maiúscula, uma letra minúscula e um dígito, faça algo assim:

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

Eu estava fazendo algo assim recentemente para gerar uma sequência aleatória de 8 bytes de 62 caracteres. Os caracteres eram 0-9, az, AZ. Eu tinha uma matriz deles como estava repetindo 8 vezes e escolhendo um valor aleatório fora da matriz. Isso foi dentro de um aplicativo Rails.

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

O estranho é que consegui um bom número de duplicatas. Agora, aleatoriamente, isso quase nunca deve acontecer. 62 ^ 8 é enorme, mas em cerca de 1200 códigos no db eu tinha um bom número de duplicatas. Eu os notei acontecendo nos limites das horas um do outro. Em outras palavras, eu posso ver um duplo em 12:12:23 e 2:12:22 ou algo assim ... não tenho certeza se o tempo é o problema ou não.

Esse código estava na criação anterior de um objeto ActiveRecord. Antes da criação do registro, esse código seria executado e geraria o código 'exclusivo'. As entradas no banco de dados sempre foram produzidas com confiabilidade, mas o código ( strna linha acima) estava sendo duplicado com muita frequência.

Criei um script para executar 100000 iterações dessa linha acima com um pequeno atraso, de modo que levaria de 3 a 4 horas na esperança de ver algum tipo de padrão de repetição a cada hora, mas não vi nada. Não tenho idéia do por que isso estava acontecendo no meu aplicativo Rails.