如何在 Ruby 中生成一个随机的10位数字？

To generate the number call rand with the result of the expression "10 to the power of 10"

rand(10 ** 10)

要用零填充数字，可以使用字符串格式运算符

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

或字符串的 rjust方法

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

这里有一个表达式，它将比 quackingDuck 的示例少使用一个方法调用。

'%011d' % rand(1e10)

需要注意的是，1e10是 Float，而 Kernel#rand最终调用 to_i，因此对于某些较高的值，可能存在一些不一致之处。更准确地说，你还可以这样做:

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

我只是想修改一下第一个答案。如果0在第一位，rand (10**10)可以产生9位随机数。为了确保10个精确的数字只是修改

code = rand(10**10)
while code.to_s.length != 10
code = rand(11**11)

结束

这甚至可以在 ruby 1.8.7上运行:

(9999999999) . to _ s. center (10，rand (9) . to _ s) . to _ i

我想贡献一个可能是我知道的最简单的解决方案，这是一个相当不错的技巧。

rand.to_s[2..11]
=> "5950281724"

正如在 Ruby 社区样式指南中提到的那样，只是因为没有提到，Kernel#sprintf方法(或者它在 Powerpack 图书馆中的别名 Kernel#format)通常优先于 String#%方法。

当然，这一点存在很大争议，但为了提供洞察力:

@ quackingDuck 的回答的语法是

# considered bad
'%010d' % rand(10**10)


# considered good
sprintf('%010d', rand(10**10))

这种偏好的性质主要是由于 %的神秘性。它本身没有很强的语义，如果没有任何额外的上下文，它可能会与 %模运算符混淆。

时尚指南的例子:

# bad
'%d %d' % [20, 10]
# => '20 10'


# good
sprintf('%d %d', 20, 10)
# => '20 10'


# good
sprintf('%{first} %{second}', first: 20, second: 10)
# => '20 10'


format('%d %d', 20, 10)
# => '20 10'


# good
format('%{first} %{second}', first: 20, second: 10)
# => '20 10'

为了公正地对待 String#%，我个人非常喜欢使用类操作符的语法而不是命令，就像使用 your_array << 'foo'而不是 your_array.push('123')一样。

这恰恰说明了社区中的一种趋势，什么是“最好的”取决于你自己。

更多信息在 这篇博文。

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

比

rand.to_s[2..11].to_i

你可使用:

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

还有

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

在 Rails 控制台中确认。

不要使用 rand.to_s[2..11].to_i

为什么? 因为这是你能得到的:

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

然后:

"04890612".to_i #=> 4890612

请注意:

4890612.to_s.length #=> 7

这可不是你想的那样！

要在您自己的代码中检查该错误，您可以像下面这样包装它，而不是 .to_i:

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

很快就会发现:

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

因此，最好还是坚持 .center，但要记住:

rand(9)

有时可能会给你 0。

为了防止这种情况:

rand(1..9)

它总是返回 1..9范围内的值。

我很高兴我有很好的测试，我希望你能避免破坏你的系统。

尝试使用 SecureRandom 红宝石库。

它生成随机数，但长度不是特定的。

通过这个链接获得更多信息: http://ruby-doc.org/stdlib-2.1.2/libdoc/securerandom/rdoc/SecureRandom.html

这种技术适用于任何“字母表”

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

最直接的答案可能是

rand(1e9...1e10).to_i

to_i部分是必需的，因为 1e9和 1e10实际上是浮动的:

irb(main)> 1e9.class
=> Float

这是一种快速生成10个大小的数字字符串的方法:

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

生成 n 位随机数的最简单方法-

Random.new.rand((10**(n - 1))..(10**n))

产生10位数字的号码-

Random.new.rand((10**(10 - 1))..(10**10))

随机数生成

使用 Kernel Rand方法:

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

随机字符串生成

使用 times + map + join组合:

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

使用填充将数字转换为字符串

使用 字符串 #% 方法:

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

生成密码

使用 KeePass 密码生成器库，它支持生成随机密码的不同模式:

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

可以找到 KeePass 模式的文档 给你。

使用 regexp-examples红宝石作为替代答案:

require 'regexp-examples'


/\d{10}/.random_example # => "0826423747"

这种方法不需要“用零填充”，因为您将立即生成一个 String。

一个更好的方法是使用 Array.new()而不是 .times.map。

例如:

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

Rubucop，时间地图:

Https://www.rubydoc.info/gems/rubocop/rubocop/cop/performance/timesmap

只需在下面直接使用即可。

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

只要在 IRB 上测试它就可以了。

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

随机10个数字:

require 'string_pattern'
puts "10:N".gen

在我的案例中，模型中的编号必须是唯一的，所以我添加了检查块。

  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)

('%010d' % rand(0..9999999999)).to_s

或者

"#{'%010d' % rand(0..9999999999)}"

生成一个随机的10位字符串:

# 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')

下面是更多的细节，通过把一行分成多行来解释变量:

  # 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')

我最终使用了 Ruby 内核 srand

srand.to_s.last(10)

这里是医生: Kernel # srand

我做过类似的事

x = 10  #Number of digit
(rand(10 ** x) + 10**x).to_s[0..x-1]