Jak wygenerować losowy ciąg znaków w Ruby

Dlaczego nie użyć SecureRandom?

require 'securerandom'
random_string = SecureRandom.hex

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

SecureRandom ma również metody dla:

• base64
• random_bytes
• random_number

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

Używam tego do generowania losowych łańcuchów przyjaznych URL o gwarantowanej maksymalnej długości:

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

Generuje losowe ciągi małych liter a-z i 0-9. Nie jest zbyt konfigurowalny, ale jest krótki i czysty.

To rozwiązanie generuje ciąg łatwych do odczytania znaków dla kodów aktywacyjnych; nie chciałem, aby ludzie mylili 8 z B, 1 z I, 0 Z O, L z 1, itd.

# 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

Inni wspominali o czymś podobnym, ale używa To funkcji 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=="

Wynik może zawierać A-Z, A-Z, 0-9, " - "i"_". "="jest również używany, jeśli wypełnienie jest prawdziwe.

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

Wygeneruj losowy ciąg 8 liter (np. NVAYXHGR)

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

Wygenerować losowy ciąg 8 znaków (np. 3PH4SWF2), wyłączając 0/1/I/O. Ruby 1.9

Nie pamiętam, gdzie to znalazłem, ale wydaje mi się, że jest to najlepsze i najmniej intensywne procesowo:

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

require 'securerandom'
SecureRandom.urlsafe_base64(9)

Od ruby 2.5 naprawdę łatwo z SecureRandom.alphanumeric:

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

Generuje losowe łańcuchy zawierające A-Z, a-Z i 0-9 i dlatego powinny być stosowane w większości przypadków. I są one generowane losowo bezpieczne, co może być również korzyścią.

Edit: benchmark do porównania go z rozwiązaniem mającym najwięcej 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)

Więc rozwiązanie rand zajmuje tylko około 3/4 czasu SecureRandom. Może mieć znaczenie, jeśli generujesz naprawdę dużo ciągów, ale jeśli wystarczy stworzyć jakiś losowy ciąg znaków od czasu do czasu zawsze wybierałbym bardziej bezpieczną implementację (ponieważ jest również łatwiejsze do wywołania i bardziej wyraźne).

Jeśli chcesz ciąg o określonej długości, użyj:

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

Wygeneruje losowy ciąg o długości 2n zawierający 0-9 i a-f

Array.new(n){[*"0".."9"].sample}.join, gdzie n = 8 w Twoim przypadku.

Uogólnione: Array.new(n){[*"A".."Z", *"0".."9"].sample}.join, itd. - from this answer

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

Oto jeden wiersz prosty kod dla losowego ciągu o długości 8

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

Możesz również użyć go do losowego hasła o długości 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"

Oto jeden prosty kod dla losowego hasła z lenth 8

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

Bądź świadomy: rand jest przewidywalny dla atakującego, a zatem prawdopodobnie niepewny. Zdecydowanie powinieneś użyć SecureRandom, jeśli jest to do generowania haseł. Używam czegoś takiego:

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

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

Coś z Devise

Inna metoda, którą lubię używać

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

Dodaj ljust, jeśli naprawdę masz paranoję co do prawidłowej długości strun:

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

Myślę, że to miła równowaga zwięzłości, jasności i łatwości modyfikacji.

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

Łatwo modyfikować

Na przykład, w tym cyfry:

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

Wielkie Litery szesnastkowe:

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

Dla naprawdę imponującej tablicy znaków:

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

Dodaję tu moje grosze...

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

Możesz użyć String#random z aspektów rubinowego klejnotu facets:

Https://github.com/rubyworks/facets/blob/126a619fd766bc45588cac18d09c4f1927538e33/lib/core/facets/string/random.rb

W zasadzie robi to:

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

Moim ulubionym jest (:A..:Z).to_a.shuffle[0,8].join. Zauważ, że shuffle wymaga Ruby > 1.9.

To rozwiązanie wymaga zależności zewnętrznej, ale wydaje się ładniejsze niż inne.

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

Podane:

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

Pojedyncze wyrażenie, może być przekazane jako argument, pozwala na duplikowanie znaków:

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

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

Moje 2 grosze:

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

Po prostu piszę mały klejnot random_token aby wygenerować losowe tokeny dla większości przypadków użycia, enjoy ~

Https://github.com/sibevin/random_token

Dzięki tej metodzie możesz przejść w długości abitralnej. Jest ustawiony jako domyślny jako 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

Jak na razie najbardziej podoba mi się odpowiedź Radara. Podkręciłbym trochę tak:

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

Ostatnio robiłem coś takiego, aby wygenerować losowy ciąg 8 bajtów z 62 znaków. Znaki były 0-9, a-z,A-Z. miałem tablicę z nich, jak było zapętlanie 8 razy i wybierając losową wartość z tablicy. To było wewnątrz aplikacji rails.

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

Ten kod był przed utworzeniem obiektu activerecord. Przed utworzeniem rekordu kod ten uruchamiał się i generował kod 'unikalny'. Wpisy w db zawsze były tworzone rzetelnie, ale kod (str w powyższej linii) był powielany zbyt często.

I created a script to run through 100000 iteracji tej powyżej linii z niewielkim opóźnieniem, więc zajęłoby to 3-4 godziny w nadziei, że zobaczę jakiś wzór powtarzania na godzinę, ale nic nie widziałem. Nie mam pojęcia, dlaczego tak się dzieje w mojej aplikacji rails.