1
2
3
4
5
6
7
8
9
10
# Simple print statement
puts "Hello, World!"

# Method definition
def greet(name)
  "Hello, #{name}!"
end

puts greet("Ruby Developer")

1
2
3
4
# Single-line comment

=begin
Multiline comment
Can span multiple lines
=end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# Integer (Fixnum/Bignum unified since 2.4)
age = 30
big_number = 1_000_000  # Underscores for readability

# Float
pi = 3.14159

# Rational and Complex literals
half = 1/2r          # (1/2)
imaginary = 2+3i     # (2+3i)

# String (frozen string literals recommended)
# frozen_string_literal: true
name = "Ruby"
interpolated = "Hello, #{name}!"

# Boolean
is_true = true
is_false = false

# Nil
nothing = nil

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# Array
fruits = ["apple", "banana", "cherry"]
mixed_array = [1, "two", :three]

# Hash (Dictionary) — preserves insertion order
person = {
  name: "Alice",
  age: 30,
  city: "New York"
}

# Hash shorthand (Ruby 3.1+): omit value when key matches local variable
name, age = "Alice", 30
person = { name:, age: }   # => { name: "Alice", age: 30 }

# Symbol
status = :active

# Data class (Ruby 3.2+) — immutable value objects
Point = Data.define(:x, :y)
origin = Point.new(x: 0, y: 0)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# Local variable
local_var = 42

# Instance variable
@instance_var = "I belong to an instance"

# Class variable (use sparingly; prefer class instance variables)
@@class_var = "Shared across all instances"

# Global variable (avoid when possible)
$global_var = "Accessible everywhere"

# Constant
DAYS_IN_WEEK = 7
PI = 3.14159

1
2
3
4
5
6
7
8
9
10
a = 10
b = 3

puts a + b   # Addition: 13
puts a - b   # Subtraction: 7
puts a * b   # Multiplication: 30
puts a / b   # Division: 3
puts a % b   # Modulo: 1
puts a ** 2  # Exponentiation: 100

1
2
3
4
5
6
7
8
9
10
11
a = 5
b = 10

puts a == b  # Equal to: false
puts a != b  # Not equal to: true
puts a < b   # Less than: true
puts a > b   # Greater than: false
puts a <= b  # Less than or equal to: true
puts a >= b  # Greater than or equal to: false
puts a <=> b # Spaceship: -1, 0, or 1

1
2
3
4
5
6
7
8
9
10
true_value = true
false_value = false

puts true_value && false_value  # Logical AND: false
puts true_value || false_value  # Logical OR: true
puts !true_value                # Logical NOT: false

# Safe navigation operator (avoid NoMethodError on nil)
user&.profile&.name

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
# If-else
x = 10
if x > 5
  puts "x is greater than 5"
elsif x == 5
  puts "x is equal to 5"
else
  puts "x is less than 5"
end

# Ternary operator
result = x > 5 ? "Greater" : "Less or Equal"

# Case statement
grade = 'B'
case grade
when 'A'
  puts "Excellent!"
when 'B'
  puts "Good job!"
when 'C'
  puts "Satisfactory"
else
  puts "Needs improvement"
end

# Pattern matching with case/in (stable since Ruby 3.0)
config = { host: "localhost", port: 5432 }
case config
in { host: String => host, port: Integer => port }
  puts "Connecting to #{host}:#{port}"
in { host: }
  puts "Host only: #{host}"
else
  puts "Unknown shape"
end

# One-line pattern matching with =>
{ name: "Alice", age: 30 } => { name:, age: }
puts name  # "Alice"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# While loop
count = 0
while count < 5
  puts count
  count += 1
end

# Range iteration (prefer over `for`)
(1..5).each do |num|
  puts num
end

# Times loop
5.times do |i|
  puts "Iteration #{i}"
end

# Loop control
10.times do |i|
  break if i > 5
  next if i.even?
  puts i
end

# Endless ranges and beginless ranges
(1..).take(5)     # [1, 2, 3, 4, 5]
arr = [1, 2, 3, 4, 5]
arr[..2]          # [1, 2, 3]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# Method definition
def greet(name = "World")
  "Hello, #{name}!"
end

puts greet         # "Hello, World!"
puts greet("Ruby") # "Hello, Ruby!"

# Endless method definition (Ruby 3.0+)
def square(x) = x * x

# Keyword arguments
def connect(host:, port: 5432)
  "#{host}:#{port}"
end
connect(host: "localhost")

# Multiple return values
def multiple_values
  [1, 2, 3]
end

a, b, c = multiple_values

1
2
3
4
5
6
7
8
9
10
# Lambda
multiply = ->(x, y) { x * y }
puts multiply.call(3, 4)  # 12
puts multiply.(3, 4)      # 12
puts multiply[3, 4]       # 12

# Proc
multiply_proc = Proc.new { |x, y| x * y }
puts multiply_proc.call(3, 4)  # 12

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Block with yield
def demonstrate_block
  puts "Before yield"
  yield if block_given?
  puts "After yield"
end

demonstrate_block { puts "Inside block" }

# Numbered block parameters (Ruby 2.7+)
[1, 2, 3].map { _1 * 2 }   # [2, 4, 6]

# `it` block parameter (Ruby 3.4+)
[1, 2, 3].map { it * 2 }   # [2, 4, 6]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Person
  # Accessor methods
  attr_accessor :name, :age

  # Constructor
  def initialize(name, age)
    @name = name
    @age = age
  end

  # Instance method
  def introduce
    "Hi, I'm #{@name}, #{@age} years old"
  end
end

person = Person.new("Alice", 30)
puts person.introduce

1
2
3
4
5
6
7
8
9
10
11
12
13
class Employee < Person
  attr_accessor :company

  def initialize(name, age, company)
    super(name, age)
    @company = company
  end

  def work_info
    "Works at #{@company}"
  end
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
module Swimmable
  def swim
    "I can swim!"
  end
end

class Fish
  include Swimmable
end

fish = Fish.new
puts fish.swim  # "I can swim!"

# Prepend inserts the module before the class in the ancestor chain
module Logged
  def call(*) = (puts "calling"; super)
end

class Service
  prepend Logged
  def call(*) = "done"
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
begin
  # Risky code
  result = 10 / 0
rescue ZeroDivisionError => e
  puts "Error: #{e.message}"
ensure
  puts "This always runs"
end

# Method-level rescue
def safe_divide(a, b)
  a / b
rescue ZeroDivisionError
  Float::INFINITY
end

# Custom exception
class CustomError < StandardError; end

def raise_custom_error
  raise CustomError, "Something went wrong"
end

# Exception#cause and #full_message for nested errors
begin
  begin
    raise "inner"
  rescue
    raise CustomError, "outer"
  end
rescue => e
  puts e.full_message
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# Writing to a file
File.open("example.txt", "w") do |file|
  file.puts "Hello, File!"
end

# Reading from a file
File.read("example.txt")

# Appending to a file
File.open("example.txt", "a") do |file|
  file.puts "Another line"
end

# Streaming line by line
File.foreach("example.txt") { |line| puts line }

1
2
3
4
5
6
7
8
9
10
11
# Threads (share memory, subject to the GVL for CRuby)
threads = 3.times.map { |i| Thread.new { puts "Thread #{i}" } }
threads.each(&:join)

# Fiber scheduler enables non-blocking I/O (Ruby 3.0+)
require "async"
Async do
  Async { sleep 1; puts "task 1" }
  Async { sleep 1; puts "task 2" }
end

1
2
3
4
5
# Ractors enable true parallelism by isolating state (Ruby 3.0+)
r = Ractor.new { Ractor.receive * 2 }
r.send(21)
puts r.take  # 42

1
2
3
4
5
6
7
8
# person.rbs
class Person
  attr_accessor name: String
  attr_accessor age: Integer
  def initialize: (String, Integer) -> void
  def introduce: () -> String
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# RSpec example
RSpec.describe Calculator do
  it "adds two numbers" do
    expect(Calculator.add(2, 3)).to eq(5)
  end
end

# Minitest example (ships with Ruby)
require "minitest/autorun"

class CalculatorTest < Minitest::Test
  def test_add
    assert_equal 5, Calculator.add(2, 3)
  end
end