Comment générer une chaîne de caractères aléatoires en Ruby

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

Je passe trop de temps au golf.

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

Et un dernier qui est encore plus déroutant, mais plus souple et les déchets, moins de cycles:

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

- Je l'utiliser pour la génération aléatoire URL amicale des chaînes de caractères avec une garantie de longueur maximale:

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

Il génère aléatoirement des chaînes de lettres minuscules a-z et 0-9. Ce n'est pas très personnalisable, mais elle est courte et propre.

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

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 des A-Z, a-z, 0-9, “-” et “_”. “=” est également utilisé si le rembourrage est vrai.

Depuis ruby 2.5 vraiment facile avec SecureRandom.alphanumeric:

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

Génère aléatoirement des chaînes contenant A-Z, a-z 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 sécurisée, ce qui peut être un avantage, trop.

---

Edit: Un indice de référence à comparer avec la solution ayant le plus 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)

De sorte que le rand solution ne prend environ 3/4 du temps de SecureRandom. Peut importe si vous générez vraiment beaucoup de chaînes, mais si vous venez de créer une certaine chaîne de caractères aléatoires de temps en temps j'avais toujours aller avec le plus d'assurer la mise en œuvre (puisqu'il est également plus facile d'appeler et de plus explicite).

require 'securerandom'
SecureRandom.urlsafe_base64(9)

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

Généralisée: Array.new(n){[*"A".."Z", *"0".."9"].sample}.join, etc. - à partir de cette réponse

Voici une ligne de code simple pour chaîne aléatoire avec une longueur de 8

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

Vous pouvez également l'utiliser pour le mot de passe aléatoire ayant la longueur 8

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

j'espère que ça aidera et étonnant.

Ici est un simple code de mot de passe aléatoire avec lenth 8

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

Espère que ça va aider.

Une autre méthode, je tiens à utiliser

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

Ajouter ljust si vous êtes vraiment paranoïaque à propos de la bonne longueur de la chaîne:

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

Je pense que c'est un bon équilibre de la concision, la clarté et la 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

Majuscules hexadécimal:

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

Pour un impressionnant tableau de caractères:

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

vous pouvez utiliser String#random des Facettes de Ruby Gem facets:

https://github.com/rubyworks/facets/blob/126a619fd766bc45588cac18d09c4f1927538e33/lib/core/facets/string/random.rb

il fait 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

Cette solution doit dépendance externe, mais semble plus jolie que l'autre.

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

Je faisais quelque chose comme ça récemment pour générer de 8 octets chaîne de caractères aléatoires à partir de 62 caractères. Les personnages sont 0-9,a-z,A-Z, j'ai eu un tableau d'entre eux comme ce fut le bouclage 8 fois et choisir une valeur aléatoire de la matrice. C'était à l'intérieur d'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 bon nombre de doublons. Maintenant, au hasard, cela devrait assez bien ne jamais arriver. 62^8 est énorme, mais en dehors de 1200 codes de la bd, j'ai eu un bon nombre de doublons. J'ai remarqué qu'elles se sur-heure limites de chacune des autres. En d'autres termes, je pourrais voir un double à 12:12:23 2:12:22 ou quelque chose comme ça...vous ne savez pas si le temps est de la question ou non.

Ce code a été à l'avant de créer un activerecord objet. Avant la création de l'enregistrement de ce code s'exécuter et de générer l' 'unique' code. Les entrées dans la base de données ont toujours produit de manière fiable, mais le code (str dans la ligne ci-dessus) a été dupliqué beaucoup trop souvent.

J'ai créé un script à exécuter par le biais de 100000 itérations de cette ligne ci-dessus avec un peu de retard alors qu'il faudrait 3 à 4 heures dans l'espoir de voir une sorte de répétition du motif sur une base horaire, mais ne vit rien. Je n'ai aucune idée de pourquoi ce qui se passe dans mon application rails.

Mes 2 cents:

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

Avec cette méthode, vous pouvez passer d'un abitrary longueur. Il est défini comme un défaut 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

Voici une autre méthode:

• Il utilise secure générateur de nombres aléatoires au lieu de rand()
• Peut être utilisé dans les Url et les noms de fichier
• Contient des majuscules, des minuscules, des caractères et des nombres
• A une possibilité de ne pas inclure des personnages ambigus I0l01

Besoins 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

Si vous êtes sur un UNIX, et vous devez toujours utiliser Ruby 1.8 (pas de SecureRandom) sans Rails, vous pouvez également utiliser cette:

random_string = `openssl rand -base64 24`

Remarque cela engendre de nouveaux coquille, c'est très lent et il ne peut être recommandé pour les scripts.

De mon mieux, 2 solutions pour une chaîne aléatoire composé de 3 gammes de

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

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

La façon la plus simple est d'utiliser le string_pattern gem https://github.com/MarioRuiz/string_pattern

Par exemple pour générer 36 lettres aléatoires:

 require 'string_pattern'
 puts '36:L'.gen

Aussi, vous pouvez utiliser des expressions régulières

 require 'string_pattern'
 puts /[a-zA-Z]{36}/.gen

Nous avons été à l'aide de notre code:

class String

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

end

La longueur maximale prise en charge est de 25 (nous ne sommes que de l'utiliser avec la valeur par défaut de toute façon, ce n'est pas un problème).

Quelqu'un a mentionné que 'a'..'z' est sous-optimale si vous souhaitez éviter de générer les mots offensants. L'une des idées que nous avons eu a été de retirer les voyelles, mais vous avez encore jusqu'à la fin avec WTFBBQ etc.

Créer une chaîne vide ou un pré-corriger si besoin:

myStr = "OID-"

Utiliser ce code pour remplir la chaîne avec des nombres aléatoires:

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

Notes:

(rand * 43) + 47).ceil

Il va générer des nombres aléatoires à partir de 48-91 (0,1,2..Y,Z)

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

Il est utilisé pour ignorer les caractères spéciaux (comme je ne suis pas intéressé à les inclure)

while(myStr.length < 12)

Il va générer un total de 12 caractères chaîne, y compris le préfixe.

Exemple De Sortie:

"OID-XZ2J32XM"

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

Ici est d'améliorer de @Travis R réponse:

 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

À @Travis R réponse caractères et les nombres étaient ensemble, donc parfois random_string pourrait revenir uniquement des chiffres ou que des personnages. Avec cette améliorer au moins la moitié de random_string sera caractères et le reste sont des nombres. Juste au cas où si vous avez besoin d'une chaîne de caractères aléatoires avec des numéros et des caractères

C'est presque aussi laid, mais peut-être l'étape dans la bonne direction?

 (1..8).map{|i| ('a'..'z').to_a[rand(26)]}.join

Je ne sais pas ruby, donc je ne peux pas vous donner la syntaxe exacte, mais je voudrais définir une constante chaîne de caractères avec la liste des caractères acceptables, puis utilisez la sous-chaîne de l'opérateur de choisir un caractère aléatoire hors de lui.

L'avantage ici est que si la chaîne est censé être de l'utilisateur-enterable, alors vous pouvez exclure facile de confondre les personnages comme l et 1 et i, 0 et O, 5 et S, etc.