Ruby'de rastgele bir dize nasıl oluşturulur

Şu anda "A" .. "Z" için 8 karakter sahte rasgele büyük harf dizesi üretiyorum:

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

ama temiz görünmüyor ve tek bir ifade olmadığı için argüman olarak aktarılamıyor. Karma bir dize "a" .. "z" artı "A" .. "Z" almak için:

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

ama çöp gibi görünüyor.

Daha iyi bir yöntemi olan var mı?

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

Golf yapmak için çok fazla zaman harcıyorum.

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

Ve daha da kafa karıştırıcı, ancak daha esnek ve daha az döngü harcayan sonuncusu:

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

Neden SecureRandom kullanmıyorsunuz?

require 'securerandom'
random_string = SecureRandom.hex

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

SecureRandom ayrıca aşağıdakiler için yöntemlere sahiptir:

• base64
• random_bytes
• RANDOM_NUMBER

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

Ben garanti maksimum uzunluğu ile rastgele URL dostu dizeleri oluşturmak için kullanın:

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

Küçük az ve 0-9 arası rastgele dizeler oluşturur. Çok özelleştirilebilir değil ama kısa ve temiz.

Bu çözüm, etkinleştirme kodları için kolayca okunabilen bir karakter dizisi oluşturur; İnsanların 8'i B, 1'i I, 0'ı O, L'yi 1 vb. İle karıştırmak istemedim.

# 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

Diğerleri de benzer bir şeyden bahsetti, ancak bu URL güvenli işlevini kullanıyor.

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

Sonuç AZ, az, 0-9, “-” ve “_” içerebilir. Dolgu doğru olduğunda “=” da kullanılır.

Ruby 2.5'den bu yana, gerçekten çok kolay SecureRandom.alphanumeric:

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

AZ, az ve 0-9 içeren rasgele dizeler oluşturur ve bu nedenle çoğu kullanım durumunda uygulanabilir olmalıdır. Ve rastgele bir şekilde üretilirler, bu da bir fayda olabilir.

Bu, en yüksek oyu alan çözümle karşılaştırmak için bir ölçüttür:

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)

Böylece randçözüm sadece yaklaşık 3/4 zaman alır SecureRandom. Çok sayıda dizgi oluşturursanız bu önemli olabilir, ancak zaman zaman rastgele bir dize oluşturursanız, her zaman daha güvenli bir uygulama ile giderim çünkü daha kolay ve daha açıktır.

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

Rastgele 8 harfli bir dize oluşturun (ör. NVAYXHGR)

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

Rastgele 8 karakterli bir dize (örn. 3PH4SWF2) oluşturun, 0/1 / I / O hariçtir. Yakut 1.9

Bunu nerede bulduğumu hatırlayamıyorum, ama benim için en iyi ve en az süreç yoğun görünüyor:

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

require 'securerandom'
SecureRandom.urlsafe_base64(9)

Belirtilen uzunlukta bir dize istiyorsanız şunu kullanın:

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

Ve 2niçeren rastgele bir uzunluk dizesi oluşturur0-9a-f

Array.new(n){[*"0".."9"].sample}.join, n=8sizin durumunuzda.

Genelleştirilmiş: Array.new(n){[*"A".."Z", *"0".."9"].sample}.joinvb.

Kimden: " AZ, 0-9 sözde rasgele dize oluştur ".

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

İşte uzunluğu 8 olan rastgele dize için bir satır basit kod:

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

Ayrıca uzunluğu 8 olan rastgele bir şifre için de kullanabilirsiniz:

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

Yakut 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"

Dikkat: randbir saldırgan için tahmin edilebilir ve bu nedenle muhtemelen güvensizdir. Şifre oluşturmak için kesinlikle SecureRandom kullanmalısınız. Böyle bir şey kullanıyorum:

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

İşte uzunluğu 8 olan rastgele şifre için basit bir kod:

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

Kullanmak istediğim başka bir yöntem:

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

ljustDoğru dize uzunluğu hakkında gerçekten paranoyaysanız ekleyin :

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

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

Devise'den bir şey

Bence bu hoşluk, açıklık ve modifikasyon kolaylığı arasında güzel bir denge.

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

Kolayca değiştirilebilir

Örneğin, rakamlar dahil:

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

Büyük harf onaltılık:

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

Gerçekten etkileyici bir karakter dizisi için:

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

Sadece sentlerimi buraya ekliyorum ...

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

String#randomRuby Geminin Şeylerinden kullanabilirsiniz facets.

Temel olarak bunu yapar:

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

Benim favorim (:A..:Z).to_a.shuffle[0,8].join. Karıştırma işleminin Ruby> 1.9 gerektirdiğini unutmayın.

Bu çözümün dışa bağımlı olması gerekiyor, ancak diğerinden daha güzel görünüyor.

1. Gem faker yükleyin
2. Faker::Lorem.characters(10) # => "ang9cbhoa8"

Verilen:

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

Tek bir ifade, bağımsız değişken olarak geçirilebilir, yinelenen karakterlere izin verir:

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

Radar'ın cevabını en çok seviyorum, şimdiye kadar. Bu şekilde biraz değiştiririm:

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 sentim:

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

Ben sadece random_tokençoğu kullanım durumda için rastgele jetonlar üretmek için küçük bir mücevher yazmak

https://github.com/sibevin/random_token

3 aralıktan oluşan rastgele bir dize için 2 çözüm:

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

Her Aralıktan Bir Karakter.

Ve her aralıktan bir büyük harf, bir küçük harf ve bir rakam içeren rastgele bir şifre oluşturmak gibi en az bir karaktere ihtiyacınız varsa, şöyle bir şey yapabilirsiniz:

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

Son zamanlarda böyle bir şey yapıyordum 62 karakterden 8 bayt rastgele dize üretmek için. Karakterler 0-9, az, AZ idi. Ben 8 kez döngü ve diziden rastgele bir değer toplama gibi onları bir dizi vardı. Bu bir Rails uygulamasının içindeydi.

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

Tuhaf olan, çok sayıda kopyamın olması. Şimdi rastgele bu neredeyse hiç olmamalı. 62 ^ 8 çok büyük, ama db 1200 veya kodları dışında çoğaltmaları iyi bir sayı vardı. Birbirlerinin saat sınırlarında olduklarını fark ettim. Başka bir deyişle, 12:12:23 ve 2:12:22 saatlerinde bir çift görebilirim ya da bunun gibi bir şey ... zamanın sorun olup olmadığından emin değilim.

Bu kod, bir ActiveRecord nesnesinin oluşturulmasından önce idi. Kayıt oluşturulmadan önce bu kod çalıştırılır ve 'benzersiz' kod oluşturulur. DB'deki girişler her zaman güvenilir bir şekilde üretildi, ancak kod ( stryukarıdaki satırda) çok sık kopyalandı.

Bu satırın 100000 yinelemesini küçük bir gecikmeyle çalıştırmak için bir komut dosyası oluşturdum, böylece saatte bir tür tekrarlama desenini görmeyi umarak 3-4 saat sürecek, ancak hiçbir şey göremedim. Bunun neden Rails uygulamamda olduğunu bilmiyorum.