diff --git a/source/_posts/ruby.md b/source/_posts/ruby.md
new file mode 100644
index 0000000..13f972a
--- /dev/null
+++ b/source/_posts/ruby.md
@@ -0,0 +1,2254 @@
+---
+title: Ruby
+date: 2024-04-25 09:50:25
+background: bg-red-500
+tags:
+ - script
+ - interpret
+categories:
+ - Programming
+intro: |
+ The [Ruby](https://www.ruby-lang.org/) cheat sheet is a one-page reference sheet for the Ruby programming language.
+plugins:
+ - copyCode
+---
+
+Getting Started
+---------------
+
+### Install
+
+```bash
+# 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 {.row-span-2}
+
+- [Gemfile](https://bundler.io/v2.3/man/gemfile.5.html) Is the Bundler (also gem) configuration file that contains the project's gem list (dependencies)
+
+```ruby
+# 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
+
+```bash
+$ bundle install
+```
+
+Solve the problem of Gemfile.lock inconsistency between mac for development and linux for production
+
+```bash
+bundle lock --add-platform x86_64-linux
+```
+
+### Install a specific version of a specific ruby gem
+
+```bash
+$ gem install bundler -v 2.4.20
+$ gem install minitest -v 5.22.3
+```
+
+### Update gems using Bundler
+
+```bash
+# Updating a single gem using Bundler
+$ bundle update nokogiri
+# Use Bundler to update each gem in the Gemfile
+$ bundle update
+```
+
+### Comment {.row-span-1}
+
+```ruby
+# This is a single line comments.
+=begin
+Multi-line
+Comment
+=end
+puts "Hello world!" # Inline comments for code
+```
+
+### reserved words {.col-span-1}
+
+
+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 opearator
+| `or` | Logical OR opearator
+| `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 with`if`,`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 {.row-span-7}
+
+#### Logical Operators
+
+- `and`
+- `or`
+- `not`
+- `&&`
+- `||`
+- `!`
+
+#### Bit operators
+
+- `&`
+- `|`
+- `^`
+- `~`
+- `<<`
+- `>>`
+
+#### Arithmetic operators
+
+- `+`
+- `-`
+- `*`
+- `/`
+- `%`
+- `**`
+
+#### Comparison operator
+
+- `==`
+- `!=`
+- `>`
+- `<`
+- `>=`
+- `<=`
+- `<=>`
+- `===`
+- `eql?`
+- `equal?`
+
+#### Operator examples
+
+```bash
+# 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 {.col-span-2}
+
+| - | - | - | - |
+|------|-------|---------|-------------|
+| 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](https://ruby-doc.org/docs/ruby-doc-bundle/UsersGuide/rg/) cap 19,20,21,22,23
+[Pre-Defined Variables and Constants](https://ruby-doc.org/docs/ruby-doc-bundle/Manual/man-1.4/variable.html)
+
+
+### Check the scope of a variable
+
+```ruby
+defined? count
+"local-variable"
+defined? @id
+"instance-variable"
+defined? @@name
+"class variable"
+defined? $version
+"global-variable"
+defined? PI
+"constant"
+```
+
+### Data Types {.col-span-2}
+
+| - | - | - | - |
+|:--------|:-----------------------------|:------------------------------------------|:--------------|
+| Type | Example | Class | Documentation |
+| `Integer` | a = 17 | a.class > Integer
a.class.superclass > Numeric | [#]((https://ruby-doc.org/3.3.1/Integer.html)) |
+| `Float` | a = 87.23 | a.class > Float
a.class.superclass > Numeric | [#](https://ruby-doc.org/3.3.1/Float.html) |
+| `String` | a = "Hello universe" | a.class > String | [#](https://ruby-doc.org/3.3.1/String.html) |
+| `Array` | a = [12, 34] | a.class > Array | [#](https://ruby-doc.org/3.3.1/Array.html) |
+| `Hash` | a = {type: "tea", count: 10} | a.class > Hash | [#](https://ruby-doc.org/3.3.1/Hash.html) |
+| `Boolean` | a = false
a = true | a.class > FalseClass
a.class > TrueClass | [TrueClass](https://ruby-doc.org/3.3.1/TrueClass.html) [FalseClass](https://ruby-doc.org/3.3.1/FalseClass.html) |
+| `Symbol` | a = :status | a.class > Symbol | [#](https://ruby-doc.org/3.3.1/Symbol.html) |
+| `Range` | a = 1..3 | a.class > Range | [#](https://ruby-doc.org/3.3.1/Range.html) |
+| `Nil` | a = nil | a.class > NilClass | [#](https://ruby-doc.org/3.3.1/NilClass.html) |
+
+[further reading](https://www.digitalocean.com/community/tutorials/understanding-data-types-in-ruby)
+
+### Check data type
+
+```ruby
+# Both are synonyms
+a = 37
+a.kind_of? Integer
+# true
+a.is_a? Integer
+# true
+```
+
+### Symbol
+
+```ruby
+week_days = {sunday: 11, monday: 222}
+```
+
+### Integer useful methods
+
+```ruby
+2.even?
+# true
+3.even?
+# false
+```
+
+### Range
+
+`..` Used to create inclusive ranges
+
+```ruby
+range = 1..10
+range.to_a
+# output => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+```
+
+`...` Used to create exclusive ranges
+
+```ruby
+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
+
+```ruby
+(1..20).step(2) { |number| puts "#{number}"}
+# output
+# 1
+# 3
+# 5
+# 7
+# 9
+# 11
+# 13
+# 15
+# 17
+# 19
+```
+
+Ruby Flow control
+---
+
+### if
+
+```ruby
+num = 2
+puts 'two' if num == 2
+```
+
+If the condition is true, execute the code
+
+### if elsif else
+
+```ruby
+temp = 19
+if temp >= 25
+ puts "hot"
+elsif temp < 25 && temp >= 18
+ puts "normal"
+else
+ puts "cold"
+end
+# output => normal
+```
+
+### unless
+
+```ruby
+# 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 {.row-span-2}
+
+```ruby
+# 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 )
+
+```ruby
+case input
+ when 19 then puts "It's 19"
+end
+```
+
+### case( Optional failure )
+
+```ruby
+case input
+ when 19 then puts "It's 19"
+else
+ puts "It's not 19"
+end
+```
+
+### case( Get return value )
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+"HELLO World".downcase # "hello world"
+"hello worlD".upcase # "HELLO WORLD"
+"hEllo wOrlD".capitalize # "Hello world"
+"hEllo WOrlD".swapcase # "HeLLO woRLd"
+```
+
+### useful methods {.col-span-3}
+
+| 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) { |match| block} | `"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"
a.prepend("hello ")`
`"hello world"` | Adds the string before another string |
+| insert | `a = "hello"
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"
string.split`
`["a", "b", "c", "d"]` | Converts the string into an array of characters |
+| join | `arr = ['a', 'b', 'c']
arr.join` => `"abc"` | Converts an array into a string |
+| to_i | `a = "49"
a.to_i` => `49` | Converts the string into an integer |
+| chop | `"abcd?".chop("?")` => `"abcd"` | Deletes the last character from the string |
+| count | `str = "aaab"
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/)` => `#` | 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 {.row-span-3}
+
+```ruby
+def method_name(parameter1, parameter2)
+ puts "#{parameter1} #{parameter2}"
+ parameter1 + parameter2
+end
+```
+---
+
+```ruby
+res = method_name(20, 10)
+# output => 30
+def method_name(parameter1, parameter2)
+ puts "#{parameter1} #{parameter2}"
+ return parameter1 + parameter2
+end
+# output => 30
+```
+
+### Call method
+
+```ruby
+res = method_name(parameter1, parameter2)
+# Methods can be called without parentheses
+res = method_name parameter1, parameter2
+```
+
+### Class method {.row-span-4}
+
+Class methods are class-level methods. There are multiple ways to define class methods
+
+```ruby
+class Mobile
+ def self.ring
+ "ring ring ring..."
+ end
+end
+
+Mobile.ring
+```
+---
+
+```ruby
+class Mobile
+ def Mobile.ring
+ "ring ring ring..."
+ end
+end
+Mobile.ring
+```
+---
+
+```ruby
+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)
+
+```ruby
+Mobile = Class.new do
+ def self.ring
+ "ring ring ring..."
+ end
+end
+Mobile.ring
+```
+
+```ruby
+Mobile = Class.new
+class << Mobile
+ def ring
+ "ring ring ring..."
+ end
+end
+Mobile.ring
+```
+
+### Use another parameter as default value
+
+```ruby
+def method_name(num1, num2 = num1)
+ return num1 + num2
+end
+res = method_name(10)
+# output => 20
+```
+
+### Define default values for method parameters
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+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`
+
+```ruby
+"some text".nil?
+# false
+nil.nil?
+# true
+```
+
+You can have your own boolean method
+
+```ruby
+def is_vowel?(char)
+ ['a','e','i','o','u'].include? char
+end
+is_vowel? 'a'
+# true
+is_vowel? 'b'
+# false
+```
+
+Blocks
+---
+
+### Block example
+
+```ruby
+# 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
+
+```ruby
+salary = [399, 234, 566, 533, 233]
+salary.each { |s| puts s }
+# puts s = block body
+# |s| = block arugments
+```
+
+### Multi-line block
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+def give_me_data
+ yield
+end
+
+give_me_data
+
+# output
+# LocalJumpError: no block given (yield)
+```
+
+### Ways to handle exceptions and make blocks optional
+
+```ruby
+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
+
+```ruby
+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 {.col-span-2}
+
+```ruby
+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
+
+```ruby
+p = Proc.new { return 10 }
+p.call
+# output
+LocalJumpError: unexpected return
+```
+
+### Cannot return from top-level context
+
+```ruby
+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{.row-span-2}
+
+```ruby
+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
+
+```ruby
+l.()
+l[]
+```
+
+### strict arguments
+
+```ruby
+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 {.row-span-2}
+
+```ruby
+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
+
+```ruby
+l = -> { return 10 }
+l.call
+
+# output => 10
+```
+
+Array
+---
+
+### Initialize an empty array
+
+```ruby
+array = Array.new #=> []
+# or
+array = []
+```
+
+### Array containing objects of different types
+
+```ruby
+array = [1, "two", 3.0]
+#=> [1, "two", 3.0]
+```
+
+### Fill array with initial size and default objects {.row-span-2}
+
+```ruby
+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 {.col-span-2}
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+str_array = [
+ "This", "is", "a", "small", "array"
+]
+str_array[0] #=> "This"
+str_array[1] #=> "is"
+str_array[4] #=> "array"
+```
+
+### negative index
+
+```ruby
+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
+
+```ruby
+str_array = [
+ "This", "is", "a", "small", "array"
+]
+
+puts str_array.at(0) #=> "This"
+```
+
+### Range acquisition
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+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 {.row-span-2}
+
+```ruby
+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
+
+```ruby
+numbers = Array.new(10) { |n| n = n * 2 }
+#=> [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
+```
+
+### Filling arrays becomes easier
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+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?`)
+
+```ruby
+planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
+planets.include? "Mars"
+# output => true
+planets.include? "Pluto"
+# output => false
+```
+
+### Get array size
+
+```ruby
+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
+
+```ruby
+numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+numbers.clear
+# output => []
+```
+
+### Get the first element of the array
+
+```ruby
+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
+
+```ruby
+numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+numbers[-1]
+# or
+numbers.last
+# output => 10
+```
+
+### Merge two arrays
+
+```ruby
+a = ["tom", "mot", "otm"]
+b = [2, 3, 5]
+a.zip(b)
+# output
+# [["tom", 2], ["mot", 3], ["otm", 5]]
+```
+
+### Sort array {.row-span-3}
+
+```ruby
+primes = [7, 2, 3, 5]
+sorted_primes = primes.sort
+puts "#{sorted_primes}"
+# output => [2, 3, 5, 7]
+```
+or in-place sort
+```ruby
+primes = [7, 2, 3, 5]
+primes.sort!
+puts "#{primes}"
+# output => [2, 3, 5, 7]
+```
+
+```ruby
+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
+
+```ruby
+primes = [7, 2, 3, 5]
+primes.max_by { |p| p }
+# output => 7
+```
+
+### Get array elements using range {.row-span-2}
+
+```ruby
+# 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
+
+```ruby
+primes = [7, 2, 3, 5]
+primes.take(3)
+# [7, 2, 3]
+```
+
+### access element
+
+```ruby
+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
+
+```ruby
+primes = [7, 2, 3, 5]
+primes.drop(3)
+# [5]
+```
+
+### Delete the first element
+
+```ruby
+primes = [7, 2, 3, 5]
+primes.shift
+# [2, 3, 5]
+```
+
+### Remove last element
+
+```ruby
+primes = [7, 2, 3, 5]
+primes.pop
+# [7, 2, 3]
+```
+
+### Delete element with index
+
+```ruby
+primes = [7, 2, 3, 5]
+primes.delete_at(-1)
+# [7, 2, 3]
+```
+
+### Remove all occurrences of elements
+
+```ruby
+primes = [7, 2, 3, 5, 5]
+primes.delete(5)
+# [7, 2, 3]
+```
+
+### each {.row-span-3}
+
+```ruby
+# 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`
+
+```ruby
+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
+
+```ruby
+salary.each { |s| a = 10 ; res = a * s ; puts res }
+```
+
+### each_with_index
+
+```ruby
+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
+
+```ruby
+salary = [399, 234, 566, 533, 233]
+salary.each_index { |i| puts i}
+# output
+# 0
+# 1
+# 2
+# 3
+# 4
+```
+
+### map
+
+```ruby
+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
+
+```ruby
+salary = [399, 234, 566, 533, 233]
+salary.collect { |s| s > 400 }
+# output
+# [false, false, true, true, false]
+```
+
+### for
+
+```ruby
+for value in [2, 3, 5, 7]
+ puts value
+end
+```
+
+### each_with_object {.col-span-2}
+
+```ruby
+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
+
+```ruby
+planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
+index = 0
+while index < planets.size
+ puts "#{planets[index]}"
+ index += 1
+end
+```
+---
+
+```ruby
+a = 1
+star = '*'
+while a <= 10
+ puts star
+ star += '*'
+ a += 1
+end
+```
+
+### do while
+
+```ruby
+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
+
+```ruby
+planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
+index = planets.size - 1
+until index < 0
+ puts "#{planets[index]}"
+ index -= 1
+end
+```
+
+```ruby
+a = 1
+star = '*'
+until star.length > 10
+ puts star
+ star += '*'
+ a += 1
+end
+```
+
+### times
+
+```ruby
+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
+
+```ruby
+data_sample = [2, 3, 5, 7]
+data_sample.size.times { |index| puts "#{data_sample[index]}" }
+# output
+# 2
+# 3
+# 5
+# 7
+```
+
+### upto
+
+```ruby
+data_sample = [2, 3, 5, 7]
+0.upto((data_sample.size - 1) / 2) { |index| puts "#{data_sample[index]}" }
+# output
+# 2
+# 3
+```
+
+### downto
+
+```ruby
+data_sample = [2, 3, 5, 7]
+(data_sample.size - 1).downto(data_sample.size / 2) { |index| puts "#{data_sample[index]}" }
+# output
+# 7
+# 5
+```
+
+
+### step {.row-span-2}
+
+```ruby
+1.step(20, 2) { |number| puts "#{number}"}
+# output
+# 1
+# 3
+# 5
+# 7
+# 9
+# 11
+# 13
+# 15
+# 17
+# 19
+```
+
+---
+
+```ruby
+19.step(1, -2) { |number| puts "#{number}"}
+# output
+# 19
+# 17
+# 15
+# 13
+# 11
+# 9
+# 7
+# 5
+# 3
+# 1
+```
+
+### inject {.row-span-2}
+
+```ruby
+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
+
+```ruby
+numbers = [2, 2, 2, 2, 2]
+numbers.inject(11, :+)
+# output
+# 21
+```
+
+### reduce
+
+```ruby
+numbers = [2, 2, 2, 2, 2]
+numbers.reduce(11, :+)
+# output
+# 21
+```
+
+### detect
+
+```ruby
+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
+
+```ruby
+planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
+planets.find { |name| name.start_with?("E") and name.end_with?("h") }
+# output
+# Earth
+```
+
+
+### select
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+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 {.row-span-2}
+
+| 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?
+
+```ruby
+[2, 4, 6, 8, 10].all? { |num| num % 2 == 0 }
+# true
+[1, 4, 6, 8, 10].all? { |num| num % 2 == 0 }
+# false
+```
+
+### any?
+
+```ruby
+[1, 3, 5, 7, 10].any? { |num| num % 2 == 0 }
+# true
+[1, 3, 5, 7, 19].any? { |num| num % 2 == 0 }
+# false
+```
+
+### one?
+
+```ruby
+[1, 3, 2, 5, 7].one? { |num| num % 2 == 0 }
+# true
+[1, 3, 2, 5, 4].one? { |num| num % 2 == 0 }
+# false
+```
+
+### none?
+
+```ruby
+[1, 3, 5, 7, 9].none? { |num| num % 2 == 0 }
+# true
+[2, 3, 5, 7, 9].none? { |num| num % 2 == 0 }
+# false
+```
+
+### empty?
+
+```ruby
+[].empty?
+# true
+[1, 3, 5, 7, 9].empty?
+# false
+```
+
+Combination method
+---
+
+### Combination method {.row-span-2}
+
+- `&` 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
+
+### &
+
+```ruby
+[0, 1, 2, 3] & [1, 2] # => [1, 2]
+[0, 1, 0, 1] & [0, 1] # => [0, 1]
+```
+
+### intersection
+
+```ruby
+[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]
+```
+
+### +
+
+```ruby
+a = [0, 1] + [2, 3]
+a # => [0, 1, 2, 3]
+```
+
+### -
+
+```ruby
+[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
+
+```ruby
+[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
+
+```ruby
+[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
+
+```ruby
+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
+
+```ruby
+# 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
+
+```ruby
+# 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
+
+```ruby
+# 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
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+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 {.row-span-2}
+
+```ruby
+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
+
+```ruby
+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
+
+```ruby
+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
+
+### Print all method names of a class
+
+```ruby
+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
+
+```ruby
+String.respond_to?(:prepend)
+true
+String.respond_to?(:append)
+false
+```
+
+See Also
+---
+
+- [Ruby](https://www.ruby-lang.org/en/) _(ruby-lang.org)_
+- [Ruby Cheatsheet](https://github.com/lifeparticle/Ruby-Cheatsheet) _(github.com)_
\ No newline at end of file
diff --git a/source/assets/icon/ruby.svg b/source/assets/icon/ruby.svg
new file mode 100644
index 0000000..45e591d
--- /dev/null
+++ b/source/assets/icon/ruby.svg
@@ -0,0 +1,3 @@
+
\ No newline at end of file