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

把你的第一个变成一个陈述：

(0...8).collect { |n| value  << (65 + rand(25)).chr }.join()

(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).flattenstring = (0...50).map { o[rand(o.length)] }.join

如果您想生成一些随机文本，请使用以下命令：

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

此代码生成50个单词长度小于10个字符的随机字符串，然后用空格连接

我不懂ruby，所以我不能给你确切的语法，但我会用可接受的字符列表设置一个常量字符串，然后使用子字符串运算符从中选择一个随机字符。

这里的优点是，如果字符串应该是用户可接受的，那么您可以排除容易混淆的字符，例如l和1和i、0和O、5和S等。

这几乎是丑陋的，但也许是朝着正确方向迈出的一步？

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

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

我们一直在我们的代码中使用它：

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

支持的最大长度为25（无论如何，我们只将其与默认值一起使用，所以没有问题）。

有人提到，如果你想完全避免产生冒犯性词语，'a'…'z'是次优的。我们的想法之一是删除元音，但你仍然会得到WTFBBQ等。

使用此方法，您可以传入一个abitrary长度。它默认设置为6。

def generate_random_string(length=6)string = ""chars = ("A".."Z").to_alength.times dostring << chars[rand(chars.length-1)]endstringend

到目前为止，我认为我最喜欢雷达的答案。我会像这样调整一下：

CHARS = ('a'..'z').to_a + ('A'..'Z').to_adef rand_string(length=8)s=''length.times{ s << CHARS[rand(CHARS.length)] }send

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

# Generates a random string from a set of easily readable charactersdef 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)] }.joinend

我不记得我在哪里找到这个，但对我来说，这似乎是最好和最少的过程：

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

在ruby 1.9中，可以使用Array的选择方法从数组中返回随机元素

为什么不使用SecureRandom？

require 'securerandom'random_string = SecureRandom.hex
# outputs: 5b5cd0da3121fc53b4bc84d0c8af2e81 (i.e. 32 chars of 0..9, a..f)

SecureRandom也有以下方法：

• bas64
• random_bytes
• random_number

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

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

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

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

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

`pwgen 8 1`.chomp

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"

我最近正在做这样的事情，从62个字符中生成一个8字节的随机字符串。字符是0-9、a-z、A-Z。我有一个数组，循环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或类似的地方看到二重奏……不确定时间是否是问题所在。

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

我创建了一个脚本来运行上述行的100000次迭代，延迟很小，所以需要3-4个小时才能看到每小时的重复模式，但什么也没看到。我不知道为什么会在我的Rails应用程序中发生这种情况。

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

string_length = 8rand(36**string_length).to_s(36)

它生成小写a-z和0-9的随机字符串。它不是很可定制，但它简短而干净。

试试这个

def rand_name(len=9)ary = [('0'..'9').to_a, ('a'..'z').to_a, ('A'..'Z').to_a]name = ''
len.times doname << ary.choice.choiceendnameend

我喜欢这个线程的答案，确实很有帮助！，但是如果我可以说，他们都不满足我的同意，也许是rand（）方法。这对我来说似乎不太合适，因为我们已经有了数组#选择方法。

给定：

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

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

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

我认为这是简洁、清晰和易于修改的一个很好的平衡。

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

这是另一种方法：

• 它使用安全随机数生成器而不是rand（）
• 可用于URL和文件名
• 包含大写、小写字符和数字
• 具有不包含歧义字符的选项I0l01

需要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)]}.joinend

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

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

结果可能包含A-Z、a-z、0-9、“-”和“_如果填充为真，也使用 ”. “=” 。

''.tap {|v| 4.times { v << ('a'..'z').to_a.sample} }

[*('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

由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"

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

来自Devise的东西

这是基于其他一些答案，但它增加了一些复杂性：

def random_passwordspecials = ((32..47).to_a + (58..64).to_a + (91..96).to_a + (123..126).to_a).pack('U*').chars.to_anumbers  = (0..9).to_aalpha    = ('a'..'z').to_a + ('A'..'Z').to_a%w{i I l L 1 O o 0}.each{ |ambiguous_character|alpha.delete ambiguous_character}characters = (alpha + specials + numbers)password = Random.new.rand(8..18).times.map{characters.sample}password << specials.sample unless password.join =~ Regexp.new(Regexp.escape(specials.join))password << numbers.sample  unless password.join =~ Regexp.new(Regexp.escape(numbers.join))password.shuffle.joinend

从本质上讲，它确保密码长度为8-20个字符，并且至少包含一个数字和一个特殊字符。

我的2美分：

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

在这里加上我的美分…

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

如果您使用的是UNIX，并且仍然必须使用没有Rails的Ruby 1.8（没有SecureRandom），您也可以使用以下命令：

random_string = `openssl rand -base64 24`

请注意，这会产生新的shell，这非常慢，只能推荐用于脚本。

require 'securerandom'SecureRandom.urlsafe_base64(9)

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

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

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

length = 10characters = ('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

如果需要，创建一个空字符串或前缀：

myStr = "OID-"

使用此代码用随机数填充字符串：

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

备注：

(rand * 43) + 47).ceil

它将从48-91（0,1,2… Y， Z）生成随机数

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

它用于跳过特殊字符（因为我对包含它们不感兴趣）

while(myStr.length < 12)

它将生成总共12个字符长的字符串，包括前缀。

样品输出：

"OID-XZ2J32XM"

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

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

它将生成一个长度为2n的随机字符串，其中包含0-9和a-f

这是一个灵活且允许dups的解决方案：

class String# generate a random string of length n using current string as the source of charactersdef random(n)return "" if n <= 0(chars * (n / length + 1)).shuffle[0..n-1].joinendend

示例：

"ATCG".random(8) => "CGTGAAGA"

您还可以允许某个字符更频繁地出现：

"AAAAATCG".random(10) => "CTGAAAAAGC"

说明：上面的方法获取给定字符串的字符并生成一个足够大的数组。然后它对其进行洗牌，获取前n个项目，然后连接它们。

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

我只是写一个小gemrandom_token来为大多数用例生成随机令牌，享受~

Array.new(8).inject(""){|r|r<<('0'..'z').to_a.shuffle[0]}  # 57(1..8).inject(""){|r|r<<('0'..'z').to_a.shuffle[0]}        # 51e="";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

另一个适用于Ruby 1.8+且速度很快的技巧是：

>> require "openssl">> OpenSSL::Random.random_bytes(20).unpack('H*').join=> "2f3ff53dd712ba2303a573d9f9a8c1dbc1942d28"

它让你随机十六进制字符串。类似的方式你应该能够生成base 64字符串（'M*'）。

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

它基本上是这样做的：

class Stringdef self.random(len=32, character_set = ["A".."Z", "a".."z", "0".."9"])characters = character_set.map { |i| i.to_a }.flattencharacters_len = characters.length(0...len).map{ characters[rand(characters_len)] }.joinendend

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

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

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

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

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

您也可以将其用于长度为8的随机密码：

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

这个解决方案需要外部依赖，但似乎比另一个更漂亮。

1. 安装gemfaker
2. Faker::Lorem.characters(10) # => "ang9cbhoa8"

10.times doalphabet = ('a'..'z').to_astring += alpha[rand(alpha.length)]end

设计secure_validatable你可以用这个

(0...8).map { ([65, 97].sample + rand(26)).chr }.push(rand(99)).join

a='';8.times{a<<[*'a'..'z'].sample};p a

或

8.times.collect{[*'a'..'z'].sample}.join

从Ruby 2.5开始，使用SecureRandom.alphanumeric非常容易：

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

它生成包含A-Z、a-z和0-9的随机字符串，因此应该适用于大多数用例。它们是随机安全生成的，这也可能是一个好处。

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

require 'benchmark'require 'securerandom'
len = 10n = 100_000
Benchmark.bm(12) do |x|x.report('SecureRandom') { n.times { SecureRandom.alphanumeric(len) } }x.report('rand') doo = [('a'..'z'), ('A'..'Z'), (0..9)].map(&:to_a).flattenn.times { (0...len).map { o[rand(o.length)] }.join }endend

                   user     system      total        realSecureRandom   0.429442   0.002746   0.432188 (  0.432705)rand           0.306650   0.000716   0.307366 (  0.307745)

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

以下是@Travis R答案的改进：

 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.joinend

在@Travis R回答时，字符和数字在一起，所以有时random_string只能返回数字或仅返回字符。通过这种改进，random_string中至少有一半是字符，其余是数字。以防万一，如果您需要一个包含数字和字符的随机字符串

使用'SafeRandom'GemGithubLink

它将提供最简单的方法来生成与Rails 2、Rails 3、Rails 4、Rails 5兼容的随机值。

以下内容对我很有效

def generate_random_password(min_length, max_length)length = SecureRandom.random_number(max_length - min_length) + min_lengthcharacter_sets = [('a'..'z').to_a,('A'..'Z').to_a,('0'..'9').to_a,"~!@^&*()_-+=[]|:;<,>.?".split('')]retval = []## Add one character from each set#character_sets.each do |character_set|character = character_set[SecureRandom.random_number(character_set.count)]retval.push characterend## Fill the rest of the password with a random character from a random set#i = character_sets.count - 1while i < lengthcharacter_set = character_sets[SecureRandom.random_number(character_sets.count)]character = character_set[SecureRandom.random_number(character_set.count)]retval.push characteri += 1endretval.shuffle.joinend