So generieren Sie eine zufällige Zeichenfolge in Ruby

Ich generiere derzeit eine 8-stellige pseudozufällige Großbuchstabenzeichenfolge für "A" .. "Z":

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

aber es sieht nicht sauber aus und kann nicht als Argument übergeben werden, da es keine einzelne Aussage ist. Um eine Zeichenfolge mit gemischten Groß- und Kleinschreibung "a" .. "z" plus "A" .. "Z" zu erhalten, habe ich sie geändert in:

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

aber es sieht aus wie Müll.

Hat jemand eine bessere Methode?

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

Ich verbringe zu viel Zeit mit Golfen.

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

Und eine letzte, die noch verwirrender, aber flexibler ist und weniger Zyklen verschwendet:

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

Warum nicht SecureRandom verwenden?

require 'securerandom'
random_string = SecureRandom.hex

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

SecureRandom bietet auch Methoden für:

• base64
• random_bytes
• Zufallszahl

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

Ich verwende dies, um zufällige URL-freundliche Zeichenfolgen mit einer garantierten maximalen Länge zu generieren:

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

Es werden zufällige Zeichenfolgen mit Kleinbuchstaben az und 0-9 generiert. Es ist nicht sehr anpassbar, aber es ist kurz und sauber.

Diese Lösung generiert eine Zeichenfolge leicht lesbarer Zeichen für Aktivierungscodes. Ich wollte nicht, dass Leute 8 mit B, 1 mit I, 0 mit O, L mit 1 usw. verwechseln.

# 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

Andere haben etwas Ähnliches erwähnt, aber dies verwendet die URL-sichere Funktion.

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

Das Ergebnis kann AZ, az, 0-9, "-" und "_" enthalten. "=" Wird auch verwendet, wenn die Auffüllung wahr ist.

Seit Ruby 2.5 ist es ganz einfach mit SecureRandom.alphanumeric:

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

Es generiert zufällige Zeichenfolgen, die AZ, az und 0-9 enthalten, und sollte daher in den meisten Anwendungsfällen anwendbar sein. Und sie werden zufällig sicher generiert, was ebenfalls von Vorteil sein kann.

Dies ist ein Benchmark, um ihn mit der Lösung mit den meisten positiven Stimmen zu vergleichen:

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)

Die randLösung dauert also nur etwa 3/4 der Zeit von SecureRandom. Das mag wichtig sein, wenn Sie viele Zeichenfolgen generieren, aber wenn Sie von Zeit zu Zeit nur eine zufällige Zeichenfolge erstellen, würde ich immer die sicherere Implementierung wählen, da sie auch einfacher aufzurufen und expliziter ist.

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

Generieren Sie eine zufällige Zeichenfolge mit 8 Buchstaben (z. B. NVAYXHGR).

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

Generieren Sie eine zufällige 8-stellige Zeichenfolge (z. B. 3PH4SWF2) ohne 0/1 / I / O. Ruby 1.9

Ich kann mich nicht erinnern, wo ich das gefunden habe, aber es scheint mir der beste und der am wenigsten prozessintensive zu sein:

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

require 'securerandom'
SecureRandom.urlsafe_base64(9)

Wenn Sie eine Zeichenfolge mit der angegebenen Länge möchten, verwenden Sie:

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

Es wird eine zufällige Zeichenfolge der Länge erzeugen 2nenthält 0-9unda-f

Array.new(n){[*"0".."9"].sample}.join, wo n=8in deinem Fall.

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

Von: " Pseudozufallszeichenfolge AZ, 0-9 erzeugen ".

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

Hier ist ein einzeiliger einfacher Code für zufällige Zeichenfolgen mit der Länge 8:

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

Sie können es auch für ein zufälliges Passwort mit der Länge 8 verwenden:

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"

Seien Sie sich bewusst: randist für einen Angreifer vorhersehbar und daher wahrscheinlich unsicher. Sie sollten SecureRandom auf jeden Fall verwenden, wenn dies zum Generieren von Kennwörtern dient. Ich benutze so etwas:

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

Hier ist ein einfacher Code für ein zufälliges Passwort mit der Länge 8:

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

Eine andere Methode, die ich gerne benutze:

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

Fügen ljustSie hinzu, wenn Sie in Bezug auf die richtige Zeichenfolgenlänge wirklich paranoid sind:

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

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

Etwas von Devise

Ich denke, dies ist eine gute Balance zwischen Prägnanz, Klarheit und einfacher Modifikation.

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

Leicht zu modifizieren

Zum Beispiel einschließlich Ziffern:

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

Hexadezimal in Großbuchstaben:

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

Für eine wirklich beeindruckende Reihe von Charakteren:

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

Ich füge hier nur meine Cent hinzu ...

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

Sie können String#randomaus den Facetten von Ruby Gem verwenden facets.

Es macht im Grunde das:

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

Mein Favorit ist (:A..:Z).to_a.shuffle[0,8].join. Beachten Sie, dass für das Mischen Ruby> 1.9 erforderlich ist.

Diese Lösung benötigt externe Abhängigkeit, scheint aber hübscher als eine andere.

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

Gegeben:

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

Ein einzelner Ausdruck, der als Argument übergeben werden kann, ermöglicht doppelte Zeichen:

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

Die Antwort von Radar gefällt mir bisher am besten, denke ich. Ich würde ein bisschen so optimieren:

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} }

Meine 2 Cent:

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

Ich schreibe nur einen kleinen Edelstein random_token, um zufällige Token für den meisten Anwendungsfall zu generieren. Viel Spaß ~

https://github.com/sibevin/random_token

2 Lösungen für eine zufällige Zeichenfolge bestehend aus 3 Bereichen:

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

Ein Zeichen aus jedem Bereich.

Und wenn Sie mindestens ein Zeichen aus jedem Bereich benötigen, z. B. ein zufälliges Passwort mit einem Großbuchstaben, einem Kleinbuchstaben und einer Ziffer erstellen, können Sie Folgendes tun:

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

Ich habe kürzlich so etwas gemacht, um aus 62 Zeichen eine 8-Byte-Zufallszeichenfolge zu generieren. Die Zeichen waren 0-9, az, AZ. Ich hatte ein Array von ihnen, wie es 8-mal wiederholt wurde und einen zufälligen Wert aus dem Array auswählte. Dies war in einer Rails-App.

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

Das Seltsame ist, dass ich eine gute Anzahl von Duplikaten habe. Zufällig sollte dies so gut wie nie passieren. 62 ^ 8 ist riesig, aber von ungefähr 1200 Codes in der Datenbank hatte ich eine gute Anzahl von Duplikaten. Ich bemerkte, dass sie an Stundengrenzen voneinander passierten. Mit anderen Worten, ich könnte ein Duplikat um 12:12:23 und 2:12:22 oder so etwas sehen ... nicht sicher, ob die Zeit das Problem ist oder nicht.

Dieser Code wurde vor dem Erstellen eines ActiveRecord-Objekts erstellt. Bevor der Datensatz erstellt wurde, wurde dieser Code ausgeführt und der "eindeutige" Code generiert. Einträge in der DB wurden immer zuverlässig erstellt, aber der Code ( strin der obigen Zeile) wurde viel zu oft dupliziert.

Ich habe ein Skript erstellt, um 100000 Iterationen dieser obigen Zeile mit geringer Verzögerung zu durchlaufen, sodass es 3-4 Stunden dauern würde, in der Hoffnung, stündlich ein Wiederholungsmuster zu sehen, aber nichts zu sehen. Ich habe keine Ahnung, warum dies in meiner Rails-App passiert ist.