如何在Ruby中生成随机字符串

我目前正在为“ A” ..“ Z”生成一个8个字符的伪随机大写字符串：

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

但它看起来并不干净，并且由于它不是单个语句，因此不能作为参数传递。为了获得大小写混合的字符串“ a” ..“ z”加上“ A” ..“ Z”，我将其更改为：

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

但看起来像垃圾

有谁有更好的方法？

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

我花太多时间打高尔夫球。

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

最后一个更令人困惑，但更灵活，浪费的周期更少：

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

为什么不使用SecureRandom？

require 'securerandom'
random_string = SecureRandom.hex

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

SecureRandom还具有以下方法：

• base64
• random_bytes
• random_number

参见：http : //ruby-doc.org/stdlib-1.9.2/libdoc/securerandom/rdoc/SecureRandom.html

我用它来生成具有最大长度保证的随机URL友好字符串：

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

它生成小写字母az和0-9的随机字符串。它不是非常可定制的，但是又短又干净。

该解决方案为激活码生成一串易于阅读的字符；我不希望人们将B与8混淆，将I与1混淆，将O与O混淆，将L与1混淆，等等。

# 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

其他人提到了类似的内容，但这使用了URL安全功能。

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

结果可能包含AZ，az，0-9，“-”和“ _”。如果填充为true，则也使用“ =”。

从Ruby 2.5开始，使用SecureRandom.alphanumeric以下命令真的很容易：

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

它会生成包含AZ，az和0-9的随机字符串，因此应适用于大多数用例。而且它们是随机安全生成的，这也可能是一个好处。

这是将其与投票最多的解决方案进行比较的基准：

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)

因此，rand解决方案仅需要3/4的时间SecureRandom。如果您生成许多字符串，那可能很重要，但是如果您不时地创建一些随机字符串，我总是会选择更安全的实现，因为它也更容易调用和更明确。

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

生成一个随机的8个字母的字符串（例如NVAYXHGR）

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

生成随机的8个字符串（例如3PH4SWF2），不包括0/1 / I / O。Ruby 1.9

我不记得我在哪里找到的，但对我来说似乎是最好，最省力的过程：

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

require 'securerandom'
SecureRandom.urlsafe_base64(9)

如果要指定长度的字符串，请使用：

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

这将产生长度的随机串2n含有0-9和a-f

Array.new(n){[*"0".."9"].sample}.join，n=8在您的情况下。

广义：Array.new(n){[*"A".."Z", *"0".."9"].sample}.join等

来自：“ 生成伪随机字符串AZ，0-9 ”。

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

这是长度为8的随机字符串的一行简单代码：

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

您也可以将其用于长度为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"

请注意：rand对于攻击者是可预测的，因此可能不安全。如果这用于生成密码，则绝对应该使用SecureRandom。我用这样的东西：

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

这是长度为8的随机密码的简单代码：

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

我喜欢使用的另一种方法：

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

ljust如果您对正确的字符串长度确实有些偏执，请添加：

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

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

来自Devise的东西

我认为这是简洁，清晰和易于修改之间的良好平衡。

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

轻松修改

例如，包括数字：

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

大写十六进制：

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

对于真正令人印象深刻的字符数组：

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

只是在这里加我的美分...

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

您可以String#random从Ruby Gem的Facets中使用facets。

它基本上是这样做的：

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

我最喜欢的是(:A..:Z).to_a.shuffle[0,8].join。请注意，随机播放要求Ruby> 1.9。

此解决方案需要外部依赖性，但看起来比其他解决方案还漂亮。

1. 安装宝石造假者
2. Faker::Lorem.characters(10) # => "ang9cbhoa8"

鉴于：

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

可以作为参数传递的单个表达式，允许重复的字符：

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

我认为到目前为止，我最喜欢Radar的答案。我将进行如下调整：

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

我的2美分：

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

我只是写了一个小gem random_token来为大多数用例生成随机令牌，请享用〜

https://github.com/sibevin/random_token

包含3个范围的随机字符串的2个解决方案：

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

每个范围一个字符。

并且，如果您需要每个范围至少包含一个字符，例如创建一个具有一个大写，一个小写字母和一位数字的随机密码，则可以执行以下操作：

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

我最近在做这样的事情，从62个字符中生成了一个8字节的随机字符串。字符是0-9，az，AZ。我有一个数组，循环了8次，并从数组中选择了一个随机值。这是在Rails应用程序内。

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

奇怪的是我得到了很多重复的东西。现在，这几乎永远不会发生。62 ^ 8很大，但是在数据库中的1200左右代码中，我有很多重复项。我注意到它们发生在彼此的小时边界上。换句话说，我可能会在12:12:23和2:12:22看到类似的情况……不确定时间是否是问题所在。

此代码在创建ActiveRecord对象之前。在创建记录之前，此代码将运行并生成“唯一”代码。数据库中的条目始终可靠地生成，但是代码（str在上一行中）被复制得太多了。

我创建了一个脚本，可以稍稍延迟地执行上述代码的100000次迭代，因此需要3-4个小时才能希望每小时看到某种重复模式，但什么也没看到。我不知道为什么这会在我的Rails应用程序中发生。