random string in ruby

random.string.rb

# Only upper case alphabets [A-Z]
value = "";
8.times{value  << (65 + rand(25)).chr} >>}
#or
(0...8).map{65.+(rand(26)).chr}.join
(0...8).map{ ('A'..'Z').to_a[rand(26)]  }.join

# Lower case and upper case [a-zA-Z]
value = "";
8.times{value << ((rand(2)==1?65:97) + rand(25)).chr} >>}
#or
o =  [('a'..'z'),('A'..'Z')].map{|i| i.to_a}.flatten
string  =  (0...50).map{ o[rand(o.length)]  }.join

# Using SecureRandom provided by ActiveSupport
require 'active_support/secure_random'
random_string = ActiveSupport::SecureRandom.hex(16)
# outputs: 5b5cd0da3121fc53b4bc84d0c8af2e81

# SecureRandom also has methods for: base64
# hex
# random_bytes
# random_number

# It is also important to avoid Ambiguity
# 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

# Random URL Friendly Strings
rand(36**length).to_s(36)

# One more example with SecureRandom
require 'securerandom'
s = SecureRandom.urlsafe_base64(20)

# Creating a Random string with arguments
def random_string(length=10)
  chars = 'abcdefghjkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789'
  password = ''
  length.times { password << chars[rand(chars.size)] }
  password
end

# This example works Only in ruby 1.9
[*('A'..'Z')].sample(8).join
#Generate a random 8 letter string (e.g. NVAYXHGR)

([*('A'..'Z'),*('0'..'9')]-%w(0 1 I O)).sample(8).join
#Generate a random 8 character string (e.g. 3PH4SWF2), excludes 0/1/I/O. Ruby 1.9
ALPHABET = ('a'..'z').to_a
10.times.map{ ALPHABET.sample }.join
10.times.inject(''){|s| s << ALPHABET.sample }

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

# Here are more examples to help
# ex.1
rand(2**256).to_s(36)[0..7]
#Add ljust if you are really paranoid about the correct string length:
rand(2**256).to_s(36).ljust(8,'a')[0..7]
characters = ('a'..'z').to_a + ('A'..'Z').to_a
# Prior to 1.9, use .choice, not .sample
(0..8).map{characters.sample}.join
(0...8).collect { |n| value  << (65 + rand(25)).chr }.join()

# ex.2
def generate_random_string(length=6)
  string = ""
  chars = ("A".."Z").to_a
  length.times do
    string << chars[rand(chars.length-1)]
  end
  string
end

# ex.3
chars = [*('a'..'z'),*('0'..'9')].flatten
#Single expression, can be passed as an argument, allows duplicate characters:
Array.new(len) {|i| chars.sample}.join

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

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

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

# ex.7
(('a'..'z').to_a + ('A'..'Z').to_a + (0..9).to_a).sample(8).join
([(48..57),(65..90),(97..122)]).sample(8).collect{|x|x.chr}""

# ex.8
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

# ex.9
SecureRandom.base64(15).tr('+/=lIO0', 'pqrsxyz')
# ruby 1.8 and unix
random_string = `openssl rand -base64 24`