fullstack

Ruby

The Ruby cheat sheet is a one-page reference sheet for the Ruby programming language.

#Getting Started

#Install

# Debian, Ubuntu
$ sudo apt-get install ruby-full
# Windows
$ winget install RubyInstallerTeam.Ruby
$ brew install ruby # macOS
$ docker run -it --rm ruby:latest # Docker

#What is Gemfile and Gemfile.lock

  • Gemfile Is the Bundler (also gem) configuration file that contains the project's gem list (dependencies)
# Specify gem in the Gemfile in the project root directory
ruby '3.1.2'

source 'https://rubygems.org'
gem 'nokogiri'
gem 'rack', '~>3.0.10'
gem 'rspec', :require => 'spec'

Install all gems in Gemfile

$ bundle install

Solve the problem of Gemfile.lock inconsistency between mac for development and linux for production

bundle lock --add-platform x86_64-linux

#Install a specific version of a specific ruby gem

$ gem install bundler -v 2.4.20
$ gem install minitest -v 5.22.3

#Update gems using Bundler

# Updating a single gem using Bundler
$ bundle update nokogiri
# Use Bundler to update each gem in the Gemfile
$ bundle update

#Comment

# This is a single line comments.
=begin
Multi-line
Comment
=end
puts "Hello world!"  # Inline comments for code

#reserved words

Reserved words Description
__ENCODING__ The script encoding of the current file
__LINE__ The line number of this keyword in the current file
__FILE__ The path of the current file
BEGIN Code enclosed in { } is run before the program is run
END Code enclosed in { } is run at the end of the program
alias Create an alias for an existing method, operator, or global variable
and Logical AND operator
begin Begin a block of code
break Terminate a loop
case Compare an expression with matching when clauses, terminated with
end
class Define a class
def define a function/method
defined? Check if a variable or function exist
do Start a block of code, terminated with the
end keyword
else Execute the following code if previous conditions are not met
elsif Alternative condition for if expressions
end End blocks of code starting with keywords like begin, class,def,do,if, etc.
ensure Always execute at the end of a block
false Logical boolean value false
for Start a for loop
if Execute the code block if the condition is true
in Used with for loop
module Define a module
next jump to the point before the evaluation of the loop condition
nil Stand for null, invalid, or always false
not Logical NOT operator
or Logical OR operator
redo Jump back to the loop condition evaluation
rescue Evaluate expressions after an exception is raised
retry Repeat method calls when called outside rescue, jump to the top of the block when called inside rescue
return Return a value from a method or block
self Refer to the current object
super Call the same-named method in the superclass
then Used as a separator withif,unless,when,case,rescue
true Logical boolean value true
undef Undefine methods/functions within the current class
until Execute the code block until the condition is false
when Begin a clause under a case statement
while Execute the code block while the condition is true
yield Execute the code block passed to a method

#Operator

#Logical Operators

  • and
  • or
  • not
  • &&
  • ||
  • !

#Bit operators

  • &
  • |
  • ^
  • ~
  • <<
  • >>

#Arithmetic operators

  • +
  • -
  • *
  • /
  • %
  • **

#Comparison operator

  • ==
  • !=
  • >
  • <
  • >=
  • <=
  • <=>
  • ===
  • eql?
  • equal?

#Operator examples

# Addition
1 + 1   #=> 2
# Subtraction
2 - 1   #=> 1
# Multiplication
2 * 2   #=> 4
# Division
10 / 5  #=> 2
17 / 5    #=> 3, not 3.4
17 / 5.0  #=> 3.4
# Exponentiation
2 ** 2  #=> 4
3 ** 4  #=> 81
# Modulus (remainder of division)
8 % 2   #=> 0  (8 / 2 = 4; no remainder)
10 % 4  #=> 2  (10 / 4 = 2 remainder 2)
a = 10
b = 20
a == b #=> false
a != b #=> true
a > b #=> false
a < b #=> true
a >= b #=> false
a <= b #=> true

# Comparison operators
a <=> b #=> -1
c = 20
c <=> b #=> 0
c <=> a  #=> 1
# Equality used in when clauses for case statements
(1...10) === 5 #=> true
# True if the receiver and the argument have the same type and equal values
1.eql?(1.0) #=> false
c = a + b  #=> 30
c += a #=> 40
c -= a #=> 30
c *= a #=> 300
c /= a #=> 30
c %= a #=> 3
c **= a #=> 59049

# Ruby parallel assignment
a = 10
b = 20
c = 30
a, b, c = 10, 20, 30
# Ruby bitwise operators
a = 60
b = 13
# & Binary AND operator copies a bit to the result if it exists in both operands.
a & b #=> 12
# | Binary OR operator copies a bit if it exists in either operand.
a | b #=> 61
# ^ Binary XOR operator copies a bit if it is set in one operand but not both.
a ^ b #=> 49
# ~ Binary Ones Complement is unary and has the effect of 'flipping' bits.
~a
# << Binary Left Shift Operator. The left operand's value is moved
# left by the number of bits specified by the right operand.
a << 2
# >> Binary Right Shift Operator. The left operand's value is moved
# right by the number of bits specified by the right operand.
a >> 2

# Ruby logical operators
a and b #=> true.
a or b #=> true.
a && b #=> true.
(a || b) #=> true.
!(a && b) #=> false.
not(a && b) #=> false.
# Ruby ternary operator
# ? :
# If condition is true ? Then value X : Otherwise value Y
a == 10 ? puts 'Right' : puts 'Wrong'
# Ruby range operators
# .. Creates a range from the start point to the end point (inclusive)
1..10 #=> Creates a range from 1 to 10 (inclusive of 1 and 10)
# ... Creates an exclusive range from the start point to the end point
1...10 #=> Creates an exclusive range from 1 to 10

#Operator precedence table

From highest to lowest, this is the precedence table for ruby. High precedence operations happen before low precedence operations.

  • !, ~, unary +
  • **
  • unary -
  • *, /, %
  • +, -
  • <<, >>
  • &
  • |, ^
  • , >=, <, <=

  • <=>, ==, ===, !=, =~, !~
  • &&
  • ||
  • .., ...
  • ?, :
  • modifier-rescue
  • =, +=, -=, etc.
  • defined?
  • not
  • or, and
  • modifier-if, modifier-unless, modifier-while, modifier-until
  • { } blocks

#Variables and scope

- - - -
Name Scope Example Explanation
[a-z] or _ Local count = 10 or _count = 10 Local variables must be initialized
@ Instance variable @id = [] Instance variables have a "nil" value before initialization
@@ Class variable @@name = [] Class variables must be initialized
$ Global variable $version = "0.8.9" Global variables have a "nil" value before initialization
[A-Z] Constant PI = 3.14 Constant variables must be initialized, you can change constants, but you will receive a warning

There are five different types of variables. The first character determines the range To read in deap about variables check User Guide cap 19,20,21,22,23 Pre-Defined Variables and Constants

#Check the scope of a variable

defined? count
"local-variable"
defined? @id
"instance-variable"
defined? @@name
"class variable"
defined? $version
"global-variable"
defined? PI
"constant"

#Data Types

- - - -
Type Example Class Documentation
Integer a = 17 a.class > Integer
a.class.superclass > Numeric
#
Float a = 87.23 a.class > Float
a.class.superclass > Numeric
#
String a = "Hello universe" a.class > String #
Array a = [12, 34] a.class > Array #
Hash a = a.class > Hash #
Boolean a = false
a = true
a.class > FalseClass
a.class > TrueClass
TrueClass FalseClass
Symbol a = :status a.class > Symbol #
Range a = 1..3 a.class > Range #
Nil a = nil a.class > NilClass #

further reading

#Check data type

# Both are synonyms
a = 37
a.kind_of? Integer
# true
a.is_a? Integer
# true

#Symbol

week_days = {sunday: 11, monday: 222}

#Integer useful methods

2.even?
# true
3.even?
# false

#Range

.. Used to create inclusive ranges

range = 1..10
range.to_a
# output => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

... Used to create exclusive ranges

range = 1...10
range.to_a
# output => [1, 2, 3, 4, 5, 6, 7, 8, 9]

some useful methods

Method name Output
cover? (1..5).cover?(5) => true
end ('a'..'z').end => "z"
first (1..5).first => 1
first(3) ('A'..'Z').first(2) => ["A", "B"]
eql? ((0..2).eql?(0..5) => false

#Using step in Range

(1..20).step(2) { |number| puts "#{number}"}
# output
# 1
# 3
# 5
# 7
# 9
# 11
# 13
# 15
# 17
# 19

#Ruby Flow control

#if

num = 2
puts 'two' if num == 2

If the condition is true, execute the code

#if elsif else

temp = 19
if temp >= 25
  puts "hot"
elsif temp < 25 && temp >= 18
  puts "normal"
else
  puts "cold"
end
# output => normal

#unless

# Unless contrary to if , evaluates when the statement is false
name = "rob"
# if name != "bob"
unless name == "bob"
  puts "hello stranger"
else
  puts "hello bob"
end
# output => hello stranger
num = 6
puts 'not two' unless num == 2
# output => not two

#case

# case returns the value of the last expression executed
case input
# Check for an integer, 19
when 19
  puts "It's 19"
  # 检查一个确切的字符串,“Zaman”
when "Zaman"
  puts "Hi Zaman"
when 7..11
  puts "It's between 7 and 11"
  # Check multiple values, "coffee"
when "tea", "coffee"
  puts "Happy days"
end

#case( short syntax )

case input
  when 19 then puts "It's 19"
end

#case( Optional failure )

case input
  when 19 then puts "It's 19"
else
  puts "It's not 19"
end

#case( Get return value )

marks = 86
result = case marks
        when 0..49 then "Fail"
        when 50..64 then "Pass"
        when 65..74 then "Credit"
        when 75..84 then "Distinction"
        when 85..100 then "High Distinction"
        else "Invalid marks"
        end

puts result
# High Distinction

#String

#String interpolation

name = "World"
puts "Hello #{name}"
puts "The total is #{1+1}"
# "the total is 2"

String interpolation allows you to combine strings together

#Extract substring

string = "abc123"
string[0,3]
# "abc"
string[3,3]
# "123"
string[0..-2]
# "abc12"
#remove or replace the substring
string[0..2] = ""
puts string
# "123"

A substring is a small part of a string, which is useful if you only want that specific part, like the beginning, middle, or end

#Convert a string to lowercase or uppercase

"HELLO World".downcase  # "hello world"
"hello worlD".upcase    # "HELLO WORLD"
"hEllo wOrlD".capitalize # "Hello world"
"hEllo WOrlD".swapcase  # "HeLLO woRLd"

#useful methods

Function Name Output Note
length or size "HELLO World".length => 11
"HELLO World".size => 11
Returns the length of the string
reverse "hello worlD".reverse => "Dlrow olleh" Returns the reversed string
include? other_str "hEllo wOrlD".include? "w" => true Returns true if the string or character exists, otherwise returns false
gsub(pattern, replacement) "hEllo wOrlD".gsub(" ", "_") => "hEllo_wOrlD" gsub or global substitute replaces one or more strings with the provided string
gsub(pattern, hash) "organization".gsub("z", 'z' => 's') => "organisation" gsub or global substitute replaces one or more strings with the provided hash
gsub(pattern) "Price of the phone is 1000 AUD".gsub(/\d+/) {\| s\| '$'+s }
"Price of the phone is $1000 AUD"
gsub or global substitute replaces one or more strings with the provided block
strip " hEllo WOrlD ".strip
"hEllo WOrlD"
It will remove (trim) any leading and trailing characters: null (“\x00”), horizontal tab (“\t”), newline (\n), vertical tab (“\v”), form feed (f), carriage return(\r), space (" ")
prepend a = "world" <br> a.prepend("hello ")
"hello world"
Adds the string before another string
insert a = "hello" <br> a.insert(a.length, " world")
"hello world"
Inserts the string at a specific position
start_with? string = "ruby programming"
string.start_with? "ruby"
true
Checks if the string starts with a specific prefix
end_with? string = "ruby programming"
string.end_with? "ruby"
false
Checks if the string ends with a specific prefix
delete_suffix string = "sausage is expensive"
string.delete_suffix(" is expensive")
"sausage"
Deletes the suffix from the string
delete_prefix string = "sausage is expensive"
string.delete_prefix("sausage")
" is expensive"
Deletes the prefix from the string
split string = "a b c d" <br> string.split
["a", "b", "c", "d"]
Converts the string into an array of characters
join arr = ['a', 'b', 'c'] <br> arr.join => "abc" Converts an array into a string
to_i a = "49" <br> a.to_i => 49 Converts the string into an integer
chop "abcd?".chop("?") => "abcd" Deletes the last character from the string
count str = "aaab" <br> str.count("a")
3
Counts the characters in the string
to_f a = "49"
a.to_f
49.0
Converts the string into a floating point number
to_sym a = "key"
a.to_sym
:key
Converts the string into a symbol
match "abcd?".match(/ab/) => #<MatchData "ab"> Converts the pattern into a regular expression and calls its match method on the string
empty? "hello".empty? => false Returns true if the length of the string is zero
squeeze "Booook".squeeze => "Bok" Returns a copy of the string where runs of the same character are replaced by a single character
* puts "Ruby " * 4 => Ruby Ruby Ruby Ruby Returns the concatenation of multiple copies of self
+ "sammy " + "shark" => "sammyshark" Returns the concatenation of self and the given other string
eql? s = 'foo' => true
s.eql?('foo') => true
Returns true if the objects have the same length and content; false otherwise

#Methods

#Declare a method

def method_name(parameter1, parameter2)
    puts "#{parameter1} #{parameter2}"
    parameter1 + parameter2
end

res = method_name(20, 10)
# output => 30
def method_name(parameter1, parameter2)
    puts "#{parameter1} #{parameter2}"
    return parameter1 + parameter2
end
# output => 30

#Call method

res = method_name(parameter1, parameter2)
# Methods can be called without parentheses
res = method_name parameter1, parameter2

#Class method

Class methods are class-level methods. There are multiple ways to define class methods

class Mobile
    def self.ring
        "ring ring ring..."
    end
end

Mobile.ring

class Mobile
    def Mobile.ring
        "ring ring ring..."
    end
end
Mobile.ring

class Mobile
    class << self
    def ring
        "ring ring ring..."
       end
    end
end
Mobile.ring

Class methods are instance methods of class objects. When a new class is created, an object of type "Class" is initialized and assigned to a global constant (in this case Mobile)

Mobile = Class.new do
    def self.ring
        "ring ring ring..."
    end
end
Mobile.ring
Mobile = Class.new
class << Mobile
    def ring
        "ring ring ring..."
    end
end
Mobile.ring

#Use another parameter as default value

def method_name(num1, num2 = num1)
    return num1 + num2
end
res = method_name(10)
# output => 20

#Define default values for method parameters

def method_name(parameter1, parameter2, type = "ADD")
    puts "#{parameter1} #{parameter2}"
    return parameter1 + parameter2 if type == "ADD"
    return parameter1 - parameter2 if type == "SUB"
end
res = method_name(20, 10)
# output => 30

#Pass variable length arguments to method parameters

def method_name(type, *values)
    return values.reduce(:+) if type == "ADD"
    return values.reduce(:-) if type == "SUB"
end
numbers = [2, 2, 2, 3, 3, 3]
res = method_name("ADD", *numbers)
# output => 15
res = method_name("SUB", *numbers)
# output => -11
# Or you can provide a value like this
res = method_name("ADD", 2, 2, 2, 3, 3, 3)
# output => 15

#Modify object

a = ["Drama", "Mystery", "Crime",
"Sci-fi", "Disaster", "Thriller"]
a.sort
puts a
# We did not modify the object
# Drama
# Mystery
# Crime
# Sci-fi
# Disaster
# Thriller
a.sort!
puts a
# Modify object
# Crime
# Disaster
# Drama
# Mystery
# Sci-fi
# Thriller

When you want to modify the object, use ! after the method

#Boolean method

In ruby, methods ending with a question mark (?) are called boolean methods, which return true or false

"some text".nil?
# false
nil.nil?
# true

You can have your own boolean method

def is_vowel?(char)
    ['a','e','i','o','u'].include? char
end
is_vowel? 'a'
# true
is_vowel? 'b'
# false

#Blocks

#Block example

# return value
def give_me_data
    data = yield
    puts "data = #{data}"
end
give_me_data { "Big data" }
# output => data = Big data

The code between do and end (for multiple lines) or curly braces { and } (for a single line) is called a block, and they can define multiple parameters between two pipes ( |arg1, arg2|)

#Single line block

salary = [399, 234, 566, 533, 233]
salary.each { |s| puts s }
# puts s = block body
# |s| = block arguments

#Multi-line block

salary.each do |s|
    a = 10
    res = a * s
    puts res
end
# Block
# a = 10
# res = a * s
# puts res
# block parameters
# |s|

Blocks can be passed as method parameters or associated with method calls. block returns the last evaluated statement

#Implicitly passing a block

def give_me_data
    puts "I am inside give_me_data method"
    yield
    puts "I am back in give_me_data method"
end

give_me_data { puts "Big data" }

# output
# I am inside give_me_data method
# Big data
# I am back in give_me_data method

#Called multiple times

def give_me_data
    yield
    yield
    yield
end

give_me_data { puts "Big data" }

# output
# Big data
# Big data
# Big data

#Called with block parameters

def give_me_data
    yield 10
    yield 100
    yield 30
end

give_me_data { |data| puts "Big data #{data} TB" }

# output
# Big data 10 TB
# Big data 100 TB
# Big data 30 TB

#Called with multiple block parameters

def give_me_data
    yield "Big data", 10, "TB"
    yield "Big data", 100, "GB"
    yield "Big data", 30, "MB"
end

give_me_data { |text, data, unit| puts "#{text} #{data} #{unit}" }

# output
# Big data 10 TB
# Big data 100 GB
# Big data 30 MB

#Block will attempt to return from the current context

give_me_data
    puts "I'm inside the give_me_data method"
end

def test
  puts "I'm inside the test method"
  give_me_data { return 10 } # Code returns from here
  puts "I am back in test method"
end

return_value = test

# output
# I'm inside the test method
# I'm inside the give_me_data method
# 10

#Pass the block explicitly by using the & parameter

def give_me_data(&block)
    block.call
    block.call
end

give_me_data { puts "Big data" }

# output
# Big data
# Big data

#Check if block is given

def give_me_data
    yield
end

give_me_data

# output
# LocalJumpError: no block given (yield)

#Ways to handle exceptions and make blocks optional

def give_me_data
    return "no block" unless block_given?
    yield
end

give_me_data { puts "Big data" }
give_me_data

# output
# Big data

#Procs

#Procs

p = Proc.new { puts "Hello World" }

def give_me_data(proc)
    proc.call
end

give_me_data p

# output
# Hello World

proc is like a block that can be stored in a variable

#any parameter

p = Proc.new { |count| "Hello World " * count }

def give_me_data(proc)
    proc.call 5, 2
end

give_me_data p

# output
# "Hello World Hello World Hello World Hello World Hello World "

#proc will attempt to return from the current context

p = Proc.new { return 10 }
p.call
# output
LocalJumpError: unexpected return

#Cannot return from top-level context

def give_me_data
    puts "I'm inside the give_me_data method"
    p = Proc.new { return 10 }
    p.call # Code returns from here
    puts "I am back in give_me_data method"
end

return_value = give_me_data
puts return_value

# output
# I'm inside the give_me_data method
# 10

#Lambdas

#Declare a lambda

l = lambda { puts "Hello World" }
# shorthand
l = -> { puts "Hello World" }
# transfer lambda
l.call
# output => Hello World

There are multiple ways to call a lambda

l.()
l[]

#strict arguments

l = -> (count) { "Hello World " * count }
l.call 5
# output
# "Hello World Hello World Hello World Hello World Hello World "
l.call 5, 2
# output
wrong number of arguments (given 2, expected 1)

#declare a lambda in block

def give_me_data
    puts "I am inside give_me_data method"
    l = -> { return 10 }
    l.call
    puts "I am back in give_me_data method"
end

return_value = give_me_data
puts return_value

# output
# I am inside give_me_data method
# I am back in give_me_data method
# nil # because puts return nil

#lambdas are returned from the lambda itself, just like regular methods

l = -> { return 10 }
l.call

# output => 10

#Array

#Initialize an empty array

array = Array.new   #=> []
# or
array = []

#Array containing objects of different types

array = [1, "two", 3.0]
#=> [1, "two", 3.0]

#Fill array with initial size and default objects

numbers = Array.new(3)
#=> [nil, nil, nil]
numbers = Array.new(3, 7)
#=> [7, 7, 7]
numbers = Array.new(3, true)
#=> [true, true, true]
numbers = []
numbers.fill(7, 0..2)   #=> [7, 7, 7]

#array of different hashes

array_with_hashes = Array.new(2) { {} } #=> [{}, {}]
array_with_hashes[0][:name] = "Bob"
array_with_hashes[0][:id] = 10          #=> [{:name=>"Bob", :id=>10}, {}]

#Two-dimensional array

temperature_data = [
              ["A908", 38],
              ["A909", 37],
              ["A910", 38],
          ]
temperature_data[0]    #=> ["A908", 38]
temperature_data[0][0] #=> "A908"
temperature_data[0][1] #=> 38

#array index

str_array = [
  "This", "is", "a", "small", "array"
]
str_array[0]            #=> "This"
str_array[1]            #=> "is"
str_array[4]            #=> "array"

#negative index

str_array = [
  "This", "is", "a", "small", "array"
]
# Index -1 represents the last element
str_array[-1]        #=> "array"
# Index -2 represents the second to last element
str_array[-2]        #=> "small"
str_array[-6]        #=> nil

#array method at

str_array = [
  "This", "is", "a", "small", "array"
]

puts str_array.at(0)      #=> "This"

#Range acquisition

arr = [1, 2, 3, 4, 5, 6]
arr[100]                  #=> nil
arr[-3]                   #=> 4
arr[2, 3]                 #=> [3, 4, 5]
arr[1..4]                 #=> [2, 3, 4, 5]
arr[1..-3]                #=> [2, 3, 4]

#Array method fetch

arr = ['a', 'b', 'c', 'd', 'e', 'f']
arr.fetch(100)
#=> IndexError: Index outside array bounds 100:-6...6
arr.fetch(100, "oops")    #=> "oops"

Out of bounds, give default value

#Get array elements

arr = [1, 2, 3, 4, 5, 6]

arr.first     # first value => 1
arr.last      # last value => 6
# take Returns the first n elements
arr.take(3)   #=> [1, 2, 3]
# drop after n elements have been deleted
arr.drop(3)   #=> [4, 5, 6]

#Add value to end of array push

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers.push(11)
#=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
numbers.push(12, 13, 14)
#=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

#Delete the value at the end of the array pop

num_array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
num_array.pop             #=> 10
num_array
#=> [1, 2, 3, 4, 5, 6, 7, 8, 9]

#Add value to beginning of array unshift

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers.unshift(0)
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers.unshift(-3, -2, -1)
#=> [-3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

#Retrieve and simultaneously delete the first element shift

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers.shift #=> 1
numbers
#=> [2, 3, 4, 5, 6, 7, 8, 9, 10]

#Remove element at specific index delete_at

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers.delete_at(2) #=> 4
numbers
#=> [2, 3, 5, 6, 7, 8, 9, 10]

#Remove a specific element anywhere in an array

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers.delete(2) #=> 2
numbers           #=> [3, 5, 6, 7, 8, 9, 10]

#Insert value at given index insert

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers.insert(0, 0)
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers.insert(0, -3, -2, -1)
#=> [-3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

numbers.insert(-1, 12, 13, 14)
#=> [-3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14]
numbers.insert(-4, 11)
#=> [-3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

#A block to fill the array with values

numbers = Array.new(10) { |n| n = n * 2 }
#=> [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

#Filling arrays becomes easier

numbers = Array(100..110)
#=> [100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110]

# Or we can convert the range to an array
(100..110).to_a
#=> [100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110]

#Remove nil value from array

arr = ['foo', 0, nil, 'bar', 7, nil]
arr.compact  #=> ['foo', 0, 'bar', 7]
arr      #=> ['foo', 0, nil, 'bar', 7, nil]
arr.compact! #=> ['foo', 0, 'bar', 7]
arr      #=> ['foo', 0, 'bar', 7]

#Remove duplicates uniq

arr = [2, 5, 6, 556, 6, 6, 8, 9, 0, 123, 556]
arr.uniq #=> [2, 5, 6, 556, 8, 9, 0, 123]
arr # => [2, 5, 6, 556, 6, 6, 8, 9, 0, 123, 556]
arr.uniq! #=> [2, 5, 6, 556, 8, 9, 0, 123]
arr #=> [2, 5, 6, 556, 8, 9, 0, 123]

#Check if a value exists in an array(include?

planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
planets.include? "Mars"
# output => true
planets.include? "Pluto"
# output => false

#Get array size

planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
planets.size
# output => 8
planets.length
# output => 8

You can use size or length, both are synonyms

#clear array

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers.clear
# output => []

#Get the first element of the array

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers[0]
# or
numbers.first
# output => 1

#Get the last element of the array

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers[-1]
# or
numbers.last
# output => 10

#Merge two arrays

a = ["tom", "mot", "otm"]
b = [2, 3, 5]
a.zip(b)
# output
# [["tom", 2], ["mot", 3], ["otm", 5]]

#Sort array

primes = [7, 2, 3, 5]
sorted_primes = primes.sort
puts "#{sorted_primes}"
# output => [2, 3, 5, 7]

or in-place sort

primes = [7, 2, 3, 5]
primes.sort!
puts "#{primes}"
# output => [2, 3, 5, 7]
planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
planets.sort
# output
# ["Earth", "Jupiter", "Mars", "Mercury", "Neptune", "Saturn", "Uranus", "Venus"]
planets.sort_by { |p| p }
# output
# ["Earth", "Jupiter", "Mars", "Mercury", "Neptune", "Saturn", "Uranus", "Venus"]
planets.sort_by { |p| p.length }
# output
# ["Mars", "Earth", "Venus", "Saturn", "Uranus", "Neptune", "Jupiter", "Mercury"]

#Get maximum value from array

primes = [7, 2, 3, 5]
primes.max_by { |p| p }
# output => 7

#Get array elements using range

# numbers[start..end], both index are inclusive
puts numbers[0..3]
# 1
# 2
# 3
# 4
# numbers[start..end], end index is exclusive
puts numbers[0...3]
# 1
# 2
# 3
# or numbers[start..length]
puts numbers[0, 1]
# 1

#Get the first n elements of the array

primes = [7, 2, 3, 5]
primes.take(3)
# [7, 2, 3]

#access element

primes = [7, 2, 3, 5]
primes.fetch(3)
# 5
# Fetch will throw an error if the element does not exist
primes.fetch(10)
# (index 10 outside of array bounds: -4...4)
# or get an default value
primes.fetch(10, -1)
# -1

#Delete first n elements

primes = [7, 2, 3, 5]
primes.drop(3)
# [5]

#Delete the first element

primes = [7, 2, 3, 5]
primes.shift
# [2, 3, 5]

#Remove last element

primes = [7, 2, 3, 5]
primes.pop
# [7, 2, 3]

#Delete element with index

primes = [7, 2, 3, 5]
primes.delete_at(-1)
# [7, 2, 3]

#Remove all occurrences of elements

primes = [7, 2, 3, 5, 5]
primes.delete(5)
# [7, 2, 3]

#each

# When you have single line blocks
salary = [399, 234, 566, 533, 233]
salary.each { |s| puts s }
# output
# 399
# 234
# 566
# 533
# 233

When you have a multi-line block, you can replace the curly braces {} with do and end

salary.each do |s|
  a = 10
  res = a * s
  puts res
end
# output
# 3990
# 2340
# 5660
# 5330
# 2330

Or you can do the same thing using braces {} and semicolon as separator instead of newline

salary.each { |s| a = 10 ; res = a * s ; puts res }

#each_with_index

salary = [399, 234, 566, 533, 233]
salary.each_with_index { |value, index| puts "#{index} #{value}" }
# output
# 0 399
# 1 234
# 2 566
# 3 533
# 4 233

#each_index

salary = [399, 234, 566, 533, 233]
salary.each_index { |i| puts i}
# output
# 0
# 1
# 2
# 3
# 4

#map

salary = [399, 234, 566, 533, 233]
salary.map { |s|  s * 10  }
# return
# [3990, 2340, 5660, 5330, 2330]
# On the other hand, each returns the original value
salary = [399, 234, 566, 533, 233]
salary.each { |s|  s * 10  }
# return
# [399, 234, 566, 533, 233]

#collect

salary = [399, 234, 566, 533, 233]
salary.collect { |s| s > 400 }
# output
# [false, false, true, true, false]

#for

for value in [2, 3, 5, 7]
    puts value
end

#each_with_object

colors = [
  {color: "red", count: 3}, {color: "red", count: 5}, {color: "black", count: 4}
]
colors.each_with_object(Hash.new(0)) { |color, hash| hash["color_"+color[:color]] = color[:color].upcase; hash["count_"+color[:color]] += color[:count] }
# output
{"color_red"=>"RED", "count_red"=>8, "color_black"=>"BLACK", "count_black"=>4}

[1, 2, 3].each_with_object(0) { |number, sum| sum += number}
# output
# 0
# Because 0 is immutable, and since the initial object is 0, the method returns 0

#while

planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
index = 0
while index < planets.size
    puts "#{planets[index]}"
    index += 1
end

a = 1
star = '*'
while a <= 10
    puts star
    star += '*'
    a += 1
end

#do while

planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
index = 0
loop do
    puts "#{planets[index]}"
    index += 1
    break if planets[index] == "Mars" or index > planets.size
end

#until

planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
index = planets.size - 1
until index < 0
    puts "#{planets[index]}"
    index -= 1
end
a = 1
star = '*'
until star.length > 10
    puts star
    star += '*'
    a += 1
end

#times

10.times { puts "#{rand(1..100)}"}
# output
# will print 10 random numbers

Just because you can doesn't mean you should iterate over an array like this

data_sample = [2, 3, 5, 7]
data_sample.size.times { |index| puts "#{data_sample[index]}" }
# output
# 2
# 3
# 5
# 7

#upto

data_sample = [2, 3, 5, 7]
0.upto((data_sample.size - 1) / 2) { |index| puts "#{data_sample[index]}" }
# output
# 2
# 3

#downto

data_sample = [2, 3, 5, 7]
(data_sample.size - 1).downto(data_sample.size / 2) { |index| puts "#{data_sample[index]}" }
# output
# 7
# 5

#step

1.step(20, 2) { |number| puts "#{number}"}
# output
# 1
# 3
# 5
# 7
# 9
# 11
# 13
# 15
# 17
# 19

19.step(1, -2) { |number| puts "#{number}"}
# output
# 19
# 17
# 15
# 13
# 11
# 9
# 7
# 5
# 3
# 1

#inject

numbers = [2, 2, 2, 2, 2]
numbers.inject{ |res, n| res + n }
# The output is the sum of all numbers
# If no initial value is set for res, the first element of the array is used as the initial value of res.
#10
# Now set the value of res to 11
numbers = [2, 2, 2, 2, 2]
numbers.inject(11) { |res, n| res + n }
# so 11 + 2, 13 + 2, 15 + 2, 17 + 2 and 19 + 2
# 21
# using symbol
numbers = [2, 2, 2, 2, 2]
numbers.inject(:+)
# output
# 10

Use initial values and symbols

numbers = [2, 2, 2, 2, 2]
numbers.inject(11, :+)
# output
# 21

#reduce

numbers = [2, 2, 2, 2, 2]
numbers.reduce(11, :+)
# output
# 21

#detect

planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
planets.detect { |name| name.start_with?("E") and name.end_with?("h") }
# output
# Earth
salary = [399, 234, 566, 533, 233]
salary.detect { |s| s > 1000 }
# output
# nil

#find

planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
planets.find { |name| name.start_with?("E") and name.end_with?("h") }
# output
# Earth

#select

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers.select { |n| n % 2 == 0 }
# Now you have an even array
# [2, 4, 6, 8, 10]
# If there are no values that satisfy your logic, return an empty array
[1, 1, 1].select { |n| n % 2 == 0 }
# no even numbers
# []

#reject

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers.reject { |n| n % 2 == 0 }
# Reject if the number is even, so now we have an odd array
# [1, 3, 5, 7, 9]

#keep_if

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers.keep_if { |n| n % 2 == 0 }
# numbers Array contains only even numbers
# [2, 4, 6, 8, 10]

#delete_if

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numbers.delete_if { |n| n % 2 == 0 }
# numbers Array contains only odd numbers
# [1, 3, 5, 7, 9]

#drop_while

numbers = [1, 2, 3, 1, 2, 3, 0]
numbers.drop_while { |n| n < 3 }
# is 3 less than 3, returns false, so delete 1, 2
# [3, 1, 2, 3, 0]

#reverse_each

words = %w[first second third fourth fifth sixth]
str = ""
words.reverse_each {|word| str += "#{word} "}
p str #=> "sixth fifth fourth third second first "

#boolean enumerable method

#boolean enumerable method

Name When to use
all? When you want to check if all elements meet your condition
any? When you want to check if at least one item meets your condition
one? When you want to check if one element meets your requirement
none? When you want to check if no item meets your condition, the opposite of?
empty? When you want to check if an object is empty
include? When you want to check if an element exists in the object

#all?

[2, 4, 6, 8, 10].all? { |num| num % 2 == 0 }
# true
[1, 4, 6, 8, 10].all? { |num| num % 2 == 0 }
# false

#any?

[1, 3, 5, 7, 10].any? { |num| num % 2 == 0 }
# true
[1, 3, 5, 7, 19].any? { |num| num % 2 == 0 }
# false

#one?

[1, 3, 2, 5, 7].one? { |num| num % 2 == 0 }
# true
[1, 3, 2, 5, 4].one? { |num| num % 2 == 0 }
# false

#none?

[1, 3, 5, 7, 9].none? { |num| num % 2 == 0 }
# true
[2, 3, 5, 7, 9].none? { |num| num % 2 == 0 }
# false

#empty?

[].empty?
# true
[1, 3, 5, 7, 9].empty?
# false

#Combination method

#Combination method

  • & Returns a new array containing each element found in array and array other_array; duplicates are omitted; use eql? to compare items
  • intersection Returns a new array containing each element found in self and all given arrays other_arrays; duplicates are omitted; use eql? to compare items
  • + Returns an array containing all elements of self followed by all elements of the given array
  • - Returns an array containing all elements of self not found in the given array
  • union Returns an array containing all elements of self and all elements of the given array, with duplicates removed
  • difference Returns an array containing all elements of self not found in any given array
  • product self Returns or produces all combinations of elements from self and the given array

#&

[0, 1, 2, 3] & [1, 2] # => [1, 2]
[0, 1, 0, 1] & [0, 1] # => [0, 1]

#intersection

[0, 1, 2, 3].intersection([0, 1, 2], [0, 1, 3])
# => [0, 1]
[0, 0, 1, 1, 2, 3].intersection([0, 1, 2], [0, 1, 3])
# => [0, 1]

#+

a = [0, 1] + [2, 3]
a # => [0, 1, 2, 3]

#-

[0, 1, 1, 2, 1, 1, 3, 1, 1] - [1]
# => [0, 2, 3]
[0, 1, 2, 3] - [3, 0]
# => [1, 2]
[0, 1, 2] - [4]
# => [0, 1, 2]

#union

[0, 1, 2, 3].union([4, 5], [6, 7])
# => [0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 1].union([2, 1], [3, 1])
# => [0, 1, 2, 3]
[0, 1, 2, 3].union([3, 2], [1, 0])
# => [0, 1, 2, 3]

#difference

[0, 1, 1, 2, 1, 1, 3, 1, 1].difference([1])
# => [0, 2, 3]
[0, 1, 2, 3].difference([3, 0], [1, 3])
# => [2]
[0, 1, 2].difference([4])
# => [0, 1, 2]

#product

a = [0, 1, 2]
a1 = [3, 4]
p = a.product(a1)
p.size # => 6 # a.size * a1.size
p # => [[0, 3], [0, 4], [1, 3], [1, 4], [2, 3], [2, 4]]

#Loops

#while loop

# variable count
count = 4
# using while loop
# here conditional is count i.e. 4
while count >= 1
  # statements to be executed
  puts "Ruby Cheatsheet"
  count = count - 1
  # while loop ends here
end

output

Ruby Cheatsheet
Ruby Cheatsheet
Ruby Cheatsheet
Ruby Cheatsheet

#for loop

# loop using range as expression
text = "Ruby Cheatsheet"
# using for loop with the range
for count in 1..5 do
  puts text
end

output

Ruby Cheatsheet
Ruby Cheatsheet
Ruby Cheatsheet
Ruby Cheatsheet
Ruby Cheatsheet

#do..while loop

# starting of do..while loop
loop do
  puts "Ruby Cheatsheet"
  val = '7'
  # using boolean expressions
  if val == '7'
    break
  end
  # ending of ruby do..while loop
end

output

Ruby Cheatsheet

#until loop

var = 7
# here do is optional
until var == 11 do
  # code to be executed
  puts var * 10
  var = var + 1
  # here loop ends
end

output

70
80
90
100

#Break out of loop

salary = [399, 234, 566, 533, 233]
salary.each do |s|
  break if s == 566
  puts s
end
# output
# 399
# 234

By using the break keyword

#skip within loop

salary = [399, 234, 566, 533, 233]
salary.each do |s|
  next if s == 533
  puts s
end
# output
# 399
# 234
# 566
# 233

By using next keyword

#Repeat current iteration

data = [456, 3000]
retry_count = 0
status = "network failure"
sum = 0
data.each do |d|
    if retry_count == 3
        status = "connection established"
        retry_count = 0
        redo
    elsif status == "network failure" and retry_count < 5
        puts "network failure #{retry_count}"
        retry_count += 1
        redo
    elsif status == "connection established"
        puts d
        sum += d
    end
end
# output of sum
# 3456

#Start the cycle again

numbers = [2, 2, 44, 44]
sum = 0
begin
    numbers.each do |s|
        if rand(1..10) == 5
            puts "hi 5, let's do it again!"
            sum = 0
            raise "hi 5"
        end
        puts s
        sum += s
    end
rescue
    retry
end

#Classes

#Classes Example

class Person
    # when you create a new object, it looks for a method named initialize and executes it, like a constructor in java
    # def initialize(name, number)
    #    @name = name
    #    @number = number
    # end
    # instance variable
    # @name
    # class variable
    # @@count
    # attr_accessor acts as a getter and setter for the following instance attributes
    attr_accessor :name, :number
    # class variable must be initialized
    @@count = 0
    def self.count
        @@count
    end
    def self.count=(count)
        @@count = count
    end
    def initialize
        @@count += 1
    end
end
# create an instance of the Person class
p1 = Person.new
# set attributes of the Person class
p1.name = "Yukihiro Matsumoto"
p1.number = 9999999999
# get attributes of the Person class
puts "#{p1.name}"
puts "#{p1.number}"
puts "#{Person.count}"
# Yukihiro Matsumoto
# 9999999999
# 1
p2 = Person.new
p2.name = "Yukihiro Matsumoto"
p2.number = 9999999999
# get attributes of the Person class
puts "#{p2.name}"
puts "#{p2.number}"
puts "#{Person.count}"
# Yukihiro Matsumoto
# 9999999999
# 2
# set class variable
Person.count = 3
puts "#{Person.count}"
# 3

#Inherit a class

class Person
    attr_accessor :name, :number
end
# Inherit methods and properties from parent class using < symbol
class Student < Person
    attr_accessor :id
end
s = Student.new
s.name = "James Bond"
s.number = 700
s.id = 678
puts "#{p.name}"
James Bond
puts "#{p.number}"
700
puts "#{p.id}"
678

#Check instance type

class Vehicle; end
class Car < Vehicle; end
class Audi < Car; end
car = Car.new
car.instance_of? Vehicle
false
car.instance_of? Car
true
car.instance_of? Audi
false
a = 7
a.instance_of? Integer
true
a.instance_of? Numeric
false

Returns true if the object is an instance of the given class and not a subclass or superclass

puts (String.methods).sort
# Exclude methods inherited from Object class
puts (String.methods - Object.public_instance_methods).sort

#Check if a class has a specific method

String.respond_to?(:prepend)
true
String.respond_to?(:append)
false

#See Also