Exercitando com Ruby Parte 3 (Iteradores, Sub-rotinas)

O Ruby usa essa idéia: "a forma que escrevemos, é a forma que lemos", tornando o código mais compreensível possível. O Tutorial de hoje é bem interessante pelo motivo de desbravar varias funções úteis que o Ruby pode trazer.

Iteradores

A cada dia que passa tenho mais vontade de buscar material, e conhecer essa poderosa linguagem, como é o caso dos métodos Iteradores, ele funciona percorrendo um vetor e retorna um valor, executando um determinado procedimento, existem vários, irei mostrar alguns legais.

1. Iterador EACH: retorna todos os elementos de um array ou hash;
   

   vetor = [1,3,9,2]
   vetor.each { |valor| puts "numero = #{valor}"}
   =>numero = 1
   =>numero = 3
   =>numero = 9
   =>numero = 2

2. Iterador SELECT: seleção de alguns elementos. Note que estou usando inserção manual de elementos com os colchetes, para usar os ranges use os parenteses com os intervalos;
   

   [1,2,3,4,5].select {|v| v>2}.each {|v| puts v}
   =>3
   =>4
   =>5

3. Iterador REJECT:  rejeita seleção de elementos;
   

   (1..7).reject { |v| v > 2}.each {|v| puts v}
   =>1
   =>2

4. Iterador MAP: altera valor dos elementos;
   

   (1..5).map { |v| v * 2}.each {|v| puts v}
   =>2
   =>4
   =>6
   =>8
   =>10

5. Iterador ANY: verifica se existe alguma coisa. OBS: método boolean {true ou false};

(0..10).any? {|v| v==3}
=>true

6. Iterador INCLUDE: a mesma forma que o ANY, verifica se existe algum elemento;
   

   (0..10).include?(3)
   =>true

7. Iterador DETECT: literalmente atende a chamada como uma detecção de algum elemento;
   

   (0..10).detect {|v| v==5}
   =>5

8. Iterador INJECT: acumulando valores;
   

   (0..10).inject {|soma,valor| soma+valor}
   =>55

Sub-rotinas
Lembrando que existem dois tipos de sub-rotina, elas são classificadas como um procedimento que não retorna nada, somente uma chamada, ou uma função que pelo contrário retorna algo. Para escrever uma sub-rotina em Ruby usamos o bloco iniciando em def e terminando em end

1. Procedimento: um tipo de rotina básica:

def eu
 puts 'Darlan Dieterich'
end
eu
=>Darlan Dieterich

2. Função: note que não há nenhum tipo de return, pois a ultima opção a ser avaliada é a que retorna, mas se quiser pode usar return também que irá retornar:
   

   def operacao(a,b)
    a+b
   end
   puts operacao(2,6)
   =>8
   

3. Função com retorno padrão:
   

   def funcao(valor='padrao')
    "aqui o valor sera #{valor}"
   end
   puts funcao()
   puts funcao('trocado')
   =>aqui o valor sera padrao
   =>aqui o valor sera trocado

4. Função com passagem de código para execução (genial isso!), para essa ocasião usamos o yield dentro do bloco. Nesse exemplo criei uma função com retorno do resto da divisão usando o operador %:

   def funcao(opcao)
    yield (opcao)
   end
   funcao(3) {|v| puts v%2}
   =>1

autor: Darlan Dieterich