# Incrementa 1 a cada elemento da array

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

arr.each do |element|
    element += 1
end

#=> [2,3,4,5,6]


# One line each

arr.each { |element| element +=1 }

#=> [3,4,5,6,7]

# Incrementa 1 a cada elemento da array, exceto do 3º

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

arr.each_with_index do |element, index|
    unless index == 2
        element += 1
    end
end

#=> [2,3,3,5,6]


# One line each

arr..each_with_index { |element, index| element +=1 unless index == 2 }

#=> [3,4,3,6,7]

# Cria uma nova array de números elevados ao quadrado

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

sqr = arr.map do |element|
    return element * element
end

#=> arr = [1,2,3,4,5]
#=> sqr = [1,4,9,16,25]


# Sobrescreve a array por números elevados ao quadrado

arr.map! { |element| element * element }

#=> arr = [1,4,9,16,25]

# Retorna uma array apenas de números pares

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

arr.select do |element|
    element % 2 == 0
end

#=> [2,4]

# Retorna uma array apenas de números ímpares

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


arr.reject { |element| element % 2 == 0 }


#=> [1,3,5]

# Bloco de múltiplas linhas

do |var|
    return var * var
end

# Bloco de uma linha


{ |var| var * var }

# Bloco de múltiplas linhas 
# aplicado ao each

arr.each do |element|
    element += 1
end

# Bloco de uma linha
# Aplicado ao map


arr.map{ |element| element * element }

# defina seu método. Quando quiser executar o bloco,
# utilize a keyword yield

def timer
    puts "Vamos começar"
    start = Time.now
    yield                                             #=> executa o bloco!
    end = Time.now
    puts "O bloco demorou #{start - end}s pra executar."
end


# Ao chamar seu método, passe um bloco

timer() do
    puts "partiu naninha"
    sleep(4)
    puts "brincadeeira"
end

# pode ser de uma linha só

timer() { sleep(1) }

# defina seu método. Quando quiser executar o bloco,
# utilize a keyword yield

def timer(nomezin)
    puts "Vamos começar"
    nomezao = name.upcase
    yield(nomezao)              #=> executa o bloco e passa um argumento!
    name2 = "Obama"
    yield(name2)                #=> executa o bloco e passa um argumento!
    puts "Pretty cool, huh?"
end


# Ao chamar seu método, passe um bloco que espera um argumento

timer("Putin") do |name|
    puts "Olá, #{name}!"
end

# pode ser de uma linha só

timer("trump") { |name| puts "#{name} já foi presidente, sabia??" }

test = [["Fantini", "BCC", 18], ["Slash", "BCC", "017"], ["Camila", "Bio", "015"]]

# Cada array dentro da array (aka 'mini_array') equivale a um aluno do test
# Cada posição da mini_array equivale a um dado específico

test << ["BCC", "015", "Goleiro"]

# Como mostrar todos os nomes???

# Hash relaciona 'keys' e 'values'. É como um dicionário

aluno = {
    nome:   'Goleiro',
    curso:  'BCC',
}

# Adicionando uma nova informação à Hash ==> hash[:key] = value
aluno[:ano] = '015'

# Lendo uma informação da hash ==> hash[:key]
aluno[:nome]     #==> 'Goleiro'

# Atualizando uma informação da hash ==> hash[:key] = value
aluno[:ano] = '019'

# Deletando uma informação da hash ==> hash.delete(:key)
aluno.delete(:curso)    #==> 'BCC'

test = [
    {nome: "Goleiro", curso: "BCC", ano: '015'}, 
    {nome: "Sofia", curso: "BCC" },
    {curso: "Bio", ano: '015'}
]

# Cada array dentro da array (aka 'mini_array') equivale a um aluno do TeSt
# Cada posição da mini_array equivale a um dado específico

test << {curso: "BCC", ano: "015", nome: "Daniel"}

# Como mostrar todos os nomes???

# O #each sobre uma hash dá 2 parâmetros ao meu bloco

aluno.each do |key, value|
    puts "O #{key} do(a) aluno(a) é #{value}"
end

# Caso queira iterar só sobre as keys...

aluno.each_key do |key|
    puts "O #{key} do(a) aluno(a) está registrado!"
end

# ...Ou só sobre os values...
aluno.each_value do |value|
    puts "O #{value} do(a) aluno(a) está registrado!"
end