DEV Community: Augusto Kato

Methods in Ruby

Augusto Kato — Mon, 21 Aug 2023 03:52:54 +0000

Methods are used to don't repeat the same thing all along the program.

Creating Methods

To create a method use this syntax:

def my_first_method
  "Hello"
end

puts my_first_method  #=> "Hello"

Parameters and Arguments

Parameters are placeholder variables in the template of your method, whereas arguments are the actual variables that get passed to the method when it is called.

def add_ten(number)
  number + 10
end

puts add_ten(20)  #=> "30"

In this example, number is a parameter and 20 is an argument.

Default Parameters

If you don't want to always give parameters when calling a method, use default parameters:

def add_ten(number = 1)
  number + 10
end

puts add_ten(20)  #=> "30"
puts add_ten      #=> "11"

What Methods Return

Ruby offers implicit return for methods, it always returns the last expression that was evaluated.

And Ruby offers explicit return too, it is useful to write methods that check for input errors before continuing.

def even_odd(number)
  unless number.is_a? Numeric
    return "A number was not entered."
  end

  if number % 2 == 0
    "That is an even number."
  else
    "That is an odd number."
  end
end

puts even_odd(30) #=>  That is an even number.
puts even_odd("Egg") #=>  A number was not entered.

Predicate Methods

Methods that have a question mark (?) at the end of their name, such as even?, odd?, or between? are predicate methods, which is a naming convention that Ruby uses for methods that return a Boolean.

puts 3.even?  #=> false
puts 10.even?  #=> true
puts 171.odd?  #=> true

puts 13.between?(10, 15)  #=> true

Bang Methods

Methods that are denoted with an exclamation mark (!) at the end of the method name.

By adding a ! to the end of your method, you indicate that this method performs its action and simultaneously overwrites the value of the original object with the result.

whisper = "HEY"
puts whisper.downcase! #=> "hey"
puts whisper #=> "hey"

Hashes in Ruby

Augusto Kato — Sun, 20 Aug 2023 03:17:08 +0000

Ruby hashes are similar to objects in JS, or Dictionaries in Python.

Hashes are like dining menus, the dish names are the keys and the food are the values.

Creating Hashes

Using literal ({}):

my_hash = {
  "a random word" => "pineapple",
  "Amanda's math test score" => 94,
  "an array" => [1, 2, 3],
  "an empty hash within a hash" => {}
}

Using ::new:

my_hash = Hash.new
my_hash               #=> {}

Accessing Values

It's the same way that you access elements in an array.

movies = {
  "horror" => "Talk To Me",
  "action" => "Blue Beetle"
}

movies["horror"]   #=> "Talk To Me"

Adding or Changing Data

Just call the key and set a value:

movies["drama"] = "Eternal Sunshine Of The Spotless Mind"

movies     #=> {"horror" => "Talk To Me", "action" => "Blue Beetle", "drama" => "Eternal Sunshine Of The Spotless Mind"}

movies["horror"] = "Scream"
movies     #=> {"horror" => "Scream", "action" => "Blue Beetle", "drama" => "Eternal Sunshine Of The Spotless Mind"}

Removing Data

Use #delete method, and it returns the value of the key-value pair that was deleted from the hash:

movies.delete("horror")    #=> "Scream"
movies                     #=> {"action" => "Blue Beetle", "drama" => "Eternal Sunshine Of The Spotless Mind"}

Methods

Specific to hashes: #keys and #values

movies = {
  "The Grand Budapest Hotel" => "Wes Anderson",
  "Lost in Translation" => "Sofia Coppola",
  "Lady Bird" => "Greta Gerwig"
}


movies.keys      #=> ["The Grand Budapest Hotel", "Lost in Translation", "Lady Bird"]
movies.values    #=> ["Wes Anderson", "Sofia Coppola", "Greta Gerwig"]

Merging two hashes

The hash2 will overwrite the values of hash1:

hash1 = { "a" => 100, "b" => 200 }
hash2 = { "b" => 254, "c" => 300 }
hash1.merge(hash2)      #=> { "a" => 100, "b" => 254, "c" => 300 }

Symbols as Hash Keys

Symbols are used as keys because they are more performant than strings:

# 'Rocket' syntax
american_cars = {
  :chevrolet => "Corvette",
  :ford => "Mustang",
  :dodge => "Ram"
}
# 'Symbols' syntax
japanese_cars = {
  toyota: "Supra",
  mazda: "RX-7",
  subaru: "Impreza"
}

To access:

american_cars[:ford]    #=> "Mustang"
japanese_cars[:mazda]   #=> "RX-7"

Common Hash Methods

key?

The key? method allows you to check if a hash contains a specific key. It returns a boolean value.

irb :001 > name_and_age = { "Bob" => 42, "Steve" => 31, "Joe" => 19}
=> {"Bob"=>42, "Steve"=>31, "Joe"=>19}
irb :002 > name_and_age.key?("Steve")
=> true
irb :003 > name_and_age.key?("Larry")
=> false

select

The select method allows you to pass a block and will return any key-value pairs that evaluate to true when passed to the block.

irb :004 > name_and_age.select { |k,v| k == "Bob" }
=> {"Bob"=>42}
irb :005 > name_and_age.select { |k,v| (k == "Bob") || (v == 19) }
=> {"Bob"=>42, "Joe"=>19}

fetch

The fetch method allows you to pass a given key and it will return the value for that key if it exists. You can also specify an option for return if that key is not present.

irb :006 > name_and_age.fetch("Steve")
=> 31
irb :007 > name_and_age.fetch("Larry")
=> KeyError: key not found: "Larry"
     from (irb):32:in `fetch'
     from (irb):32
     from /usr/local/rvm/rubies/ruby-2.5.3/bin/irb:16:in `<main>'
irb :008 > name_and_age.fetch("Larry", "Larry isn't in this hash")
=> "Larry isn't in this hash"

to_a

The to_a method returns an array version of your hash when called.

irb :009 > name_and_age.to_a
=> [["Bob", 42], ["Steve", 31], ["Joe", 19]]
irb :010 > name_and_age
=> {"Bob"=>42, "Steve"=>31, "Joe"=>19}

Arrays in Ruby

Augusto Kato — Sat, 19 Aug 2023 02:07:02 +0000

Today I learned about arrays and their methods in Ruby.

Creating Arrays

Here are two basic arrays, created by an array literal:

num_array = [1, 2, 3, 4, 5]
str_array = ["This", "is", "a", "small", "array"]

Created with the Array.new method. 2 optional arguments (initial size and default value):

Array.new               #=> []
Array.new(2)            #=> [nil, nil]
Array.new(3, 4)         #=> [4, 4, 4]
Array.new(3, true)      #=> [true, true, true]

Array.new also supports block:

Array.new(3) {|index| index * 2 } #=> [0, 2, 4]

Have to be used if default value is hash/array/object/etc. otherwise they'll share same reference:

# no!
arr = Array.new(3, {})
arr.first[:a] = 5
arr #=> [{:a=>5}, {:a=>5}, {:a=>5}]

# yes!
arr = Array.new(3) { {} }
arr.first[:a] = 5
arr #=> [{:a=>5}, {}, {}]

Accessing Elements

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

str_array.first         #=> "This"
str_array.first(2)      #=> ["This", "is"]
str_array.last(2)       #=> ["small", "array"]

str_array[0]            #=> "This"
str_array[1]            #=> "is"
str_array[4]            #=> "array"
str_array[-1]           #=> "array"
str_array[-2]           #=> "small"

Adding and Removing Elements

Adding: #push method or the shovel operator <<
Removing: #pop

num_array = [1, 2]

num_array.push(3, 4)      #=> [1, 2, 3, 4]
num_array << 5            #=> [1, 2, 3, 4, 5]
num_array.pop             #=> 5
num_array                 #=> [1, 2, 3, 4]

Adding in the beginning: #unshift
Removing in the beginning: #shift

num_array = [2, 3, 4]

num_array.unshift(1)      #=> [1, 2, 3, 4]
num_array.shift           #=> 1
num_array                 #=> [2, 3, 4]

#pop and #shift can take integer arguments:

num_array = [1, 2, 3, 11, 12, 13]

num_array.pop(3)          #=> [11, 12, 13]
num_array.shift(2)        #=> [1, 2]
num_array                 #=> [3]

Adding and subtracting arrays

a = [1, 2, 3]
b = [3, 4, 5]

a + b         #=> [1, 2, 3, 3, 4, 5]
a.concat(b)   #=> [1, 2, 3, 3, 4, 5]

To find differences between arrays:

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

Basic methods

[].empty?               #=> true
[[]].empty?             #=> false
[5, 6].empty?           #=> false

[5, 6, 7].length        #=> 3

[5, 6, 7].reverse       #=> [7, 6, 5]

[5, 6, 7].include?(7)   #=> true
[5, 6, 7].include?("7") #=> false

[5, 6, 7].join          #=> "567"
[5, 6, 7].join("-")     #=> "5-6-7"

Conditional Logic and Loops in Ruby

Augusto Kato — Fri, 18 Aug 2023 01:34:14 +0000

Conditional Logic

Truthy and falsy in Ruby

The only false values in Ruby are the values nil and false themselves, the number 0 or an empty string (“”) aren't false in Ruby.

Basic Conditional Statement

if statement:

if statement_to_be_evaluated == true
  # do something awesome...
end

if 1 < 2
  puts "Hot diggity, 1 is less than 2!"
end
#=> Hot diggity, 1 is less than 2!

If there is only one line of code to be evaluated inside the block, then you can rewrite the code to be more succinct and take up only one line:

puts "Hot diggity damn, 1 is less than 2" if 1 < 2

Adding else and elsif

if...elsif...else statement:

if attack_by_land == true
  puts "release the goat"
elsif attack_by_sea == true
  puts "release the shark"
else
  puts "release Kevin the octopus"
end

Boolean Logic

== (equals) returns true if the values compared are equal.

5 == 5 #=> true
5 == 6 #=> false

!= (not equal) returns true if the values compared are not equal.

5 != 7 #=> true
5 != 5 #=> false

> (greater than) returns true if the value on the left of the operator is larger than the value on the right.

7 > 5 #=> true
5 > 7 #=> false

< (less than) returns true if the value on the left of the operator is smaller than the value on the right.

5 < 7 #=> true
7 < 5 #=> false

>= (greater than or equal to) returns true if the value on the left of the operator is larger than or equal to the value on the right.

7 >= 7 #=> true
7 >= 5 #=> true

<= (less than or equal to) returns true if the value on the left of the operator is smaller than or equal to the value on the right.

5 <= 5 #=> true
5 <= 7 #=> true

#eql? checks both the value type and the actual value it holds.

5.eql?(5.0) #=> false; although they are the same value, one is an integer and the other is a float
5.eql?(5)   #=> true

#equal? checks whether both values are the exact same object in memory. This can be slightly confusing because of the way computers store some values for efficiency. Two variables pointing to the same number will usually return true.

a = 5
b = 5
a.equal?(b) #=> true

Ruby has a special operator that is affectionately referred to as the spaceship operator. Unlike the other comparison operators, which all return true or false, the spaceship operator returns one of three numerical values.

<=> (spaceship operator) returns the following:

-1 if the value on the left is less than the value on the right;
0 if the value on the left is equal to the value on the right; and
1 if the value on the left is greater than the value on the right.

5 <=> 10    #=> -1
10 <=> 10   #=> 0
10 <=> 5    #=> 1

Logical Operators

&& operator returns true if both the left and right expressions return true.
|| operator returns true if one of the expressions return true .

In Ruby there is a short circuit evaluation, if the first expression in && operator returns false, the second expression is never checked. And if the first expression in || operator returns true, the second expression is never checked, because it only needs one expression to be true.

The ! operator reverses the logic of the expression.

Case Statements

Use when you have to write multiple conditions:

grade = 'F'

did_i_pass = case grade #=> create a variable `did_i_pass` and assign the result of a call to case with the variable grade passed in
  when 'A' then "Hell yeah!"
  when 'D' then "Don't tell your mother."
  else "'YOU SHALL NOT PASS!' -Gandalf"
end

If you need to do more code manipulation:

grade = 'F'

case grade
when 'A'
  puts "You're a genius"
  future_bank_account_balance = 5_000_000
when 'D'
  puts "Better luck next time"
  can_i_retire_soon = false
else
  puts "'YOU SHALL NOT PASS!' -Gandalf"
  fml = true
end

Unless Statements

An unless statement works in the opposite way as an if statement: if the condition is false, it processes the code.

age = 19
puts "Welcome to a life of debt." unless age < 18

unless age < 18
  puts "Down with that sort of thing."
else
  puts "Careful now!"
end

Ternary Operator

The ternary operator is a one-line if...else statement that can make your code much more concise.

Its syntax is conditional statement ? <execute if true> : <execute if false>. You can assign the return value of the expression to a variable.

age = 19
response = age < 18 ? "You still have your entire life ahead of you." : "You're all grown up."
puts response #=> "You're all grown up."

Loops

Loop

It’s an infinite loop that will keep going unless you specifically request for it to stop, using the break command. Most commonly, break is used with a condition, as illustrated in the example below.

i = 0
loop do
  puts "i is #{i}"
  i += 1
  break if i == 13
end

While Loop

A while loop is similar to the loop loop except that you declare the condition that will break out of the loop up front.

i = 0
while i < 13 do
 puts "i is #{i}"
 i += 1
end

Until Loop

The until loop is the opposite of the while loop. A while loop continues for as long as the condition is true, whereas an until loop continues for as long as the condition is false.

i = 0
until i >= 10 do
 puts "i is #{i}"
 i += 1
end

Ranges

We can give Ruby ranges to loop:

(1..5)      # inclusive range: 1, 2, 3, 4, 5
(1...5)     # exclusive range: 1, 2, 3, 4

# We can make ranges of letters, too!
('a'..'d')  # a, b, c, d

For Loop

for i in 0..5
  puts "#{i} zombies incoming!"
end

Times Loop

Bonus of accessing the number it’s currently iterating through.

5.times do
  puts "Hello, world!"
end

5.times do |number|
  puts "Alternative fact number #{number}"
end

Upto and Downto Loops

5.upto(10) { |num| print "#{num} " }     #=> 5 6 7 8 9 10

10.downto(5) { |num| print "#{num} " }   #=> 10 9 8 7 6 5

Basic data types and variables in Ruby

Augusto Kato — Thu, 17 Aug 2023 02:07:02 +0000

Basic Data Types

Ruby has four basic data types: numbers (integers and floats), strings, symbols and Booleans (true, false and nil).

Numbers

# Addition
1 + 1   #=> 2

# Subtraction
2 - 1   #=> 1

# Multiplication
2 * 2   #=> 4

# Division
10 / 5  #=> 2

# Exponent
2 ** 2  #=> 4
3 ** 4  #=> 81

# Modulus (find the remainder of division)
8 % 2   #=> 0  (8 / 2 = 4; no remainder)
10 % 4  #=> 2  (10 / 4 = 2 with a remainder of 2)

There are two types of numbers in Ruby, integers and floats. Integers represent a whole number, and floats are numbers with a decimal point.
When doing arithmetic with integers, the result will always be a integer.

17 / 5    #=> 3, not 3.4

To convert the result, simply replace one of the integers on the expression with a float.

17 / 5.0  #=> 3.4

Converting Number Types

# To convert an integer to a float:
13.to_f   #=> 13.0

# To convert a float to an integer:
13.0.to_i #=> 13
13.9.to_i #=> 13

Useful Number Methods

#even?

8.even? #=> true
5.even? #=> false

#odd?

4.odd? #=> false
9.odd? #=> true

Strings

Concatenation

# With the plus operator:
"Hello " + "beautiful " + "World!"    #=> "Hello beautiful World!"

# With the shovel operator:
"Hello " << "beautiful " << "World!"  #=> "Hello beautiful World!"

# With the concat method:
"Hello ".concat("beautiful ").concat("World!")  #=> "Hello beautiful World!"

Substrings

"hello"[0]      #=> "h"

"hello"[0..1]   #=> "he"

"hello"[0, 4]   #=> "hell"

"hello"[-1]     #=> "o"

Escape characters

\\  #=> Need a backslash in your string?
\b  #=> Backspace
\r  #=> Carriage return, for those of you that love typewriters
\n  #=> Newline. You'll likely use this one the most.
\s  #=> Space
\t  #=> Tab
\"  #=> Double quotation mark
\'  #=> Single quotation mark

irb(main):001:0> puts "Hello \n\nHello"
Hello

Hello
=> nil

Interpolation

Evaluate a string that contains placeholder variables. Use double quotes so that string interpolation will work!

name = "harukat"

puts "Hello, #{name}" #=> "Hello, harukat"
puts 'Hello, #{name}' #=> "Hello, #{name}"

Common String Methods

#capitalize

"hello".capitalize #=> "Hello"

#include?

"hello".include?("lo")  #=> true

"hello".include?("z")   #=> false

#upcase

"hello".upcase  #=> "HELLO"

#downcase

"Hello".downcase  #=> "hello"

#empty?

"hello".empty?  #=> false

"".empty?       #=> true

#length

"hello".length  #=> 5

#reverse

"hello".reverse  #=> "olleh"

#split

"hello world".split  #=> ["hello", "world"]

"hello".split("")    #=> ["h", "e", "l", "l", "o"]

#strip

" hello, world   ".strip  #=> "hello, world"

More examples

"he77o".sub("7", "l")           #=> "hel7o"

"he77o".gsub("7", "l")          #=> "hello"

"hello".insert(-1, " dude")     #=> "hello dude"

"hello world".delete("l")       #=> "heo word"

"!".prepend("hello, ", "world") #=> "hello, world!"

Converting other objects to strings

Using the to_s method, you can convert pretty much anything to a string. Here are some examples:

2.to_s        #=> "2"

nil.to_s      #=> ""

:symbol.to_s  #=> "symbol"

Symbols

Create a Symbol

To create a symbol, simply put a colon at the beginning of some text:

:my_symbol

Booleans

True and False

true represents something that is true, and false represents something that is false.

Nil

nil represents “nothing”. Everything in Ruby has a return value. When a piece of code doesn’t have anything to return, it will return nil.

Basic Data Structures

Arrays

An array is used to organize information into an ordered list. In Ruby, an array literal is denoted by square brackets [ ].

irb :001 > [1, 2, 3, 4, 5]
=> [1, 2, 3, 4, 5]

Hashes

A hash, sometimes referred to as a dictionary, is a set of key-value pairs. Hash literals are represented with curly braces { }. A key-value pair is an association where a key is assigned a specific value. A hash consists of a key, usually represented by a symbol, that points to a value (denoted using a =>) of any type of data.

irb :001 > {:dog => 'barks'}
=> {:dog => 'barks'}

Variables

How to Name Variables

Always code as if the person who ends up maintaining your code will be a violent psychopath who knows where you live.

# bad
a = 19
string = "John"

# good
age = 19
name = "John"
can_swim = false

Getting Data from a User

One way to get information from the user is to call the gets method. gets stands for "get string".

irb :001 > name = gets
Bob
=> "Bob\n"

The \n at the end is the "newline" character and represents the enter key. We'll use chomp chained to gets to get rid of that.

irb :001 > name = gets.chomp
Bob
=> "Bob"

Variable Scope

Variable Scope and Blocks

Inner scope can access variables initialized in an outer scope, but not vice versa.

# scope.rb 
a = 5 # variable is initialized in the outer scope 
3.times do |n| # method invocation with a block 
    a = 3 # is a accessible here, in an inner scope? 
end 

puts a

Types of Variables

Constant:

MY_CONSTANT = 'I am available throughout your app.'

Global variable:

$var = 'I am also available throughout your app.'

Class variable:

@@instances = 0

Instance variable:

@var = 'I am available throughout the current instance of this class.'

Local variable:

var = 'I must be passed around to cross scope boundaries.'

Introdução ao Ruby

Augusto Kato — Wed, 16 Aug 2023 02:57:47 +0000

Principais ferramentas para trabalhar com o Ruby:
-Um bom editor de texto, o livro ("Ruby For Begginers do Ruby Monstas") recomenda o Sublime Text, porém o curso que estou fazendo começou com o VSCode, então estarei usando o VSCode até o final. A indentação sugerida é de 2 espaços, diferente do Python que era 4.
-Terminal, o livro deu uma revisada nos comandos básicos, como cd e ls, e deu a dica de usar o tab para autocompletar o nome do arquivo/pasta.
-Ruby Runtime, um programa que serve basicamente para executar os códigos Ruby no shell.

Fluxo de trabalho da programação

Quando for escrever qualquer programa, criar o hábito de fazer o seguinte processo:

Escrever o código no editor de texto.
Salvar em um arquivo numa pasta específica. O arquivo deve terminar com .rb.
Abrir o terminal, navegar para a pasta usando o cd e executar o arquivo usando ruby.
Ir repetindo esse processo, mudando entre o editor de texto e o terminal.

Interactive Ruby

Junto com o Ruby Runtime, vem o irb, que significa Interactive Ruby Shell, e ele serve para executar códigos Ruby diretamente do Shell. Para iniciar o irb basta apenas digitar irb, e para sair basta digitar exit, ou apertar ctrl+d .

Estilizando o Ruby

Seguindo o livro Introduction to Programming with Ruby da Launch School, é apresentada as convenções do Ruby:

O tab é de 2 espaços;
Frases depois de # são comentários;
A formatação de nomes de variáveis, funções e arquivos seguem o padrão snake_case.

# Nomeando um arquivo
isso_e_um_arquivo_em_snake_case.rb

# Declarando uma variável
quarenta_e_dois = 42

# Definindo um método
def isso_e_um_bom_metodo
  # faça algo
end

Declarações de variáveis constantes são com LETRAS_MAIÚSCULAS.
Ao trabalhar com blocos do/end, prefira usar { } quando toda a expressão do código couber numa linha.

# Linhas múltiplas
[1, 2, 3].each do |i| 
    # faça algo 
end 

# Faz a mesma coisa numa única linha 
[1, 2, 3].each { |i| faca_algo }

Para nomear classes utiliza-se o PascalCase, ou upper CamelCase

# Nomeando classes
class MinhaPrimeiraClasse
end

class MinhaSegundaClasse
end

Documentação

Nome da classe ou nome do módulo

O nome da classe é referenciado usando :: .

Métodos

:: É utilizado quando se refere a um método de classe.
# É utilizado com métodos de instância.

No código, :: serve como espaço de nome, e # é usado para fazer comentários.

3 coisas mais importantes a se lembrar quando se lê a documentação Ruby:

A classe ou módulo que está vendo.
Os seus métodos de classe disponíveis.
Os seus métodos de instância disponíveis - e como utilizar esses métodos.

Debugar código Ruby usando Pry

Pry é uma biblioteca Ruby, uma de suas capacidades é a de debugar o código. Para fazer isso, basta instalar ele primeiro:

gem install pry

Usando o pry:

Temos que require "pry" e inserir um binding.pry no arquivo:

# preparation.rb
require "pry"

a = [1, 2, 3]
a << 4
binding.pry     # execução para aqui, permitindo verificar todos os objetos
puts a

Depois para continuar a execução do programa é só apertar Ctrl+D.

Carregando um arquivo no irb:

irb -r ./seu_arquivo.rb