Comment puis-je générer de façon aléatoire un numéro à 10 chiffres en ruby?

Pour générer le numéro d'appel rand, avec le résultat de l'expression "10 puissance 10"

rand(10 ** 10)

À la map, le nombre de zéros, vous pouvez utiliser le format de la chaîne de l'opérateur

'%010d' % rand(10 ** 10)

ou la rjust méthode de chaîne de

rand(10 ** 10).to_s.rjust(10,'0')  

C'est un moyen rapide de générer un 10 taille de la chaîne de chiffres:

10.times.map{rand(10)}.join # => "3401487670"

NE PAS UTILISER rand.to_s[2..11].to_i

Pourquoi? Car ici, c'est ce que vous pouvez obtenir:

rand.to_s[2..9] #=> "04890612"

et puis:

"04890612".to_i #=> 4890612

Noter que:

4890612.to_s.length #=> 7

Qui n'est pas ce que vous avez prévu!

Pour vérifier que l'erreur dans votre code, au lieu de .to_i vous pouvez l'envelopper comme ceci:

Integer(rand.to_s[2..9])

et très bientôt, il va s'avérer que:

ArgumentError: invalid value for Integer(): "02939053"

Il est donc toujours préférable de s'en tenir à .center, mais gardez à l'esprit que:

rand(9) 

peut parfois vous donner 0.

Pour éviter que:

rand(1..9)

qui retournera toujours quelque chose à l'intérieur 1..9 gamme.

Je suis heureux que j'ai eu de bons tests et j'espère que vous allez éviter la rupture de votre système.

De génération de nombre aléatoire

Utilisation Noyau#rand méthode:

rand(1_000_000_000..9_999_999_999) # => random 10-digits number

Chaîne aléatoire de la génération

Utilisation times + map + join combinaison:

10.times.map { rand(0..9) }.join # => random 10-digit string (may start with 0!)

Nombre de conversion de chaîne de caractères avec un rembourrage

Utilisation String#% méthode:

"%010d" % 123348 # => "0000123348"

Génération de mot de passe

Utilisation KeePass password generator de la bibliothèque, il prend en charge différents modèles pour la génération aléatoire de mot de passe:

KeePass::Password.generate("d{10}") # => random 10-digit string (may start with 0!)

Une documentation pour KeePass modèles peuvent être trouvés ici.

Ici est une expression qui va utiliser moins un appel de méthode que quackingduck l'exemple.

'%011d' % rand(1e10)

Une mise en garde, 1e10 est un Float, et Kernel#rand finit par appeler to_i sur elle, donc, pour certaines valeurs supérieures vous pourriez avoir quelques incohérences. Pour être plus précis avec un littéral, vous pouvez aussi faire:

'%011d' % rand(10_000_000_000) # Note that underscores are ignored in integer literals

Cette technique fonctionne pour n'importe quel "alphabet"

(1..10).map{"0123456789".chars.to_a.sample}.join
=> "6383411680"

rand(9999999999).to_s.center(10, rand(9).to_s).to_i

est plus rapide que

rand.to_s[2..11].to_i

Vous pouvez utiliser:

puts Benchmark.measure{(1..1000000).map{rand(9999999999).to_s.center(10, rand(9).to_s).to_i}}

et

puts Benchmark.measure{(1..1000000).map{rand.to_s[2..11].to_i}}

dans la console Rails de le confirmer.

Juste une utilisation simple ci-dessous.

rand(10 ** 9...10 ** 10)

Il suffit de tester sur CISR ci-dessous.

(1..1000).each { puts rand(10 ** 9...10 ** 10) }

Une meilleure approche est d'utiliser Array.new() au lieu de .times.map. Rubocop le recommande.

Exemple:

string_size = 9
Array.new(string_size) do
   rand(10).to_s
end

Rubucop, TimesMap:

https://www.rubydoc.info/gems/rubocop/RuboCop/Cop/Performance/TimesMap

Dans mon cas, ce numéro doit être unique dans mes modèles, j'ai donc ajouté la vérification de bloc.

  module StringUtil
    refine String.singleton_class do
      def generate_random_digits(size:)
        proc = lambda{ rand.to_s[2...(2 + size)] }
        if block_given?
          loop do
            generated = proc.call
            break generated if yield(generated) # check generated num meets condition
          end
        else
          proc.call
        end
      end
    end
  end
  using StringUtil
  String.generate_random_digits(3) => "763"
  String.generate_random_digits(3) do |num|
    User.find_by(code: num).nil?
  end => "689"(This is unique in Users code)

À la génération aléatoire, 10-chaîne de chiffres:

# This generates a 10-digit string, where the
# minimum possible value is "0000000000", and the
# maximum possible value is "9999999999"
SecureRandom.random_number(10**10).to_s.rjust(10, '0')

---

Voici plus en détail de ce qui se passe, illustré par la rupture de la ligne en plusieurs lignes expliquant les variables:

  # Calculate the upper bound for the random number generator
  # upper_bound = 10,000,000,000
  upper_bound = 10**10

  # n will be an integer with a minimum possible value of 0,
  # and a maximum possible value of 9,999,999,999
  n = SecureRandom.random_number(upper_bound)

  # Convert the integer n to a string
  # unpadded_str will be "0" if n == 0
  # unpadded_str will be "9999999999" if n == 9_999_999_999
  unpadded_str = n.to_s

  # Pad the string with leading zeroes if it is less than
  # 10 digits long.
  # "0" would be padded to "0000000000"
  # "123" would be padded to "0000000123"
  # "9999999999" would not be padded, and remains unchanged as "9999999999"
  padded_str = unpadded_str.rjust(10, '0')