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

そして、最後の1つはさらに混乱しますが、より柔軟性があり、無駄なサイクルが少なくなります。

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のランダムな文字列を生成します。あまりカスタマイズできませんが、短くてすっきりしています。

このソリューションは、アクティベーションコード用の読みやすい文字列を生成します。8をBと、1をIと、0を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、など

From： " 疑似ランダム文字列AZ、0-9を生成します "。

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

長さ8のランダム文字列の1行の単純なコードを次に示します。

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

工夫からの何か

これは、簡潔さ、明確さ、変更の容易さのバランスが良いと思います。

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

大文字の16進数：

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#randomRuby Gemのファセットから使用できます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です。shuffleにはRuby> 1.9が必要です。

このソリューションには外部依存関係が必要ですが、別のソリューションよりもきれいに見えます。

1. gem fakerをインストールする
2. Faker::Lorem.characters(10) # => "ang9cbhoa8"

与えられた：

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

単一の式、引数として渡すことができ、重複文字を許可します：

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

私はレーダーの答えが一番好きだと思います。私はこのように少し微調整します：

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

私は小さな宝石を書くだけです 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)*""

各範囲から1文字。

また、大文字、小文字、数字がそれぞれ1つずつあるランダムなパスワードを作成するなど、各範囲から少なくとも1文字が必要な場合は、次のようにします。

( ('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オブジェクトの作成前にありました。レコードが作成される前に、このコードが実行され、「一意の」コードが生成されます。DBのエントリは常に確実に作成されましたが、コード（str上記の行）は頻繁に複製されていました。

上記の行を100,000回繰り返し実行するスクリプトを少し遅延して作成したため、1時間ごとにある種の繰り返しパターンを確認するには3〜4時間かかりますが、何も表示されませんでした。これが私のRailsアプリでなぜ起こっていたのか、私にはわかりません。