Ruby Random Numbers: How to Generate Them With Examples

Random number generation is a fundamental concept in programming, and Ruby makes it both simple and powerful. From building games and simulations to generating test data, tokens, or randomized user experiences, random numbers play a crucial role in many Ruby and Ruby on Rails applications. Ruby provides built-in methods and classes that allow developers to generate random integers, floating-point numbers, reproducible sequences, and even cryptographically secure random values.

In this guide, you’ll learn how random numbers work in Ruby, explore different techniques to generate them, understand when to use each approach, and see practical examples you can apply in real-world projects.

Understanding Randomness in Ruby

At its core, Ruby uses pseudo-random number generation, meaning the numbers appear random but are generated using deterministic algorithms. These algorithms start from a value called a seed, and based on that seed, Ruby produces a predictable sequence of numbers.

This behavior is intentional and useful. It allows developers to:

• Reproduce results for testing
  
• Control randomness when needed
  
• Generate secure randomness when required
  

Ruby exposes this functionality mainly through:

• Le rand method
  
• Le Random classe
• Le SecureRandom module

En utilisant rand in Ruby

The simplest way to generate random numbers in Ruby is with the rand method.

Generating a Random Float

rand

This returns a floating-point number between 0.0</code > (inclusive) and 1.0 (exclusive):

0.734218973

This is useful for probability-based logic, simulations, or mathematical calculations.

Generating a Random Integer

To generate a random integer less than a given number:

rand(10)

Output will be an integer between 0 et 9.

Exemple:

7

Generating Random Numbers Within a Range

Ruby allows you to generate random numbers within a specific range using range syntax:

rand(1..10)

This returns an integer between 1 et 10.

For floating-point ranges:

rand(1.5..5.5)

This returns a float between 1.5 et 5.5.

Common Use Cases for rand

• Selecting a random item from a list
  
• Generating scores or points
  
• Creating simple game mechanics
  
• Simulating random events

Exemple:

colors = ["red", "blue", "green", "yellow"]
random_color = colors[rand(colors.length)]

L'utilisation de la Random Class

Le Random class provides more control over random number generation. Instead of relying on Ruby’s global random generator, you can create independent random number generators.

Creating a Random Object

random = Random.new
random.rand(1..100)

This is useful when:

• You want isolated randomness
  
• You are running simulations
  
• You want reproducible behavior across systems

Seeding Random Generators

A seed defines the starting point for random number generation.

random = Random.new(1234)
random.rand(10)

Every time you run this code with the same seed, you’ll get the same result.

This is especially helpful for:

• Essai
  
• Débogage
  
• Replaying simulations

En utilisant srand for Global Seeding

Ruby fournit également la fonction srand method to seed the global random generator:

srand(100)
rand(1..10)

Calling srand ensures consistent output across executions.

Example use case:

• Automated tests
  
• Deterministic application behavior

Secure Random Numbers in Ruby

For security-sensitive applications, rand is not sufficient. Ruby provides the SecureRandom module for cryptographically secure random values.

En utilisant SecureRandom

require 'securerandom'
SecureRandom.random_number(100)

This generates a secure random integer between 0 et 99.

Generating Secure Tokens

SecureRandom.hex(16)


Example output:

"a3f9c7d2e4b8f1c6a7b9d0e3f4c5a1b2"

Other formats:

SecureRandom.base64(16)
SecureRandom.uuid

When to Use SecureRandom

Utilisation SecureRandom for:

• Authentication tokens
  
• Password reset links
  
• API keys
  
• Session identifiers

Avoid using rand for any security-related logic.

Random Numbers in Ruby on Rails

Ruby on Rails applications frequently use random numbers in practical scenarios.

Generating Friendly URLs or Tokens

token = SecureRandom.urlsafe_base64(12)

Random Record Selection

User.order("RANDOM()").first

Note: This approach may not scale well for large datasets.

Alternative:

User.offset(rand(User.count)).first

A/B Testing and Feature Flags

Random numbers help distribute users across variants:

variant = rand < 0.5 ? "A" : "B"

Randomness for Testing in Ruby

Randomness can cause flaky tests if not handled carefully. Ruby developers often combine randomness with seeds to ensure reliability.

Example in RSpec

srand(123)
expect(rand(10)).to eq(6)

This ensures predictable test results.

RSpec itself allows random test order execution:

rspec --seed 12345

Shuffling Arrays Randomly

Ruby makes it easy to shuffle collections:

array.shuffle

To shuffle in place:

array.shuffle!

Exemple:

[1, 2, 3, 4, 5].shuffle

Sampling Random Elements

array.sample

To sample multiple items:

array.sample(3)

Exemple:

["apple", "banana", "cherry"].sample

Generating Random Booleans

rand < 0.5

Ou:

[true, false].sample

Useful for simulations, testing, and feature toggles.

Performance Considerations

• rand is fast and suitable for most applications
  
• Random is ideal for controlled randomness
• SecureRandom is slower but necessary for security

Choose the right tool based on the problem you’re solving.

Common Mistakes to Avoid

1. Using rand for security-sensitive logic

2. Forgetting to seed randomness in tests

3. Overusing database-level random queries

4. Assuming random results are truly unpredictable

Understanding these pitfalls helps you write more reliable Ruby code.

Best Practices for Random Number Generation in Ruby

• Utilisation rand for simple randomness
  
• Utilisation Random.new(seed) for reproducibility
  
• Utilisation SecureRandom for authentication and security
  
• Always document seeded randomness
  
• Test randomness-based features carefully

Conclusion

Random number generation is a powerful feature in Ruby that supports a wide range of use cases—from simple application logic and testing to security-critical functionality. Ruby’s built-in tools such as rand, Random, et SecureRandom provide developers with the flexibility, control, and reliability needed to implement randomness correctly. When used with best practices, these tools help ensure predictable testing, scalable performance, and secure application behavior.

À RailsCarma, our Ruby on Rails experts apply these principles to build robust, high-performance applications that are secure, scalable, and production-ready. Whether it’s implementing secure token generation, randomized user experiences, or test-safe logic, RailsCarma helps businesses leverage Ruby and Rails efficiently to accelerate development and deliver reliable digital solutions.