Як генерувати випадкову рядок у Ruby

Наразі я генерую 8-символьний псевдослучайний рядок верхнього регістру для "A" .. "Z":

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

але це не виглядає чисто, і це не може бути передано як аргумент, оскільки це не одне твердження. Щоб отримати рядок змішаного регістру "a" .. "z" плюс "A" .. "Z", я змінив його на:

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

але це схоже на сміття.

Хтось має кращий метод?

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

Я витрачаю занадто багато часу на гольф.

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

І останнє, яке ще більше заплутує, але гнучкіше і витрачає менше циклів:

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

Чому б не використовувати SecureRandom?

require 'securerandom'
random_string = SecureRandom.hex

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

SecureRandom також має методи для:

• база64
• random_bytes
• random_number

див .: http://ruby-doc.org/stdlib-1.9.2/libdoc/securerandom/rdoc/SecureRandom.html

Я використовую це для створення випадкових URL-адрес із гарантованою максимальною довжиною:

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

Він генерує випадкові рядки з малого az та 0-9. Це не дуже настроюється, але він короткий і чистий.

Це рішення створює рядок легко читаються символів для кодів активації; Я не хотів, щоб люди плутали 8 з B, 1 з I, 0 з O, L з 1 і т.д.

# 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

Інші згадували щось подібне, але для цього використовується безпечна функція URL.

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

Результат може містити AZ, az, 0-9, “-” та “_”. "=" Також використовується, якщо підкладка є правдою.

З Ruby 2.5 це дуже просто SecureRandom.alphanumeric:

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

Він генерує випадкові рядки, що містять AZ, az і 0-9, тому повинні бути застосовні у більшості випадків використання. І вони генеруються випадковим чином безпечним, що теж може бути користю.

Це орієнтир, щоб порівняти його з рішенням, що має найбільшу ціну:

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)

Тож randрішення займає лише приблизно 3/4 часу часу SecureRandom. Це може мати значення, якщо ви генеруєте багато рядків, але якщо ви час від часу просто створюєте якусь випадкову рядок, я б завжди переходив із більш безпечною реалізацією, оскільки це також простіше зателефонувати і більш чітко.

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

Створіть випадковий рядок з 8 літер (наприклад, NVAYXHGR)

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

Створіть випадкову 8-символьну рядок (наприклад, 3PH4SWF2), виключаючи 0/1 / I / O. Рубін 1.9

Я не можу згадати, де я це знайшов, але це здається мені найкращим і найменш інтенсивним процесом:

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

require 'securerandom'
SecureRandom.urlsafe_base64(9)

Якщо ви хочете рядок заданої довжини, використовуйте:

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

Це створить випадкову рядок довжини, 2nщо містить 0-9іa-f

Array.new(n){[*"0".."9"].sample}.join, де n=8 у вашому випадку.

Узагальнено: Array.new(n){[*"A".."Z", *"0".."9"].sample}.join тощо.

З: " Створити псевдо випадкову рядок AZ, 0-9 ".

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

Ось один простий простий код для випадкового рядка довжиною 8:

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

Ви також можете використовувати його для випадкового пароля довжиною 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"

Будьте в курсі: randпередбачувано для зловмисника і тому, ймовірно, небезпечно. Ви обов'язково повинні використовувати SecureRandom, якщо це створено для генерування паролів. Я використовую щось подібне:

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

Ось один простий код для випадкового пароля довжиною 8:

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

Ще один метод, який я люблю використовувати:

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

Додайте, ljustякщо ви дійсно параноїчні щодо правильної довжини рядка:

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

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

Щось із Devise

Я думаю, що це приємний баланс лаконічності, ясності та простоти модифікації.

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

Легко модифікується

Наприклад, включаючи цифри:

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

Великий шістнадцятковий:

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

Для справді вражаючого набору символів:

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

Просто додаю сюди свої центи ...

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

Ви можете використовувати String#randomз граней Рубі Джем facets.

Це в основному так:

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

Моя улюблена (:A..:Z).to_a.shuffle[0,8].join. Зауважте, що для переміщення потрібен Ruby> 1.9.

Це рішення потребує зовнішньої залежності, але здається гарнішим за інше.

1. Встановіть драйвер для самоцвітів
2. Faker::Lorem.characters(10) # => "ang9cbhoa8"

Подано:

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

Один вираз, може передаватися як аргумент, дозволяє повторювати символи:

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

Найкраще мені подобається відповідь Радара, я думаю. Я хотів би трохи підробити це:

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 копійки:

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

Я просто записую невеликий дорогоцінний камінь, random_tokenщоб генерувати випадкові маркери для більшості випадків використання, насолоджуйтесь ~

https://github.com/sibevin/random_token

2 рішення для випадкової рядки, що складається з 3 діапазонів:

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

По одному символу з кожного діапазону.

І якщо вам потрібно щонайменше один символ з кожного діапазону, наприклад створити випадковий пароль, який містить одну велику, одну малу літеру та одну цифру, ви можете зробити щось подібне:

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

Нещодавно я робив щось подібне, щоб генерувати 8-байтний випадковий рядок із 62 символів. Символів було 0-9, az, AZ. У мене був масив з них, як був циклічний 8 разів і вибір випадкового значення з масиву. Це було в додатку Rails.

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

Дивне те, що я отримав гарну кількість дублікатів. Зараз випадково це майже не повинно відбуватися. 62 ^ 8 - величезна кількість, але з 1200 або близько кодів у db у мене було багато дублікатів. Я помітив, як вони відбуваються на годинних межах один одного. Іншими словами, я можу побачити дуель у 12:12:23 та 2:12:22 або щось подібне ... не впевнений, час у цьому питання чи ні.

Цей код був у створеному раніше об'єкті ActiveRecord. До створення запису цей код запускався та генерував би "унікальний" код. Записи в БД завжди вироблялися надійно, але код (str у наведеному вище рядку) дублювався надто часто.

Я створив сценарій, щоб пропустити 100000 ітерацій цього вище рядка з невеликою затримкою, тож це займе 3-4 години, сподіваючись щогодини побачити якусь схему повторення, але нічого не побачило. Я поняття не маю, чому це відбувається в моєму додатку Rails.