Jak wygenerować losowy ciąg w Ruby

Obecnie generuję 8-znakowy pseudolosowy ciąg wielkich liter dla „A” .. „Z”:

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

ale nie wygląda na czysty i nie można go przekazać jako argumentu, ponieważ nie jest to pojedyncze stwierdzenie. Aby uzyskać ciąg „a” .. „z” plus „A” .. „Z”, zmieniłem go na:

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

ale wygląda jak śmieci.

Czy ktoś ma lepszą metodę?

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

Zbyt dużo czasu spędzam na grze w golfa.

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

I ostatni, jeszcze bardziej zagmatwany, ale bardziej elastyczny i marnujący mniej cykli:

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

Dlaczego nie skorzystać z SecureRandom?

require 'securerandom'
random_string = SecureRandom.hex

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

SecureRandom ma również metody:

• base64
• random_bytes
• Liczba losowa

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

Używam tego do generowania ciągów przyjaznych losowym adresom URL o gwarantowanej maksymalnej długości:

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

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

To rozwiązanie generuje ciąg łatwo czytelnych znaków dla kodów aktywacyjnych; Nie chciałem, żeby 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 bezpiecznej funkcji adresu URL.

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ć AZ, az, 0-9, „-” i „_”. „=” Jest także używane, jeśli wypełnienie jest prawdziwe.

Od Ruby 2.5 jest to naprawdę łatwe dzięki SecureRandom.alphanumeric:

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

Generuje losowe ciągi zawierające AZ, az i 0-9 i dlatego powinno mieć zastosowanie w większości przypadków użycia. I są generowane losowo bezpieczne, co również może być zaletą.

Jest to punkt odniesienia w porównaniu z rozwiązaniem mającym najwięcej pozytywnych opinii:

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)

Tak więc randrozwiązanie zajmuje tylko około 3/4 czasu SecureRandom. Może to mieć znaczenie, jeśli wygenerujesz wiele ciągów, ale jeśli od czasu do czasu utworzysz jakiś losowy ciąg, zawsze będę korzystał z bezpieczniejszej implementacji, ponieważ łatwiej jest także wywoływać i bardziej jawnie.

[*('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

Wygeneruj losowy ciąg 8 znaków (np. 3PH4SWF2), z wyłączeniem 0/1 / I / O. Ruby 1.9

Nie pamiętam, gdzie to znalazłem, ale wydaje mi się, że to najlepszy i najmniej wymagający proces:

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

require 'securerandom'
SecureRandom.urlsafe_base64(9)

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

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

Wygeneruje losowy ciąg długości 2nzawierający 0-9ia-f

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

Uogólnione: Array.new(n){[*"A".."Z", *"0".."9"].sample}.joinitp.

Od: „ Wygeneruj pseudolosowy ciąg AZ, 0–9 ”.

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

Oto prosty, jednoliniowy kod losowego ciągu o długości 8:

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

Możesz go również użyć 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"

Bądź świadomy: randjest przewidywalny dla atakującego i dlatego 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

Oto jeden prosty kod losowego hasła o długości 8:

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

Kolejna metoda, której lubię używać:

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

Dodaj, ljustjeśli naprawdę jesteś paranoikiem w kwestii prawidłowej długości łańcucha:

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

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

Coś z Devise

Myślę, że to niezł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 modyfikowany

Na przykład z cyframi:

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

Aby uzyskać naprawdę imponujący zestaw znaków:

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

Właśnie dodałem tutaj swoje centy ...

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

Możesz użyć String#randomz Facets of Ruby Gem facets.

Zasadniczo 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 losowanie wymaga Ruby> 1.9.

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

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

Dany:

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

Pojedyncze wyrażenie, które można przekazać jako argument, umożliwia duplikowanie znaków:

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

Myślę, że najbardziej podoba mi się odpowiedź Radar. Poprawił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

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

Moje 2 centy:

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

Właśnie piszę mały klejnot, random_tokenaby wygenerować losowe tokeny dla większości przypadków użycia, ciesz się ~

https://github.com/sibevin/random_token

2 rozwiązania dla ciągu losowego składającego się z 3 zakresów:

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

Jedna postać z każdego zakresu.

A jeśli potrzebujesz co najmniej jednego znaku z każdego zakresu, na przykład utworzenia losowego hasła, które ma jedną wielką literę, jedną małą literę i jedną cyfrę, możesz zrobić coś takiego:

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

Ostatnio robiłem coś takiego, aby wygenerować 8-bajtowy ciąg losowy z 62 znaków. Znaki to 0-9, az, AZ. Miałem ich tablicę, ponieważ zapętlałem 8 razy i wybrałem losową wartość z tablicy. To było w aplikacji Rails.

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

Dziwne jest to, że mam dużą liczbę duplikatów. Teraz losowo to raczej nie powinno się zdarzyć. 62 ^ 8 jest ogromny, ale z około 1200 kodów w db miałem dużą liczbę duplikatów. Zauważyłem, że zdarzają się one na godzinnych granicach. Innymi słowy, mogę zobaczyć duplikat o 12:12:23 i 2:12:22 lub coś w tym rodzaju ... nie jestem pewien, czy czas jest problemem, czy nie.

Ten kod znajdował się przed utworzeniem obiektu ActiveRecord. Przed utworzeniem rekordu ten kod działałby i generował „unikalny” kod. Wpisy w DB zawsze były tworzone niezawodnie, ale kod ( strw powyższym wierszu) był zbyt często kopiowany.

Stworzyłem skrypt, który uruchamiałby 100 000 iteracji powyższej linii z niewielkim opóźnieniem, więc zajęłoby to 3-4 godziny w nadziei, że zobaczę jakiś wzór powtarzalny co godzinę, ale nic nie zobaczyłem. Nie mam pojęcia, dlaczego tak się dzieje w mojej aplikacji Rails.