Comment générer une chaîne aléatoire dans Ruby

Je génère actuellement une chaîne majuscule pseudo-aléatoire à 8 caractères pour "A" .. "Z":

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

mais il n'a pas l'air propre, et il ne peut pas être passé en argument car il ne s'agit pas d'une seule instruction. Pour obtenir une chaîne à casse mixte "a" .. "z" plus "A" .. "Z", je l'ai modifiée en:

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

mais ça ressemble à une poubelle.

Quelqu'un at-il une meilleure méthode?

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

Je passe trop de temps à jouer au golf.

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

Et un dernier encore plus déroutant, mais plus flexible et qui gaspille moins de cycles:

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

Pourquoi ne pas utiliser SecureRandom?

require 'securerandom'
random_string = SecureRandom.hex

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

SecureRandom propose également des méthodes pour:

• base64
• random_bytes
• random_number

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

J'utilise ceci pour générer des chaînes aléatoires adaptées aux URL avec une longueur maximale garantie:

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

Il génère des chaînes aléatoires d'az minuscule et de 0 à 9. Ce n'est pas très personnalisable mais c'est court et propre.

Cette solution génère une chaîne de caractères facilement lisibles pour les codes d'activation; Je ne voulais pas que les gens confondent 8 avec B, 1 avec I, 0 avec O, L avec 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

D'autres ont mentionné quelque chose de similaire, mais cela utilise la fonction de sécurité des URL.

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

Le résultat peut contenir AZ, az, 0-9, «-» et «_». "=" Est également utilisé si le remplissage est vrai.

Depuis Ruby 2.5, c'est très simple avec SecureRandom.alphanumeric:

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

Il génère des chaînes aléatoires contenant AZ, az et 0-9 et devrait donc être applicable dans la plupart des cas d'utilisation. Et ils sont générés de manière aléatoire et sécurisée, ce qui pourrait également être un avantage.

Il s'agit d'une référence pour la comparer avec la solution ayant le plus de votes positifs:

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)

La randsolution ne prend donc qu'environ 3/4 du temps de SecureRandom. Cela peut avoir de l'importance si vous générez beaucoup de chaînes, mais si vous créez de temps en temps une chaîne aléatoire, j'opterais toujours pour une implémentation plus sécurisée car elle est également plus facile à appeler et plus explicite.

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

Générez une chaîne aléatoire de 8 lettres (par exemple NVAYXHGR)

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

Génère une chaîne aléatoire de 8 caractères (par exemple 3PH4SWF2), exclut 0/1 / I / O. Ruby 1.9

Je ne me souviens pas où j'ai trouvé cela, mais cela me semble être le meilleur et le moins intensif pour moi:

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

require 'securerandom'
SecureRandom.urlsafe_base64(9)

Si vous voulez une chaîne de longueur spécifiée, utilisez:

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

Il générera une chaîne aléatoire de longueur 2ncontenant 0-9eta-f

Array.new(n){[*"0".."9"].sample}.join, où n=8dans votre cas.

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

De: " Générer une chaîne pseudo-aléatoire AZ, 0-9 ".

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

Voici un code simple d'une ligne pour une chaîne aléatoire de longueur 8:

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

Vous pouvez également l'utiliser pour un mot de passe aléatoire de longueur 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"

Attention: randest prévisible pour un attaquant et donc probablement peu sûr. Vous devez absolument utiliser SecureRandom s'il s'agit de générer des mots de passe. J'utilise quelque chose comme ça:

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

Voici un code simple pour un mot de passe aléatoire de longueur 8:

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

Une autre méthode que j'aime utiliser:

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

Ajoutez ljustsi vous êtes vraiment paranoïaque sur la longueur de chaîne correcte:

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

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

Quelque chose de Devise

Je pense que c'est un bel équilibre entre concision, clarté et facilité de modification.

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

Facilement modifié

Par exemple, y compris les chiffres:

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

Hexadécimal majuscule:

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

Pour un éventail de caractères vraiment impressionnant:

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

J'ajoute juste mes cents ici ...

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

Vous pouvez utiliser String#random partir des facettes de Ruby Gemfacets .

Il fait essentiellement ceci:

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

Mon préféré est (:A..:Z).to_a.shuffle[0,8].join. Notez que le shuffle nécessite Ruby> 1.9.

Cette solution nécessite une dépendance externe, mais semble plus jolie qu'une autre.

1. Installer Gem Faker
2. Faker::Lorem.characters(10) # => "ang9cbhoa8"

Donné:

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

Une seule expression, pouvant être passée en argument, autorise les caractères en double:

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

Je préfère la réponse de Radar, jusqu'à présent, je pense. Je voudrais modifier un peu comme ceci:

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

Mes 2 cents:

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

Je viens d'écrire un petit bijou random_tokenpour générer des jetons aléatoires pour la plupart des cas d'utilisation, profitez de ~

https://github.com/sibevin/random_token

2 solutions pour une chaîne aléatoire composée de 3 plages:

(('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 personnage de chaque plage.

Et si vous avez besoin d'au moins un caractère de chaque plage, comme la création d'un mot de passe aléatoire qui a une majuscule, une lettre minuscule et un chiffre, vous pouvez faire quelque chose comme ceci:

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

Je faisais quelque chose comme ça récemment pour générer une chaîne aléatoire de 8 octets à partir de 62 caractères. Les caractères étaient 0-9, az, AZ. J'en avais un tableau comme en boucle 8 fois et en choisissant une valeur aléatoire dans le tableau. C'était dans une application Rails.

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

La chose étrange est que j'ai eu un bon nombre de doublons. Maintenant, au hasard, cela ne devrait pratiquement jamais se produire. 62 ^ 8 est énorme, mais sur 1200 codes environ dans la base de données, j'ai eu un bon nombre de doublons. Je les ai vus se produire aux limites des heures les uns des autres. En d'autres termes, je pourrais voir un double à 12:12:23 et 2:12:22 ou quelque chose comme ça ... je ne sais pas si le temps est le problème ou non.

Ce code était dans la création antérieure d'un objet ActiveRecord. Avant la création de l'enregistrement, ce code s'exécutait et générait le code «unique». Les entrées dans la base de données étaient toujours produites de manière fiable, mais le code ( strdans la ligne ci-dessus) était dupliqué beaucoup trop souvent.

J'ai créé un script pour exécuter 100 000 itérations de cette ligne ci-dessus avec un petit retard, il faudrait donc 3-4 heures en espérant voir une sorte de motif de répétition toutes les heures, mais je n'ai rien vu. Je ne sais pas pourquoi cela se produisait dans mon application Rails.