ruby - Ruby でランダムな文字列を生成する方法

Question

現在、「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}

でもゴミみたい。

誰かがより良い方法を持っていますか?

score 1022 · Accepted Answer

(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

ランダムなテキストを生成する場合は、次を使用します。

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

このコードは、単語の長さが10文字未満のランダムな単語文字列を50個生成し、スペースで結合します

score 268 · Accepted Answer

これを使用して、最大長が保証されたランダムな URL フレンドリ文字列を生成します。

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

小文字 az と 0-9 のランダムな文字列を生成します。あまりカスタマイズできませんが、短くてきれいです。

score 178 · Accepted Answer

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

score 135 · Accepted Answer

他の人も似たようなことを言っていますが、これは 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 の場合は、「=」も使用されます。

score 53 · Accepted Answer

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

ランダムな 8 文字の文字列を生成します (例: NVAYXHGR)

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

0/1/I/O を除く、ランダムな 8 文字の文字列 (例: 3PH4SWF2) を生成します。ルビー1.9

score 31 · Accepted Answer

私はこれをどこで見つけたか思い出せませんが、それは私にとって最良で最も少ないプロセスのようです：

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

score 28 · Accepted Answer

28

require 'securerandom'
SecureRandom.urlsafe_base64(9)

于 2012-07-13T00:34:57.853 に答える

score 15 · Accepted Answer

Array.new(n){[*"0".."9"].sample}.join、n=8あなたの場合は。

一般化:Array.new(n){[*"A".."Z", *"0".."9"].sample}.joinなど

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

score 11 · Accepted Answer

11

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

于 2008-09-17T22:40:34.640 に答える

score 11 · Accepted Answer

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"

score 8 · Accepted Answer

注意: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

score 8 · Accepted Answer

長さ 8 のランダムパスワードの簡単なコードを次に示します。

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

score 7 · Accepted Answer

私が使用したい別の方法：

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

ljust正しい文字列の長さについて本当に心配している場合は、次を追加してください。

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

score 7 · Accepted Answer

7

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

Deviseの何か

于 2012-04-19T00:25:43.200 に答える

score 6 · Accepted Answer

これは、簡潔さ、明快さ、および変更の容易さのバランスが取れていると思います。

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

score 5 · Accepted Answer

このソリューションには外部依存が必要ですが、他のソリューションよりも優れているようです。

ジェムフェイカーをインストールする
Faker::Lorem.characters(10) # => "ang9cbhoa8"

score 5 · Accepted Answer

ここに私のセントを追加するだけです...

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

score 5 · Accepted Answer

String#randomRuby 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

score 4 · Accepted Answer

与えられた：

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

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

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

score 4 · Accepted Answer

私のお気に入りは(:A..:Z).to_a.shuffle[0,8].join。シャッフルには Ruby > 1.9 が必要であることに注意してください。

score 4 · Accepted Answer

私は最近、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上記の行) は頻繁に複製されていました。

上記の行をわずかな遅延で 100000 回繰り返し実行するスクリプトを作成したため、1 時間ごとに何らかの繰り返しパターンが見られることを期待して 3 ～ 4 時間かかりましたが、何も表示されませんでした。私のRailsアプリでなぜこれが起こったのか、私にはわかりません。

score 3 · Accepted Answer

3

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

于 2011-10-04T19:55:02.713 に答える

score 3 · Accepted Answer

これまでのところ、レーダーの回答が一番気に入っていると思います。私はこのように少し微調整します：

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

score 3 · Accepted Answer

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 文字、小文字 1 文字、数字 1 文字のランダムなパスワードを作成するなど)、次のようにすることができます。

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

score 3 · Accepted Answer

ほとんどのユースケースでランダムなトークンを生成する小さな宝石random_tokenを書くだけです。お楽しみください〜

https://github.com/sibevin/random_token

score 3 · Accepted Answer

私の2セント：

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

score 2 · Accepted Answer

この方法を使用すると、任意の長さで渡すことができます。デフォルトでは6に設定されています。

def generate_random_string(length=6)
  string = ""
  chars = ("A".."Z").to_a
  length.times do
    string << chars[rand(chars.length-1)]
  end
  string
end

score 2 · Accepted Answer

コードでこれを使用しています：

class String

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

end

サポートされている最大長は 25 です (いずれにせよデフォルトでのみ使用しているため、問題はありません)。

攻撃的な単語の生成を完全に避けたい場合、'a'..'z' は次善の策であると誰かが言いました。私たちが持っていたアイデアの 1 つは母音を削除することでしたが、それでも WTFBBQ などになってしまいます。

score 2 · Accepted Answer

これを試してみてください

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

  len.times do
    name << ary.choice.choice
  end
  name
end

私はスレッドの答えが大好きです。確かに非常に役に立ちました!しかし、私が言うなら、それらのどれも私の目を満足させません。おそらくrand()メソッドです。そのための Array#choice メソッドがあるので、それは私には正しくないように思えます。

score 2 · Accepted Answer

UNIX を使用していて、Rails なしで Ruby 1.8 (SecureRandom なし) を使用する必要がある場合は、これも使用できます。

random_string = `openssl rand -base64 24`

これは新しいシェルを生成することに注意してください。これは非常に遅く、スクリプトにのみ推奨できます。

score 2 · Accepted Answer

別の方法を次に示します。

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)]
  }.join
end

score 1 · Accepted Answer

devise secure_validatable の場合、これを使用できます

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

score 1 · Accepted Answer

これは他のいくつかの回答に基づいていますが、もう少し複雑になります。

def random_password
  specials = ((32..47).to_a + (58..64).to_a + (91..96).to_a + (123..126).to_a).pack('U*').chars.to_a
  numbers  = (0..9).to_a
  alpha    = ('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.join
end

基本的には、8 ～ 20 文字の長さで、少なくとも 1 つの数字と 1 つの特殊文字を含むパスワードを保証します。

score 1 · Accepted Answer

1

10.times do 
  alphabet = ('a'..'z').to_a
  string += alpha[rand(alpha.length)]
end

于 2016-02-24T11:51:09.550 に答える

score 0 · Accepted Answer

最初のステートメントを1つのステートメントにするには：

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

score 0 · Accepted Answer

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

score 0 · Accepted Answer

0

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

また

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

于 2016-08-31T09:58:52.833 に答える

score 0 · Accepted Answer

0

`pwgen 8 1`.chomp

于 2010-05-25T20:01:17.107 に答える

score 0 · Accepted Answer

柔軟で重複を許可するソリューションを次に示します。

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

例：

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

特定のキャラクターをより頻繁に出現させることもできます。

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

説明: 上記のメソッドは、指定された文字列の文字を取得し、十分な大きさの配列を生成します。次にそれをシャッフルし、最初の n 個のアイテムを取得して結合します。

score -1 · Accepted Answer

これはほとんど醜いですが、おそらく正しい方向への一歩としてですか？

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

score -1 · Accepted Answer

ruby 1.9では、配列からランダムな要素を返すArrayのchoiceメソッドを使用できます

score -11 · Accepted Answer

ルビーがわからないので、正確な構文を説明することはできませんが、受け入れ可能な文字のリストを使用して定数文字列を設定し、部分文字列演算子を使用してその中からランダムな文字を選択します。

ここでの利点は、文字列がユーザー入力可能であると想定されている場合、lと1、i、0とO、5とSなどの簡単に混乱する文字を除外できることです。

ruby - Ruby でランダムな文字列を生成する方法

50 に答える 50

簡単に変更

各範囲から 1 キャラクター。

Related

Reference