Ruby에서 임의의 문자열을 생성하는 방법

현재 "A".. "Z"에 대한 8 자리 의사 난수 대문자 문자열을 생성 중입니다.

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에는 다음과 같은 방법도 있습니다.

• base64
• 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,“-”및“_”이 포함될 수 있습니다. 패딩이 true 인 경우에도 "="가 사용됩니다.

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

0 / 1 / I / O를 제외하고 임의의 8 자 문자열 (예 : 3PH4SWF2)을 생성하십시오. 루비 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

루비 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

대문자 16 진수 :

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#randomRuby 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

내가 가장 좋아하는 것은 (:A..:Z).to_a.shuffle[0,8].join입니다. 셔플에는 Ruby> 1.9가 필요합니다.

이 솔루션에는 외부 종속성이 필요하지만 다른 솔루션보다 더 예쁘게 보입니다.

1. gem faker 설치
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

3 가지 범위로 구성된 임의 문자열에 대한 2 가지 솔루션 :

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

최근 62 자에서 8 바이트 임의 문자열을 생성하기 위해 이와 같은 작업을 수행했습니다. 문자는 0-9, az, AZ입니다. 나는 배열을 8 번 반복하고 배열에서 임의의 값을 선택했습니다. 이것은 Rails 앱 안에있었습니다.

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

이상한 것은 내가 좋은 수의 복제본을 얻었다는 것입니다. 이제 무작위로 이것은 거의 일어나지 않아야합니다. 62 ^ 8은 거대하지만 db의 1200 개 정도의 코드 중 많은 수가 중복되었습니다. 나는 그들이 서로의 시간 경계에서 일어나는 것을 보았습니다. 다시 말하면 12:12:23 및 2:12:22에서 듀플 또는 이와 유사한 것을 볼 수 있습니다 ... 시간이 문제인지 아닌지 확실하지 않습니다.

이 코드는 ActiveRecord 객체를 만들기 전에 작성되었습니다. 레코드가 작성되기 전에이 코드가 실행되고 '고유 한'코드가 생성됩니다. DB의 항목은 항상 안정적으로 생성되었지만 str위의 줄에있는 코드 는 너무 자주 복제되었습니다.

나는 작은 지연 으로이 위의 줄을 100000 회 반복 실행하는 스크립트를 만들었으므로 매시간 어떤 종류의 반복 패턴을보기를 기대하면서 3-4 시간이 걸리지 만 아무것도 보지 못했습니다. Rails 앱에서 왜 이런 일이 발생했는지 전혀 모르겠습니다.