Cách tạo một chuỗi ngẫu nhiên trong Ruby

Tôi hiện đang tạo một chuỗi chữ hoa giả ngẫu nhiên 8 ký tự cho "A" .. "Z":

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

nhưng nó không có vẻ rõ ràng và nó không thể được thông qua như là một đối số vì nó không phải là một tuyên bố duy nhất. Để có được chuỗi trường hợp hỗn hợp "a" .. "z" cộng với "A" .. "Z", tôi đã đổi nó thành:

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

nhưng nó trông giống như rác rưởi

Có ai có một phương pháp tốt hơn?

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

Tôi dành quá nhiều thời gian để chơi golf.

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

Và một điều cuối cùng thậm chí còn khó hiểu hơn, nhưng linh hoạt hơn và lãng phí ít chu kỳ hơn:

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

Tại sao không sử dụng SecureRandom?

require 'securerandom'
random_string = SecureRandom.hex

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

SecureRandom cũng có các phương thức cho:

• cơ sở64
• ngẫu nhiên
• số ngẫu nhiên

xem: http://ruby-doc.org/stdlib-1.9.2/libdoc/seckerandom/rdoc/SecureRandom.html

Tôi sử dụng điều này để tạo các chuỗi thân thiện với URL ngẫu nhiên với độ dài tối đa được đảm bảo:

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

Nó tạo ra các chuỗi ngẫu nhiên của chữ thường az và 0-9. Nó không phải là rất tùy biến nhưng nó ngắn và sạch sẽ.

Giải pháp này tạo ra một chuỗi các ký tự dễ đọc cho mã kích hoạt; Tôi không muốn mọi người nhầm lẫn 8 với B, 1 với I, 0 với O, L với 1, v.v.

# 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

Những người khác đã đề cập đến một cái gì đó tương tự, nhưng điều này sử dụng chức năng an toàn URL.

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

Kết quả có thể chứa AZ, az, 0-9, ăn - và và _ _. Cấm = cũng được sử dụng nếu đệm là đúng.

Kể từ Ruby 2.5, thật dễ dàng với SecureRandom.alphanumeric:

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

Nó tạo ra các chuỗi ngẫu nhiên chứa AZ, az và 0-9 và do đó nên được áp dụng trong hầu hết các trường hợp sử dụng. Và chúng được tạo ra an toàn ngẫu nhiên, cũng có thể là một lợi ích.

Đây là một điểm chuẩn để so sánh nó với giải pháp có nhiều upvote nhất:

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)

Vì vậy, randgiải pháp chỉ mất khoảng 3/4 thời gian SecureRandom. Điều đó có thể quan trọng nếu bạn tạo ra nhiều chuỗi, nhưng nếu thỉnh thoảng bạn chỉ tạo một số chuỗi ngẫu nhiên, tôi sẽ luôn luôn thực hiện an toàn hơn vì nó cũng dễ gọi hơn và rõ ràng hơn.

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

Tạo chuỗi 8 chữ cái ngẫu nhiên (ví dụ: NVAYXHGR)

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

Tạo chuỗi 8 ký tự ngẫu nhiên (ví dụ 3PH4SWF2), loại trừ 0/1 / I / O. Ruby 1.9

Tôi không thể nhớ nơi tôi tìm thấy cái này, nhưng có vẻ như là thứ tốt nhất và ít quy trình nhất đối với tôi:

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

require 'securerandom'
SecureRandom.urlsafe_base64(9)

Nếu bạn muốn một chuỗi có độ dài được chỉ định, hãy sử dụng:

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

Nó sẽ tạo ra một chuỗi chiều dài ngẫu nhiên 2ncó chứa 0-9vàa-f

Array.new(n){[*"0".."9"].sample}.join, n=8trong trường hợp của bạn.

Tổng quát : Array.new(n){[*"A".."Z", *"0".."9"].sample}.join, v.v.

Từ: " Tạo chuỗi giả ngẫu nhiên AZ, 0-9 ".

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

Đây là một dòng mã đơn giản cho chuỗi ngẫu nhiên có độ dài 8:

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

Bạn cũng có thể sử dụng nó cho mật khẩu ngẫu nhiên có độ dài 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"

Hãy nhận biết: randcó thể dự đoán được cho một kẻ tấn công và do đó có thể không an toàn. Bạn chắc chắn nên sử dụng SecureRandom nếu điều này là để tạo mật khẩu. Tôi sử dụng một cái gì đó như thế này:

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

Đây là một mã đơn giản cho mật khẩu ngẫu nhiên có độ dài 8:

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

Một phương pháp khác tôi muốn sử dụng:

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

Thêm ljustnếu bạn thực sự hoang tưởng về độ dài chuỗi chính xác:

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

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

Một cái gì đó từ Devise

Tôi nghĩ rằng đây là một sự cân bằng tốt đẹp của sự đồng nhất, rõ ràng và dễ sửa đổi.

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

Dễ dàng sửa đổi

Ví dụ: bao gồm các chữ số:

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

Hệ thập lục phân:

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

Đối với một loạt các nhân vật thực sự ấn tượng:

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

Chỉ cần thêm xu của tôi vào đây ...

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

Bạn có thể sử dụng String#randomtừ Facets of Ruby Gemfacets .

Về cơ bản nó làm điều này:

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

Yêu thích của tôi là (:A..:Z).to_a.shuffle[0,8].join. Lưu ý rằng shuffle yêu cầu Ruby> 1.9.

Giải pháp này cần sự phụ thuộc bên ngoài, nhưng có vẻ đẹp hơn giải pháp khác.

1. Cài đặt viên ngọc kẻ giả mạo
2. Faker::Lorem.characters(10) # => "ang9cbhoa8"

Được:

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

Biểu thức đơn, có thể được truyền dưới dạng đối số, cho phép các ký tự trùng lặp:

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

Tôi thích câu trả lời của Radar nhất, cho đến nay, tôi nghĩ vậy. Tôi muốn chỉnh sửa một chút như thế này:

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 xu của tôi:

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

Tôi chỉ viết một viên ngọc nhỏ random_tokenđể tạo mã thông báo ngẫu nhiên cho hầu hết trường hợp sử dụng, thưởng thức ~

https://github.com/sibevin/random_token

2 giải pháp cho một chuỗi ngẫu nhiên bao gồm 3 phạm vi:

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

Một nhân vật từ mỗi Phạm vi.

Và nếu bạn cần ít nhất một ký tự từ mỗi phạm vi, chẳng hạn như tạo mật khẩu ngẫu nhiên có một chữ hoa, một chữ cái viết thường và một chữ số, bạn có thể làm một cái gì đó như thế này:

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

Tôi đã làm một cái gì đó như thế này gần đây để tạo ra một chuỗi ngẫu nhiên 8 byte từ 62 ký tự. Các ký tự là 0-9, az, AZ. Tôi đã có một mảng trong số chúng như được lặp 8 lần và chọn một giá trị ngẫu nhiên trong mảng. Đây là một ứng dụng Rails.

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

Điều kỳ lạ là tôi có số lượng bản sao tốt. Bây giờ ngẫu nhiên điều này sẽ không bao giờ xảy ra. 62 ^ 8 là rất lớn, nhưng trong số 1200 hoặc hơn mã trong db tôi đã có một số lượng trùng lặp tốt. Tôi nhận thấy chúng xảy ra trên ranh giới giờ của nhau. Nói cách khác, tôi có thể thấy một bản sao vào lúc 12:12:23 và 2:12:22 hoặc đại loại như thế ... không chắc thời gian có phải là vấn đề hay không.

Mã này đã được tạo trước khi tạo đối tượng ActiveRecord. Trước khi bản ghi được tạo, mã này sẽ chạy và tạo mã 'duy nhất'. Các mục trong DB luôn được sản xuất một cách đáng tin cậy, nhưng mã ( strtrong dòng trên) đã được sao chép quá thường xuyên.

Tôi đã tạo một tập lệnh để chạy qua 100000 lần lặp của dòng trên với độ trễ nhỏ, do đó, sẽ mất 3-4 giờ với hy vọng sẽ thấy một kiểu mẫu lặp lại trên cơ sở hàng giờ, nhưng không thấy gì. Tôi không biết tại sao điều này lại xảy ra trong ứng dụng Rails của tôi.