From 8ff8115dac94bcd017cbd0b30a8fb013286769f0 Mon Sep 17 00:00:00 2001 From: W1ldr Date: Thu, 25 Apr 2024 15:58:28 +0100 Subject: [PATCH 1/2] feat: add ruby icon --- source/assets/icon/ruby.svg | 3 +++ 1 file changed, 3 insertions(+) create mode 100644 source/assets/icon/ruby.svg 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 From a30e33278aad8c22b20d1f0f473cbffad921f21c Mon Sep 17 00:00:00 2001 From: W1ldr Date: Thu, 2 May 2024 09:48:25 +0100 Subject: [PATCH 2/2] feat: add ruby cheatsheet --- source/_posts/ruby.md | 2254 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2254 insertions(+) create mode 100644 source/_posts/ruby.md 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