Home > Posts > Beginner's Guide to Ruby

Beginner's Guide to Ruby

  ·   13 min read

Getting Started with Ruby #

Installing Ruby #

Ruby’s installation process varies slightly depending on your operating system. Here’s a general guide, but you should always refer to the official Ruby website (https://www.ruby-lang.org/) for the most up-to-date and platform-specific instructions.

  • macOS: macOS often comes with an outdated version of Ruby pre-installed. It’s generally recommended to install Ruby using a package manager like rbenv or RVM. These tools allow you to manage multiple Ruby versions easily, which is crucial for working on different projects with different Ruby requirements. Instructions for installing and using these managers can be found on their respective websites.

  • Linux: Most Linux distributions offer Ruby packages through their package managers (apt, yum, dnf, etc.). Use your distribution’s package manager to search for and install the ruby package. For example, on Debian/Ubuntu systems, you might use sudo apt update && sudo apt install ruby. Again, consider using rbenv or RVM for better version management.

  • Windows: The easiest way to install Ruby on Windows is through the RubyInstaller. This installer provides a pre-built Ruby distribution with necessary components for Windows. Download the installer, run it, and follow the on-screen instructions.

After installation, verify your Ruby installation by opening your terminal or command prompt and typing ruby -v. This should print the version number of Ruby installed on your system.

Setting up your environment #

Once Ruby is installed, you’ll need a text editor or IDE to write your code. Popular choices include:

  • VS Code: A free and versatile code editor with excellent Ruby support through extensions.
  • Sublime Text: A powerful and customizable text editor.
  • Atom: Another popular and highly customizable editor.
  • RubyMine: A dedicated IDE for Ruby development (paid).

You can write your Ruby code in any plain text file (e.g., my_program.rb). The .rb extension indicates that the file contains Ruby code. It’s a good practice to create a dedicated directory for your Ruby projects.

Running your first Ruby program #

Create a new file named hello.rb and add the following line:

puts "Hello, world!"

This line uses the puts method (short for “put string”) to print the text “Hello, world!” to the console.

To run this program, open your terminal, navigate to the directory containing hello.rb, and type:

ruby hello.rb

You should see “Hello, world!” printed in your terminal.

Understanding the REPL (Interactive Ruby Shell) #

The REPL (Read-Eval-Print Loop) is an interactive environment where you can execute Ruby code line by line and see the immediate results. It’s a fantastic tool for learning and experimenting with Ruby.

To start the REPL, simply type irb in your terminal and press Enter. You’ll be presented with a prompt (usually >>). You can now type Ruby code directly, press Enter, and see the output immediately.

irb(main):001:0> puts "Hello from IRB!"
Hello from IRB!
=> nil
irb(main):002:0> 2 + 2
=> 4
irb(main):003:0> exit

The => nil indicates the return value of the puts method (it returns nil). The REPL is excellent for testing snippets of code, exploring Ruby’s methods, and quickly getting feedback. Use exit or Ctrl+D to exit the REPL.

Ruby Fundamentals #

Data Types (Integers, Floats, Strings, Booleans) #

Ruby is dynamically typed, meaning you don’t explicitly declare the data type of a variable. Ruby infers the type at runtime. Here are some fundamental data types:

  • Integers: Represent whole numbers (e.g., 10, -5, 0).

  • Floats: Represent numbers with decimal points (e.g., 3.14, -2.5, 0.0).

  • Strings: Represent sequences of characters (e.g., "Hello", 'Ruby', "123"). Strings can be enclosed in single or double quotes.

  • Booleans: Represent truth values (true or false).

integer_var = 10
float_var = 3.14
string_var = "Hello, Ruby!"
boolean_var = true

Variables and Constants #

Variables are used to store data that can change during the program’s execution. In Ruby, variable names start with a lowercase letter or underscore (_).

Constants are used to store data that should not change. Constant names start with an uppercase letter. While Ruby doesn’t strictly enforce immutability of constants, it will issue a warning if you try to reassign a constant.

my_variable = 5   # Variable
MY_CONSTANT = 10 # Constant

my_variable = 15 # Allowed
#MY_CONSTANT = 20 # Warning: already initialized constant MY_CONSTANT

Operators (Arithmetic, Comparison, Logical) #

Ruby supports a wide range of operators:

  • Arithmetic Operators: + (addition), - (subtraction), * (multiplication), / (division), % (modulo), ** (exponentiation).

  • Comparison Operators: == (equal to), != (not equal to), > (greater than), < (less than), >= (greater than or equal to), <= (less than or equal to). These operators return boolean values (true or false).

  • Logical Operators: && (and), || (or), ! (not). These operators work with boolean values.

result = 10 + 5      # Addition
result = 20 / 4      # Division
is_equal = (5 == 5)  # Comparison
is_true = (true && false) # Logical AND

Control Flow (if/else statements, loops) #

if/else statements: Used to execute different blocks of code based on conditions.

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

Loops: Used to repeat a block of code multiple times.

  • while loop: Repeats as long as a condition is true.
count = 0
while count < 5
  puts count
  count += 1
end
  • until loop: Repeats until a condition becomes true.
count = 0
until count == 5
  puts count
  count += 1
end
  • for loop: Iterates over a collection (like an array).
for i in 0..4  # .. creates an inclusive range, ... creates an exclusive range.
  puts i
end

# Using each method for iteration
(0..4).each do |i|
  puts i
end
  • times method: Repeats a block of code a specified number of times.
5.times do |i|
  puts "Iteration: #{i}"
end

Methods and Functions #

Methods are blocks of reusable code. In Ruby, methods are defined using the def keyword and ended with end.

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

greet("Alice")  # Calling the method

Methods can take arguments (parameters) and return values using the return keyword (although return is often implicit—the last evaluated expression is returned).

def add(a, b)
  return a + b # Explicit return
end

def subtract(a,b)
  a - b # Implicit return
end

sum = add(5, 3)
difference = subtract(10,4)
puts sum # Output: 8
puts difference # Output: 6

Methods enhance code organization and reusability, making programs more maintainable and readable.

Working with Data Structures #

Arrays #

Arrays are ordered collections of objects. They are defined using square brackets [].

my_array = [1, 2, 3, "apple", "banana"]

# Accessing elements:
puts my_array[0]  # Output: 1 (first element, index 0)
puts my_array[3]  # Output: apple

# Adding elements:
my_array << "orange" #Append to the end
my_array.push("grape") #Append to the end
my_array.unshift("kiwi") #Prepend to the beginning

# Removing elements:
my_array.pop #Removes the last element
my_array.shift #Removes the first element

# Array methods:
puts my_array.length  # Output: 7 (number of elements)
puts my_array.include?("banana") # Output: true (checks if element exists)

Arrays can contain elements of different data types. They are zero-indexed, meaning the first element has an index of 0. Many built-in methods simplify array manipulation.

Hashes #

Hashes (also known as dictionaries or associative arrays) are collections of key-value pairs. Keys are unique, and values can be any object. Hashes are defined using curly braces {}.

my_hash = { "name" => "Alice", "age" => 30, "city" => "New York" }

# Accessing values:
puts my_hash["name"]  # Output: Alice

# Adding key-value pairs:
my_hash["occupation"] = "Engineer"

# Modifying values:
my_hash["age"] = 31

# Hash methods:
puts my_hash.keys  # Output: ["name", "age", "city", "occupation"] (all keys)
puts my_hash.values # Output: ["Alice", 31, "New York", "Engineer"] (all values)
puts my_hash.length # Output: 4 (number of key-value pairs)
puts my_hash.has_key?("name") # Output: true (checks if key exists)


#Alternative syntax for creating hashes (Ruby 1.9+)
my_hash_alt = { name: "Bob", age: 25, city: "London" }
puts my_hash_alt[:name] # Accessing using symbols. Note the : before name.

Hashes are particularly useful for representing structured data. The key-value pair structure allows for efficient lookups based on the key. Using symbols (:name) as keys instead of strings (“name”) is generally preferred in Ruby due to performance benefits (symbols are unique objects).

Iterating through collections #

Both arrays and hashes provide various ways to iterate through their elements.

Arrays:

  • each method:
my_array = [1, 2, 3, 4, 5]
my_array.each do |element|
  puts element * 2
end
  • each_with_index method: Provides both the element and its index.
my_array.each_with_index do |element, index|
  puts "Element #{index}: #{element}"
end

Hashes:

  • each method: Iterates through key-value pairs.
my_hash = { "a" => 1, "b" => 2, "c" => 3 }
my_hash.each do |key, value|
  puts "#{key}: #{value}"
end
  • each_key and each_value methods: Iterate through keys or values only.

The each method (and its variations) is a fundamental tool for processing collections in Ruby. It’s concise and readable, making it a preferred approach for many iteration tasks. Other methods like map, select, reject, and reduce offer more advanced ways to transform and process collections, but each is a great starting point.

Object-Oriented Programming (OOP) in Ruby #

Classes and Objects #

Ruby is an object-oriented programming language. Everything in Ruby is an object, including numbers, strings, and arrays. A class is a blueprint for creating objects. Objects are instances of classes.

# Define a class
class Dog
  # This is a class definition. It doesn't create an object.
end

# Create objects (instances) of the Dog class
sparky = Dog.new  # creates a new Dog object
buddy = Dog.new   # creates another Dog object

This code defines a Dog class and creates two objects, sparky and buddy, which are both instances of the Dog class.

Methods and Attributes #

Classes define methods (functions that operate on objects) and attributes (data associated with objects).

class Dog
  attr_accessor :name, :breed #Creates getter and setter methods for name and breed

  def initialize(name, breed) # Constructor
    @name = name  # Instance variable, accessible via getter/setter methods
    @breed = breed # Instance variable
  end

  def bark
    puts "Woof!"
  end

  def description
    puts "My name is #{@name} and I'm a #{@breed}."
  end
end

my_dog = Dog.new("Fido", "Golden Retriever")
my_dog.bark       # Calls the bark method
my_dog.description # Calls the description method
puts my_dog.name   # Accesses the name attribute using getter method
my_dog.name = "Buddy" # Modifies the name attribute using setter method
puts my_dog.name   # Output: Buddy

@name and @breed are instance variables, specific to each instance of the Dog class. The initialize method is a special method called a constructor; it’s automatically called when you create a new Dog object using Dog.new. attr_accessor creates getter and setter methods for the specified instance variables.

Inheritance #

Inheritance allows you to create new classes (subclasses) based on existing classes (superclasses). Subclasses inherit the methods and attributes of their superclasses and can add their own.

class Animal
  def speak
    puts "Generic animal sound"
  end
end

class Dog < Animal # Dog inherits from Animal
  def speak
    puts "Woof!"  # Overrides the speak method from Animal
  end
end

class Cat < Animal
  def speak
    puts "Meow!"
  end
end

my_dog = Dog.new
my_dog.speak  # Output: Woof!
my_cat = Cat.new
my_cat.speak # Output: Meow!

Here, Dog and Cat inherit from Animal, but they also override the speak method to provide specific implementations.

Polymorphism #

Polymorphism means “many forms.” It allows objects of different classes to respond to the same method call in their own specific way. The speak method example above demonstrates polymorphism.

Encapsulation #

Encapsulation is the principle of bundling data (attributes) and methods that operate on that data within a class. It helps to protect data integrity and hide internal implementation details. In Ruby, instance variables (prefixed with @) are generally considered private and are usually accessed through getter and setter methods (or other public methods).

While Ruby doesn’t have strict access modifiers like public, private, and protected in languages like Java or C++, using getter and setter methods is the accepted way to achieve encapsulation and control access to internal attributes. This promotes better code organization and maintainability.

Advanced Concepts (Optional) #

Modules and Mixins #

Modules are collections of methods and constants that can be included in other classes. They provide a way to organize and reuse code. Mixins are a way to add functionality to classes without using inheritance.

module Swimmable
  def swim
    puts "I'm swimming!"
  end
end

class Dog
  include Swimmable # Including the module
end

class Duck
  include Swimmable
end

my_dog = Dog.new
my_dog.swim  # Output: I'm swimming!

my_duck = Duck.new
my_duck.swim # Output: I'm swimming!

Here, the Swimmable module is included in both the Dog and Duck classes, allowing both to use the swim method. This is a mixin—it adds functionality without creating an inheritance relationship.

Blocks and Iterators #

Blocks are anonymous functions that can be passed to methods. They are often used with iterators (methods that iterate over collections).

numbers = [1, 2, 3, 4, 5]

numbers.each do |number|  # Block starts here
  puts number * 2
end  # Block ends here

# Using a block with map to create a new array
squared_numbers = numbers.map { |number| number * number }
puts squared_numbers # Output: [1, 4, 9, 16, 25]

# More concise syntax using do...end for multiline blocks
sum = numbers.inject(0) do |sum, number|
    sum + number
end
puts sum # Output: 15

# Using curly braces {} for single-line blocks
sum2 = numbers.inject(0){|sum, number| sum + number}
puts sum2 # Output: 15

The each, map, and inject methods are examples of iterators. Blocks provide a concise way to specify the operation performed on each element during iteration.

Exception Handling #

Exception handling allows you to gracefully handle errors that might occur during program execution. The begin, rescue, ensure, and else keywords are used for this purpose.

begin
  # Code that might raise an exception
  result = 10 / 0
rescue ZeroDivisionError => e
  puts "Error: #{e.message}" # Handle the specific exception
rescue StandardError => e # Handle other errors. StandardError is a parent class for many errors.
    puts "An error occured: #{e.message}"
ensure
  puts "This always executes" # Code that always runs, regardless of exception
else
  puts "No errors occurred" # Executes if no exceptions were raised
end

This code attempts to divide by zero. The rescue block catches the ZeroDivisionError and prints an error message. The ensure block always executes, and the else block executes only if no exception occurs.

Working with Files and I/O #

Ruby provides ways to read from and write to files.

# Writing to a file
File.open("my_file.txt", "w") do |file|
  file.puts "Hello, file!"
end

# Reading from a file
File.open("my_file.txt", "r") do |file|
  file.each_line do |line|
    puts line.chomp # chomp removes trailing newline
  end
end

This code creates a file named my_file.txt, writes a line to it, and then reads and prints the content of the file. Error handling (e.g., checking if the file exists) is crucial when working with files.

Gems and Bundler #

Gems are reusable Ruby packages. Bundler is a tool for managing gem dependencies. A Gemfile specifies the gems a project requires. Bundler installs and manages those gems.

To use Bundler:

  1. Create a Gemfile in your project’s root directory:

    source 'https://rubygems.org'
gem 'sinatra'  # Example gem

  2. Run bundle install to install the gems.

  3. Use the gems in your code by requiring them (e.g., require 'sinatra').

Bundler simplifies dependency management and ensures that your project uses consistent versions of gems.

←
Beginner's Guide to R
Beginner's Guide to Kotlin
→
back to top