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

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

임의 텍스트를 생성하려면 다음을 사용합니다.

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

이 코드는 단어 길이가 10자 미만인 50개의 임의 단어 문자열을 생성한 다음 공백으로 조인합니다.

SecureRandom을 사용하지 않는 이유는 무엇입니까?

require 'securerandom'
random_string = SecureRandom.hex

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

SecureRandom에는 다음과 같은 방법도 있습니다.

• 베이스64
• 랜덤_바이트
• 난수

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

최대 길이가 보장된 임의의 URL 친화적 문자열을 생성하는 데 사용합니다.

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

소문자 a-z 및 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=="

결과는 A-Z, a-z, 0-9, "-" 및 "_"를 포함할 수 있습니다. 패딩이 참인 경우에도 "="가 사용됩니다.

2 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/의 시간의 약 3/밖에 걸리지 않습니다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 타기.

시작: "의사 임의 문자열 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

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

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

디제프의 무언가

저는 이것이 간결함, 명확함, 그리고 수정의 용이성의 좋은 균형이라고 생각합니다.

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

이 솔루션은 외부 의존성이 필요하지만 다른 솔루션보다 더 예쁜 것 같습니다.

1. 젬페이커 설치
2. Faker::Lorem.characters(10) # => "ang9cbhoa8"

루비 젬의 패싯에서 사용할 수 있습니다.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셔플에는 루비 > 1.9가 필요합니다.

주어진:

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

인수로 전달할 수 있는 단일 식이 중복 문자를 허용합니다.

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

저는 최근에 62자의 8바이트 무작위 문자열을 생성하기 위해 이런 일을 하고 있었습니다.문자는 0-9, a-z, A-Z였습니다.저는 8번 반복해서 배열에서 임의의 값을 선택하는 배열을 가지고 있었습니다.이것은 레일즈 앱 안에 있었습니다.

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

이상한 것은 제가 많은 복제품을 받았다는 것입니다.무작위로 이런 일은 절대 일어나지 않아야 합니다.62^8은 엄청나지만 dbi에 있는 1200개 정도의 코드 중에서 상당한 수의 중복이 있었습니다.저는 그들이 서로의 시간 경계에서 일어나는 것을 알아차렸습니다.즉 12시 12분 23초와 2시 12분 22초에 커플을 볼 수도 있습니다.시간이 문제인지 아닌지 확실하지 않습니다.

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

저는 위 라인의 100,000번의 반복을 작은 지연으로 실행하기 위해 스크립트를 만들었습니다. 그래서 시간 단위로 반복 패턴을 볼 수 있기를 바라며 3-4시간이 걸리지만 아무것도 보지 못했습니다.저는 제 레일즈 앱에서 왜 이런 일이 일어났는지 전혀 모르겠습니다.

우리는 코드에서 이것을 사용해 왔습니다.

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

''.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

언급URL : https://stackoverflow.com/questions/88311/how-to-generate-a-random-string-in-ruby