Как сгенерировать случайную строку в Ruby

Чтобы превратить ваше первое в одно заявление:

(0...8).collect { |n| value  << (65 + rand(25)).chr }.join()

(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

Я не знаю Ruby, поэтому я не могу дать вам точный синтаксис, но я бы установил постоянную строку со списком допустимых символов, а затем использовал бы оператор подстроки, чтобы выбрать из нее случайный символ.

Преимущество здесь в том, что если предполагается, что строка может вводиться пользователем, вы можете исключить легко запутанные символы, такие как l и 1 и i, 0 и O, 5 и S и т. д.

Это почти так же уродливо, но, может быть, как шаг в правильном направлении?

 (1..8).map{|i| ('a'..'z').to_a[rand(26)]}.join

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

Мы использовали это в нашем коде:

class String

  def self.random(length=10)
    ('a'..'z').sort_by {rand}[0,length].join
  end

end

Максимальная поддерживаемая длина - 25 (в любом случае мы используем ее только со значением по умолчанию, поэтому проблем не возникло).

Кто-то упомянул, что "a" .. "z" неоптимально, если вы хотите полностью избежать появления оскорбительных слов. Одна из наших идей заключалась в том, чтобы удалить гласные, но вы все равно получите WTFBBQ и т. д.

С помощью этого метода вы можете передавать произвольную длину. По умолчанию установлено 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

Я думаю, что пока что мне больше всего нравится ответ Радара. Я бы немного подправил вот так:

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

Это решение генерирует строку легко читаемых символов для кодов активации; Я не хотел, чтобы люди путали 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

Я не могу вспомнить, где я это нашел, но мне кажется, что это лучший и наименее интенсивный процесс:

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

В Ruby 1.9 можно использовать метод выбора массива, который возвращает случайный элемент из массива.

Почему бы не использовать SecureRandom?

require 'securerandom'
random_string = SecureRandom.hex

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

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

• base64
• random_bytes
• случайный номер

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

Еще один метод, который мне нравится использовать:

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

Добавьте ljust, если вы действительно не уверены в правильной длине строки:

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

`pwgen 8 1`.chomp

Рубин 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"

Недавно я делал что-то подобное, чтобы сгенерировать 8-байтовую случайную строку из 62 символов. Символы были 0-9, a-z, A-Z. У меня был их массив, так как он 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.

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

string_length = 8
rand(36**string_length).to_s(36)

Он генерирует случайные строки строчных букв a-z и 0-9. Он не очень настраиваемый, но короткий и чистый.

попробуйте это

def rand_name(len=9)
  ary = [('0'..'9').to_a, ('a'..'z').to_a, ('A'..'Z').to_a]
  name = ''

  len.times do
    name << ary.choice.choice
  end
  name
end

Мне нравятся ответы в этой ветке, они действительно были очень полезны! Но если я могу сказать, ни один из них не удовлетворяет меня, возможно, это метод rand (). мне это просто не кажется правильным, поскольку у нас есть метод выбора Array # на этот счет.

Данный:

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

Одно выражение, которое может быть передано в качестве аргумента, допускает повторяющиеся символы:

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

Я думаю, что это хороший баланс лаконичности, ясности и простоты модификации.

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

Вот еще один способ:

• Он использует безопасный генератор случайных чисел вместо rand ()
• Может использоваться в URL-адресах и именах файлов
• Содержит прописные, строчные буквы и цифры.
• Есть возможность не включать неоднозначные символы I0l01

Требуется require "securerandom"

def secure_random_string(length = 32, non_ambiguous = false)
  characters = ('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a

  %w{I O l 0 1}.each{ |ambiguous_character| 
    characters.delete ambiguous_character 
  } if non_ambiguous

  (0...length).map{
    characters[ActiveSupport::SecureRandom.random_number(characters.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= = "

Результат может содержать A-Z, a-z, 0-9, «-» и «_». «=» Также используется, если заполнение истинно.

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

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

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"

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

Что-то от Devise

Это основано на нескольких других ответах, но добавляет немного больше сложности:

def random_password
  specials = ((32..47).to_a + (58..64).to_a + (91..96).to_a + (123..126).to_a).pack('U*').chars.to_a
  numbers  = (0..9).to_a
  alpha    = ('a'..'z').to_a + ('A'..'Z').to_a
  %w{i I l L 1 O o 0}.each{ |ambiguous_character| 
    alpha.delete ambiguous_character 
  }
  characters = (alpha + specials + numbers)
  password = Random.new.rand(8..18).times.map{characters.sample}
  password << specials.sample unless password.join =~ Regexp.new(Regexp.escape(specials.join))
  password << numbers.sample  unless password.join =~ Regexp.new(Regexp.escape(numbers.join))
  password.shuffle.join
end

По сути, он обеспечивает пароль длиной от 8 до 20 символов, который содержит как минимум одну цифру и один специальный символ.

Мои 2 цента:

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

Просто добавляю сюда свои центы ...

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

Если вы используете UNIX и по-прежнему должны использовать Ruby 1.8 (без SecureRandom) без Rails, вы также можете использовать это:

random_string = `openssl rand -base64 24`

Обратите внимание, что это порождает новую оболочку, это очень медленно и может быть рекомендовано только для скриптов.

require 'securerandom'
SecureRandom.urlsafe_base64(9)

Вот один простой код для случайного пароля длиной 8:

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

Имейте в виду: 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

При необходимости создайте пустую строку или префикс:

myStr = "OID-"

Используйте этот код для заполнения строки случайными числами:

begin; n = ((rand * 43) + 47).ceil; myStr << n.chr if !(58..64).include?(n); end while(myStr.length < 12)

Примечания:

(rand * 43) + 47).ceil

Он будет генерировать случайные числа от 48-91 (0,1,2..Y, Z)

!(58..64).include?(n)

Он используется для пропуска специальных символов (поскольку мне не интересно их включать)

while(myStr.length < 12)

Он сгенерирует строку длиной 12 символов, включая префикс.

Пример вывода:

"OID-XZ2J32XM"

Если вам нужна строка указанной длины, используйте:

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

Он сгенерирует случайную строку длины 2n, содержащую 0-9 и a-f.

Вот решение, которое является гибким и допускает дублирование:

class String
  # generate a random string of length n using current string as the source of characters
  def random(n)
    return "" if n <= 0
    (chars * (n / length + 1)).shuffle[0..n-1].join  
  end
end

Пример:

"ATCG".random(8) => "CGTGAAGA"

Вы также можете разрешить более частое появление определенного персонажа:

"AAAAATCG".random(10) => "CTGAAAAAGC"

Объяснение: Вышеупомянутый метод принимает символы данной строки и генерирует достаточно большой массив. Затем он перемешивает его, берет первые n элементов и присоединяется к ним.

Мой фаворит - (:A..:Z).to_a.shuffle[0,8].join. Обратите внимание, что для перемешивания требуется Ruby> 1.9.

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

https://github.com/sibevin/random_token

Array.new(8).inject(""){|r|r<<('0'..'z').to_a.shuffle[0]}  # 57
(1..8).inject(""){|r|r<<('0'..'z').to_a.shuffle[0]}        # 51
e = "";8.times{e<<('0'..'z').to_a.shuffle[0]};e              # 45
(1..8).map{('0'..'z').to_a.shuffle[0]}.join                # 43
(1..8).map{rand(49..122).chr}.join                         # 34

Еще один трюк, который работает с Ruby 1.8+ и работает так же быстро, как:

>> require "openssl"
>> OpenSSL::Random.random_bytes(20).unpack('H*').join
=> "2f3ff53dd712ba2303a573d9f9a8c1dbc1942d28"

Он дает вам случайную шестнадцатеричную строку. Аналогичным образом вы сможете сгенерировать строку base64 ('M *').

Вы можете использовать String#random из Facets of Ruby Gem 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

Array.new(n){[*"0".."9"].sample}.join, где n=8 в вашем случае.

Обобщенный: Array.new(n){[*"A".."Z", *"0".."9"].sample}.join и др.

От: "Сгенерировать псевдослучайную строку A-Z, 0-9".

Вот однострочный простой код для случайной строки длиной 8:

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

Вы также можете использовать его для случайного пароля длиной 8:

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

Это решение требует внешней зависимости, но кажется красивее другого.

1. Установить гем притворщик
2. Faker::Lorem.characters(10) # => "ang9cbhoa8"

10.times do 
  alphabet = ('a'..'z').to_a
  string += alpha[rand(alpha.length)]
end

Для разработки secure_validatable вы можете использовать это

(0 ... 8) .map {([65, 97] .sample + rand (26)). Chr} .push (rand (99)). Join

a='';8.times{a<<[*'a'..'z'].sample};p a

или же

8.times.collect{[*'a'..'z'].sample}.join

Начиная с Ruby 2.5, с SecureRandom.alphanumeric это действительно просто:

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

Он генерирует случайные строки, содержащие A-Z, a-z и 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. Это может иметь значение, если вы генерируете много строк, но если вы просто время от времени создаете какую-то случайную строку, я всегда буду использовать более безопасную реализацию, поскольку ее также проще вызывать и более явным.

Вот улучшенный ответ @Travis R:

 def random_string(length=5)
    chars = 'abdefghjkmnpqrstuvwxyzABDEFGHJKLMNPQRSTUVWXYZ'
    numbers = '0123456789'
    random_s = ''
    (length/2).times { random_s << numbers[rand(numbers.size)] }
    (length - random_s.length).times { random_s << chars[rand(chars.size)] }
    random_s.split('').shuffle.join
  end

В ответах @Travis R символы и числа были вместе, поэтому иногда random_string мог возвращать только числа или только символы. Благодаря этому усовершенствованию, по крайней мере, половина random_string будет состоять из символов, а остальные - из чисел. На всякий случай, если нужна случайная строка с цифрами и символами

Используйте самоцвет SafeRandom GithubLink

Это обеспечит самый простой способ генерации случайных значений для совместимых с Rails2, Rails 3, Rails 4, Rails 5.