วิธีสร้างสตริงแบบสุ่มใน Ruby

ขณะนี้ฉันกำลังสร้างสตริงตัวพิมพ์ใหญ่หลอกแบบ 8 อักขระสำหรับ "A" .. "Z":

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 มันไม่ได้ปรับแต่งได้มาก แต่มันสั้นและสะอาด

โซลูชันนี้สร้างสตริงของอักขระที่อ่านได้ง่ายสำหรับรหัสเปิดใช้งาน ฉันไม่ต้องการให้ผู้คนสับสน 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,“ -” และ“ _” “ =” ยังใช้หากการเติมเต็มเป็นจริง

ตั้งแต่ Ruby 2.5 เป็นเรื่องง่ายด้วยSecureRandom.alphanumeric:

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

มันสร้างสตริงสุ่มที่มี AZ, az และ 0-9 และดังนั้นจึงควรใช้ในกรณีการใช้งานส่วนใหญ่ และพวกมันก็สร้างความปลอดภัยแบบสุ่มซึ่งอาจเป็นประโยชน์เช่นกัน

นี่เป็นมาตรฐานในการเปรียบเทียบกับโซลูชันที่มี upvotes มากที่สุด:

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 ทับทิม 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

ทับทิม 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

เลขฐานสิบหกตัวพิมพ์ใหญ่:

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#randomfacets

มันทำอย่างนี้โดยทั่วไป:

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. ติดตั้ง Gem faker
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

ฉันแค่เขียนอัญมณีขนาดเล็กrandom_tokenเพื่อสร้างโทเค็นแบบสุ่มสำหรับกรณีการใช้งานส่วนใหญ่สนุกกับ ~

https://github.com/sibevin/random_token

2 โซลูชั่นสำหรับสตริงสุ่มประกอบด้วย 3 ช่วง:

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

ฉันกำลังทำอะไรแบบนี้เมื่อเร็ว ๆ นี้เพื่อสร้างสตริงสุ่ม 8 ไบต์จาก 62 ตัวอักษร ตัวละครคือ 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 หรือมากกว่านั้นรหัสใน db ฉันมีจำนวนซ้ำที่ดี ฉันสังเกตเห็นพวกเขาเกิดขึ้นในขอบเขตชั่วโมงของกันและกัน กล่าวอีกนัยหนึ่งฉันอาจเห็นการตีสองหน้าเวลา 12:12:23 และ 2:12:22 หรืออะไรทำนองนั้น ... ไม่แน่ใจว่าเวลาเป็นปัญหาหรือไม่

รหัสนี้อยู่ในก่อนสร้างวัตถุ ActiveRecord ก่อนที่จะสร้างเรกคอร์ดรหัสนี้จะเรียกใช้และสร้างรหัส 'เฉพาะ' รายการในฐานข้อมูลนั้นสร้างขึ้นอย่างน่าเชื่อถือเสมอ แต่รหัส ( strในบรรทัดด้านบน) ถูกทำซ้ำบ่อยเกินไป

ฉันสร้างสคริปต์เพื่อทำงานซ้ำ 100,000 บรรทัดของบรรทัดด้านบนนี้ด้วยความล่าช้าเล็กน้อยดังนั้นจะใช้เวลา 3-4 ชั่วโมงโดยหวังว่าจะเห็นรูปแบบการทำซ้ำบางอย่างทุกชั่วโมง แต่ไม่เห็นอะไรเลย ฉันไม่รู้ว่าทำไมสิ่งนี้จึงเกิดขึ้นในแอพ Rails ของฉัน