Introduction to Ruby Cheatsheet

Introduction to Ruby

Ruby is a high-level, interpreted language that focuses on simplicity and productivity. It provides an elegant and natural syntax that reads like plain English. Ruby is known for its object-oriented nature, meaning everything in Ruby is an object, including numbers, strings, and even classes. This object-oriented approach makes Ruby highly flexible and allows for clean and modular code.

One of Ruby's strengths is its extensive standard library, which provides a wide range of pre-built functionality that developers can leverage to speed up their development process. Additionally, Ruby has a vibrant community that actively contributes gems (libraries) to extend the language's capabilities.

Now that we have a brief understanding of Ruby let's start with this Ruby cheat sheet by Scaler Topics.

Ruby Cheatsheet

Variables

Variables in Ruby are used to store data that can be accessed and manipulated throughout the program. When creating a variable, you need to specify its name and assign a value to it. Ruby variables are dynamically typed, meaning that you don't have to explicitly declare their type.

The following is an example of variable declaration and assignment in Ruby:

Code:

Explanation:

In the above example, we declare three variables: name of type string, age of type number, and is_student of type boolean. These variables can now be used throughout the program to store and retrieve data.

Constants

Constants in Ruby are similar to variables, but their values cannot be changed once assigned. They are typically used to represent values that remain constant throughout the execution of a program, such as mathematical constants or configuration settings.

To define a constant in Ruby, you prefix the variable name with an uppercase letter or underscore. Conventionally, constants are written in uppercase to distinguish them from variables.

A Ruby definition of a constant would look something like this:

Code:

Explanation:

In the above example, we define two constants: PI representing the mathematical constant pi and MAX_VALUE representing the maximum allowed value. Once assigned, we cannot modify these constants.

Data Types

Ruby provides several built-in data types to work with different kinds of values. Let's look at a few of the most popular data types.

• Number:

  Numbers in Ruby can be either floating-point values or integers. Numbers can be subjected to arithmetic operations such as addition, subtraction, multiplication, and division. Ruby also provides convenient methods for working with numbers, such as calculating the square root or raising a number to a power.

  The following are a few examples of number operations in Ruby:

  Code:

  Output:

  Explanation:

  In the above example, we perform basic arithmetic operations on num1 and num2 variables and display the results using the puts method.

• String:

  Strings represent sequences of characters and are enclosed in either single or double quotation marks. Ruby provides various methods to manipulate and concatenate strings.

  The following is an example of string manipulation in Ruby:

  Code:

  Output:

  Explanation:

  In the above example, we create a string variable name and concatenate it with another string to form a greeting. We also use the length method to get the count of characters in the name string.

• Boolean:

  Boolean values in Ruby represent either true or false. They are often used in conditional statements and loops to control the program flow.

  The following is an example of using boolean values in Ruby:

  Code:

  Output:

  Explanation:

  In the above example, we define two boolean variables, is_ruby_awesome and is_ruby_tough, to indicate whether Ruby is awesome or tough. We then display the values of these variables using the puts method.

• Arrays:

  Arrays in Ruby are ordered collections of objects. They can store multiple values of different types and are indexed starting from 0. Ruby provides various methods to manipulate and access array elements.

  The following is an example of working with arrays in Ruby:

  Code:

  Output:

  Explanation:

  In the above example, we create an array of fruits containing three elements. We then add another element, grape, to the array using the push method. Finally, we access the second element of the array using indexing and display its value along with the length of the array.

• Hashes:

  Hashes, also known as dictionaries or associative arrays, are collections of key-value pairs. They allow you to store and retrieve values based on a unique key.

  The following is an example of using hashes in Ruby:

  Code:

  Output:

  Explanation:

  In the above example, we create a hash named person containing information about a person. The keys are strings, and the values can be of any type. We then access the value associated with the name key and display it, along with the length of the hash.

• Symbols:

  Symbols are immutable identifiers in Ruby. They are often used as keys in hashes or to represent method names. Symbols start with a colon and are unique within the Ruby runtime.

  The following is an example of using symbols in Ruby:

  Code:

  Output:

  Explanation:

  In the above example, we define two symbols, status and message, and display their values using the puts method.

Operators

Operators in Ruby allow you to perform various operations on data, such as arithmetic calculations, logical evaluations, and comparisons. Let's explore some of the commonly used operators in Ruby cheatsheets.

• Arithmetic Operators:

  Arithmetic operators in Ruby allow you to perform basic mathematical calculations. The most common arithmetic operators are:

  • + (addition)
  • - (subtraction)
  • * (multiplication)
  • / (division)
  • % (modulo, returns the remainder)
  • ** (exponentiation, raises a number to a power)

  The following is an example of using arithmetic operators in Ruby:

  Code:

  Output:

  Explanation:

  In the above example, we perform arithmetic operations using the variables num1 and num2 and display the results using the puts method.

• Logical Operators:

  Logical operators in Ruby allow you to perform logical evaluations and combine conditions. The three main logical operators are:

  • && (logical AND, it returns true if both conditions are true)
  • || (logical OR, it returns true if at least one condition is true)
  • ! (logical NOT, negates a condition)

  The following is an example of using logical operators in Ruby:

  Code:

  Output:

  Explanation:

  In the above example, we evaluate the values of is_sunny and is_warm using logical operators. Based on the conditions, we display different messages using conditional statements.

• Conditional Operators:

  Conditional operators in Ruby allow you to compare values and perform conditional evaluations. The common conditional operators are:

  • == (equality, returns true if the values are equal)
  • != (inequality, returns true if the values are not equal)
  • > (greater than)
  • < (less than)
  • >= (greater than or equal to)
  • <= (less than or equal to)

  The following is an example of using conditional operators in Ruby:

  Code:

  Output:

  Explanation:

  In the above example, we compare the values of num1 and num2 using conditional operators. Based on the comparison results, we display different messages using conditional statements.

Conditional Structures

Ruby's conditional structures let you modify how your program runs depending on certain conditions. They are crucial for making decisions and executing different code blocks based on the evaluation of conditions.

• Conditional statements:

  Ruby provides conditional statements such as if, elsif, and else to handle different conditions. These statements execute specific code blocks based on the evaluation of conditions.

  The following is an example of using conditional statements in Ruby:

  Code:

  Output:

  Explanation:

  In the above example, we evaluate the value of age and display different messages based on the condition using the if statement.

• Loops:

  Loops in Ruby allow you to repeat a code block multiple times until a certain condition is met. Ruby provides several loop constructs, including while, until, for, and each.

  The following is an example of using a while loop in Ruby:

  Code:

  Output:

  Explanation:

  In the above example, we use a while loop to repeat the code block as long as the condition counter <= 5 is true. We display the value of the counter variable and increment it in each iteration.

Methods

Methods in Ruby allow you to encapsulate reusable blocks of code that can be called and executed from different parts of your program. Methods enable code reusability, improve readability, and make your program more organized.

The following is an example of defining and using a method in Ruby:

Code:

Output:

Explanation:

In the above example, we define a method called greet that takes a parameter name. The method displays a greeting message using the value of the name parameter. We then call the method and pass different names to greet different people.

Classes and Objects

Ruby is an object-oriented programming language, which means that everything in Ruby is an object.

• Objects are instances of classes that define the structure and behavior for creating and interacting with specific objects.
• Classes serve as blueprints or templates that encapsulate the properties (attributes) and behaviors (methods) that objects of that class can possess.
• When you create an object from a class, you are essentially creating a unique instance of that class with its own set of attribute values and the ability to perform actions defined by the class's methods.

The following is an example of creating a class and object in Ruby:

Code:

Output:

Explanation:

In the above example, we define a class Person with an initialize method that takes a name parameter. The initialize method assigns the value of name to an instance variable @name. We also define a greet method that displays a greeting message using the value of @name. We then create an object of the Person class, passing the name Rahul to the constructor, and call the greet method on the object.

Modules

Modules in Ruby allow you to group related methods, constants, and classes. They serve as containers for organizing code and providing namespaces.

The following is an example of defining and using a module in Ruby:

Code:

Output:

Explanation:

In the above example, we define a module called MathUtils that contains constants and methods for mathematical operations. We access the module's constant PI and call its methods using the module's namespace.

Blocks

Blocks in Ruby are chunks of code that can be passed to methods as parameters. They allow you to define anonymous functions and execute them within a method.

Here's an example of using blocks in Ruby:

Code:

Output:

Explanation:

In the above example, we use the times method with a block to execute the code within the block five times. The num variable within the block represents the current iteration count.

Procs

Procs in Ruby are objects that encapsulate blocks of code and can be stored in variables or passed as parameters to methods. They provide a way to create reusable blocks of code.

The following is an example of using procs in Ruby:

Code:

Output:

Explanation:

In the above example, we create a proc called addition that takes two parameters and returns their sum. We then call the proc and pass arguments to perform the addition.

Lambdas

Lambdas in Ruby are similar to procs but with slight differences in behavior. They are anonymous functions that can be stored in variables or passed as parameters. Lambdas enforce strict argument count and return behavior.

The following is an example of using lambdas in Ruby:

Code:

Output:

Explanation:

In the above example, we create a lambda called addition that takes two parameters and returns their sum. We then call the lambda and pass arguments to perform the addition.

Calculation

Ruby provides several mathematical methods and functions for performing complex calculations. These methods and functions are part of the built-in Math module in Ruby.

The following is an example of performing calculations using the Math module in Ruby:

Code:

Output:

Explanation:

In the above example, we use the sqrt, log, and sin methods from the Math module to calculate the square root, natural logarithm, and sine of a value, respectively.

Complex

You can work with complex numbers in Ruby by using the Complex class. A real part and an imagined part make up complex numbers.

The following is an example of working with complex numbers in Ruby:

Code:

Output:

Explanation:

In the above example, we create two complex numbers, z1 and z2, using the Complex class constructor. We then perform addition and multiplication operations on the complex numbers and display the results.

File I/O

Ruby provides built-in methods for reading from and writing to files. These methods allow you to interact with files and perform reading, writing, and appending data operations.

The following is an example of reading from a file and writing to a file in Ruby:

Code:

Explanation:

In the above example, we first open a file called data.txt in read mode, read its content, and store it in the content variable. We then close the file and display the content. Next, we open another file called output.txt in write mode, write the text "Hello, world!" to the file, and close it.

Input and Output (I/O)

In Ruby, you can handle input and output operations to interact with the user and display information. Ruby provides several methods and techniques for accepting user input, reading data from files, and formatting output for display.

1. Accepting User Input

You can use the gets method to accept user input from the console. This method reads a line of text the user enters and returns it as a string. You can assign the user's input to a variable for further processing.

The following is an example of accepting user input in Ruby:

Code:

Explanation:

In the above example, the gets method is used to read a line of text from the user. The chomp method removes the trailing newline character from the input. The user's name is then interpolated into a string and displayed using the puts method.

2. Command-Line Arguments

Ruby allows you to accept command-line arguments when running a Ruby script. We can access these arguments through the ARGV constant, which is an array that stores the provided arguments.

The following is an example of accessing command-line arguments in Ruby:

Code:

If you run the script with command-line arguments, such as ruby my_script.rb arg1 arg2, the output will be:

Output:

The ARGV constant is used in the above example to access the command-line arguments passed to the script. The array of arguments is then displayed using the puts method.

3. Formatted Output

In Ruby, the puts and print methods are used to display output on the console. After displaying the output, the puts method adds a newline character, while the print method does not.

The following is an example of using puts and print in Ruby:

Code:

Output:

Explanation:

In the above example, we define variables for name and age. The puts method displays the values with appropriate labels. We also use the print method to display the values without adding a newline character.

Ruby Standard Library

Ruby's standard library is a collection of modules and classes that come bundled with the Ruby programming language. These modules and classes provide a wide range of functionality, extending the capabilities of Ruby beyond its core features. The following are a few important modules and classes from the Ruby standard library:

1. Date

The Date class in Ruby's standard library allows you to work with dates. It provides methods for creating, manipulating, and formatting dates. You can perform operations such as calculating the difference between dates, adding or subtracting days, formatting dates as strings, and more.

Use of the Date class may be seen in the example below:

Code:

Explanation:

In the above example, we require the date module from the standard library and use the Date.today method to get the current date. We then format the date using the strftime method. Additionally, we demonstrate how to perform date arithmetic by adding 7 days to the current date.

2. Time

The Time class in Ruby's standard library allows you to work with time values. It provides methods for creating, manipulating, and formatting time objects. You can perform operations such as retrieving the current time, adding or subtracting time intervals, formatting time as strings, and more.

The following is an example of using the Time class:

Code:

Explanation:

In the above example, we require the time module from the standard library and use the Time.now method to get the current time. We then format the time using the strftime method. Additionally, we demonstrate how to perform time arithmetic by adding 3600 seconds (1 hour) to the current time.

3. File

The File class in Ruby's standard library provides methods for interacting with files. It allows you to read from and write to files, manipulate file paths, check file existence, and perform various file operations.

The following is an example of using the File class:

Code:

Explanation: In the above example, we read the content of a file using the File.read method and store it in the content variable. We then display the content. Next, we write the text "Hello, world!" to a file using the File.write method.

These are just a few examples of the modules and classes available in Ruby's standard library. By exploring the standard library documentation, you can discover many more useful modules and classes for your Ruby projects.

Errors/Exceptions Handling

You can handle errors and exceptions in Ruby using the begin, rescue, and ensure keywords. These keywords allow you to catch and handle errors gracefully.

The following is an example of error handling in Ruby:

Code:

Output:

Explanation:

In the above example, we attempt to perform a division by zero, which raises a ZeroDivisionError. We use the rescue keyword to catch the specific error and display a custom error message. We also use the ensure keyword to specify code that will always execute, regardless of whether an error occurred or not.