Cara menghasilkan string acak di Ruby

Saat ini saya sedang membuat string huruf kapital pseudo-acak 8-karakter untuk "A" .. "Z":

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

tapi itu tidak terlihat bersih, dan itu tidak bisa diajukan sebagai argumen karena itu bukan pernyataan tunggal. Untuk mendapatkan string case campuran "a" .. "z" plus "A" .. "Z", saya mengubahnya menjadi:

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

tapi sepertinya sampah.

Adakah yang punya metode yang lebih baik?

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

Saya menghabiskan terlalu banyak waktu bermain golf.

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

Dan yang terakhir bahkan lebih membingungkan, tetapi lebih fleksibel dan membuang lebih sedikit siklus:

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

Mengapa tidak menggunakan SecureRandom?

require 'securerandom'
random_string = SecureRandom.hex

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

SecureRandom juga memiliki metode untuk:

• base64
• random_bytes
• angka acak

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

Saya menggunakan ini untuk menghasilkan string ramah URL acak dengan panjang maksimum yang dijamin:

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

Ini menghasilkan string acak dari huruf kecil az dan 0-9. Ini tidak sangat dapat dikustomisasi tetapi pendek dan bersih.

Solusi ini menghasilkan serangkaian karakter yang mudah dibaca untuk kode aktivasi; Saya tidak ingin orang membingungkan 8 dengan B, 1 dengan I, 0 dengan O, L dengan 1, dll.

# 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

Yang lain menyebutkan sesuatu yang serupa, tetapi ini menggunakan fungsi URL safe.

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

Hasilnya mungkin mengandung AZ, az, 0-9, “-” dan “_”. “=” Juga digunakan jika bantalan benar.

Sejak Ruby 2.5, sangat mudah dengan SecureRandom.alphanumeric:

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

Ini menghasilkan string acak yang mengandung AZ, az dan 0-9 dan karenanya harus berlaku di sebagian besar kasus penggunaan. Dan mereka dihasilkan secara acak aman, yang mungkin bermanfaat juga.

Ini adalah tolok ukur untuk membandingkannya dengan solusi yang paling banyak mendapat dukungan:

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)

Jadi randsolusinya hanya membutuhkan sekitar 3/4 dari waktu SecureRandom. Itu mungkin penting jika Anda menghasilkan banyak string, tetapi jika Anda hanya membuat beberapa string acak dari waktu ke waktu, saya akan selalu menggunakan implementasi yang lebih aman karena juga lebih mudah untuk dipanggil dan lebih eksplisit.

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

Hasilkan string 8 huruf acak (mis. NVAYXHGR)

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

Menghasilkan string 8 karakter acak (mis. 3PH4SWF2), tidak termasuk 0/1 / I / O. Ruby 1.9

Saya tidak ingat di mana saya menemukan ini, tetapi sepertinya yang terbaik dan paling sedikit proses intensif bagi saya:

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

require 'securerandom'
SecureRandom.urlsafe_base64(9)

Jika Anda ingin string dengan panjang tertentu, gunakan:

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

Ini akan menghasilkan string acak yang 2nberisi panjang 0-9dana-f

Array.new(n){[*"0".."9"].sample}.join, n=8di mana dalam kasus Anda.

Umum:, Array.new(n){[*"A".."Z", *"0".."9"].sample}.joindll.

Dari: " Hasilkan string pseudo acak AZ, 0-9 ".

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

Berikut ini adalah satu baris kode sederhana untuk string acak dengan panjang 8:

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

Anda juga dapat menggunakannya untuk kata sandi acak yang panjangnya 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"

Waspada: randdapat diprediksi untuk penyerang dan karena itu mungkin tidak aman. Anda harus menggunakan SecureRandom jika ini untuk menghasilkan kata sandi. Saya menggunakan sesuatu seperti ini:

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

Berikut adalah satu kode sederhana untuk kata sandi acak dengan panjang 8:

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

Metode lain yang saya suka gunakan:

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

Tambahkan ljustjika Anda benar-benar paranoid tentang panjang string yang benar:

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

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

Sesuatu dari Rancangan

Saya pikir ini adalah keseimbangan yang baik antara keringkasan, kejelasan, dan kemudahan modifikasi.

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

Mudah dimodifikasi

Misalnya, termasuk digit:

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

Heksadesimal huruf besar:

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

Untuk serangkaian karakter yang benar-benar mengesankan:

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

Cukup tambahkan sen saya di sini ...

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

Anda dapat menggunakan String#randomdari Aspek Ruby Gem facets.

Ini pada dasarnya melakukan ini:

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

Favorit saya adalah (:A..:Z).to_a.shuffle[0,8].join. Perhatikan bahwa shuffle memerlukan Ruby> 1.9.

Solusi ini membutuhkan ketergantungan eksternal, tetapi tampaknya lebih cantik daripada yang lain.

1. Instal permata faker
2. Faker::Lorem.characters(10) # => "ang9cbhoa8"

Diberikan:

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

Ekspresi tunggal, dapat disampaikan sebagai argumen, memungkinkan karakter duplikat:

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

Saya suka jawaban Radar, sejauh ini, saya pikir. Saya akan mengubah sedikit seperti ini:

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 sen saya:

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

Saya hanya menulis permata kecil random_token untuk menghasilkan token acak untuk sebagian besar kasus penggunaan, selamat menikmati ~

https://github.com/sibevin/random_token

2 solusi untuk string acak yang terdiri dari 3 rentang:

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

Satu Karakter dari masing-masing Rentang.

Dan jika Anda memerlukan setidaknya satu karakter dari setiap rentang, seperti membuat kata sandi acak yang memiliki satu huruf besar, satu huruf kecil dan satu digit, Anda dapat melakukan sesuatu seperti ini:

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

Saya melakukan sesuatu seperti ini baru-baru ini untuk menghasilkan string acak 8 byte dari 62 karakter. Karakternya 0-9, az, AZ. Saya memiliki array seperti looping 8 kali dan memilih nilai acak dari array. Ini ada di dalam aplikasi Rails.

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

Yang aneh adalah saya mendapat duplikat dalam jumlah yang banyak. Sekarang secara acak ini seharusnya tidak pernah terjadi. 62 ^ 8 sangat besar, tetapi dari 1.200 kode di db saya punya banyak duplikat. Saya perhatikan mereka terjadi pada batas jam satu sama lain. Dengan kata lain saya mungkin melihat duple pada 12:12:23 dan 2:12:22 atau sesuatu seperti itu ... tidak yakin apakah waktu adalah masalah atau tidak.

Kode ini di sebelum membuat objek ActiveRecord. Sebelum catatan dibuat, kode ini akan menjalankan dan menghasilkan kode 'unik'. Entri dalam DB selalu diproduksi dengan andal, tetapi kode ( strpada baris di atas) terlalu sering diduplikasi.

Saya membuat skrip untuk menjalankan melalui 100000 iterasi baris di atas ini dengan penundaan kecil sehingga akan memakan waktu 3-4 jam berharap untuk melihat semacam pola pengulangan setiap jam, tetapi tidak melihat apa pun. Saya tidak tahu mengapa ini terjadi di aplikasi Rails saya.