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


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

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

mais il ne semble pas propre, et il ne peut pas être passé comme un argument car ce n'est pas une seule déclaration. Pour obtenir une chaîne mixte "a" .. "z" plus "A" .. "Z", je l'ai changé pour:

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

mais ça ressemble à une poubelle.

Est-ce que quelqu'un a une meilleure méthode?


673


origine


Réponses:


(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 qui est encore plus confus, mais plus flexible et gaspille moins de cycles:

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

876



Pourquoi ne pas utiliser SecureRandom?

require 'securerandom'
random_string = SecureRandom.hex

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

SecureRandom a également des méthodes pour:

  • base64
  • random_bytes
  • random_number

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


734



Je l'utilise pour générer des chaînes conviviales avec une longueur maximale garantie:

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

Il génère des chaînes aléatoires de minuscules a-z et 0-9. Ce n'est pas très personnalisable mais c'est court et propre.


225



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

162



D'autres ont mentionné quelque chose de similaire, mais cela utilise la fonction de sécurité de l'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 A-Z, a-z, 0-9, "-" et "_". "=" Est également utilisé si padding est vrai.


120



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

Générer 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érer une chaîne aléatoire de 8 caractères (par exemple 3PH4SWF2), exclut 0/1 / I / O. Ruby 1.9


41



Je ne me souviens pas où j'ai trouvé ça, mais ça me semble le meilleur et le moins intensif en matière de processus:

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 vous voulez une chaîne de longueur spécifiée, utilisez:

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

Il va générer une chaîne de longueur aléatoire 2n contenant 0-9 et a-f


22