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

Exercitando com Ruby Parte 2 (Operadores condicionais, Operadores lógicos, Laços de repetição)

Ruby é uma linguagem multiparadigma, com isso podemos desenvolver um código de diferentes formas. Hoje você aprende de uma forma, e amanhã descobre outra forma ainda melhor, principalmente se for um iniciante na linguagem, onde tudo é novidade. Irei postar no tutorial o básico, deixando de tarefa sentir-se livre em buscar mais novidades.

Lembrando que agora vai ser interessante trabalhar com uma IDE para escrever o código e se tornar mais produtivo. Sinta-se livre para escolher! existem muitas ferramentas boas e gratuitas na internet como Notepad++, Geany, NetBeans, Eclipse entre outras...se você chegou até aqui deve saber muito bem, com o que trabalhar para o seu desenvolvimento, que não é o caso de nosso objetivo essa discussão.

• Primeiro, antes de tudo crie um arquivo dentro de seu diretório favorito onde iremos trabalhar (ex: C:\testes\codigo.rb), lembrando que a extensão de Ruby é .rb;
• Para executar o código abra o terminal de comando e vá para o diretório onde definiu a pasta e execute da seguinte forma "ruby codigo.rb";

Operadores condicionais
O Ruby trabalha com a instrução end no final de seu código.

1. Condição IF: como todos já sabem a estrutura básica de um IF é  { se - então - senão}. O antigo else if agora passou a ser chamado de elsif:

   z = 77
   if z > 90
    puts 'maior que 90'
   elsif z <= 90 and z >=50
    puts 'menor que 90 e maior que 50'
   else
    puts 'menor que 50'
   end
   =>menor que 90 e maior que 50

2. Outra  forma de IF:

    
   z = 100
   puts "maior que 10" if z > 10
   =>maior que 10
   
   

3. Condição CASE: no operador condicional CASE usarei uma função chamada ranges, ela funciona para você especificar um valor entre intervalos (EX: a..z, 1..10), irei abordar sobre o tema mais futuramente.

    
   z = 7;
   case z
    when 1..5
     puts "de 1 a 5"
    when 6..10
     puts "de 6 a 10"
    else
     puts "seila"
   end
   =>de 6 a 10

4. Condição UNLESS: como diria um IF ao contrário, uma condição negativa. (como ler isso? EX: tem mais espaço no trem AO MENOS QUE o numero de pessoas não ultrapasse 100), sei que parece confuso, não gostaria de utilizar isso, pois o IF é mais "humano-entendível".
   

    
   pessoas = 50
   puts "tem mais espaco no trem!" unless pessoas > 100
   =>tem mais espaco no trem!
   
   

Operadores lógicos
Os operadores de lógica não mudaram, continuam o mesmo para quem trabalhou em C, PHP

Operador	Descrição
or, ||	Verdadeiro se A ou B são verdadeiros.
and, &&	Verdadeiro se tanto A quanto B são verdadeiros.
not, !	Verdadeiro se A não é verdadeiro

Laços de repetição
Nunca vi em nenhuma outra linguagem que conheço, existir tantas formas de laços de repetição, vou postar todas que conheço pois isso é bem útil:

1. FOR: laço de repetição de valor A até B usango ranges;

 
for z in (1..5)  
 puts z
end
=>1
=>2
=>3
=>4
=>5

2. FOR com break: sai da execução do script

 
x=10
for z in (1..x)
 break if z == 4
 puts z
end
=>1
=>2
=>3

3. FOR com next: pula para próxima condição, e anula a determinada condição

 
for z in (1..6)
 next if z == 3
 puts z
end
=>1
=>2
=>4
=>5
=>6

4. FOR com redo: repete o laço caso tenha encontrado algo;
   

   for z in (1..9)
    redo if z == 5
    puts z
   end
   =>1
   =>2
   =>3
   =>4

5. UNTIL: faça até que;

 
z = 1;
until z==4
 puts z
 z+=1
end
=>1
=>2
=>3

6. WHILE: faça enquanto; note que estou usando uma concatenação para a variável 'z' dentro do puts. Lembre-se que todo bloco de códigos fecha com end;
   

   z = 1;
   while z < 5
    puts "valor #{z}"
    z+=1
   end
   =>valor 1
   =>valor 2
   =>valor 3
   =>valor 4

7. LOOP: poderia colocar loop do e fechar com end, mas a melhor forma ficaria assim ;
   

   v = 1;
   loop {
    break if v > 4
    puts v
    v+=1
   }
   =>valor 1
   =>valor 2
   =>valor 3
   =>valor 4

8. BEGIN: é um bloco com um laço, ele pode ser usado tanto com um while como um until:
   

   z = 0
   begin
    puts z
    z += 1
   end until z == 4
   =>valor 1
   =>valor 2
   =>valor 3

9. TIMES: 
   

   z = 1
   4.times do 
    puts z
    z+=1 
   end
   =>valor 1
   =>valor 2
   =>valor 3
   =>valor 4

10. UPTO:
    

    1.upto(4) do |valor|
     puts valor
    end
    =>valor 1
    =>valor 2
    =>valor 3
    =>valor 4

11. UPTO mais compacto (isso é genial!!):

    1.upto(4) { |valor| puts valor}
    =>valor 1
    =>valor 2
    =>valor 3
    =>valor 4

autor: Darlan Dieterich

Exercitando com Ruby Parte 1 (Olá mundo, Operadores aritméticos, Strings, Arrays)

Antes de colocarmos a mão na massa com o Framework Rails é mega interessante aprender a linguagem base Ruby, assim terá mais facilidade no decorrer do desenvolvimento.
Agora tudo funcionando, é hora de praticar. Iremos iniciar neste artigo um passo a passo no Ruby de alguns exemplos como o clássico "Olá mundo!" até as Arrays. A continuação irá se estendendo no decorrer do meu tempo vago! Vamos lá! Sem enrolação!

Principio

1. Abra o terminal do Ruby conhecido como IRB (Interactive Ruby);
2. Existem duas formas: abra através do executar com o comando "irb" e de um enter, ou acesse o seu menu iniciar o procure por Ruby.... e abra o seu "Interactive Ruby";
3. Irá aparecer o terminal IRB;

Olá mundo

1. Como toda linguagem existe um comando de saída, no Ruby é utilizado "puts" ou "p", então nosso primeiro exemplo ficaria:
   

   puts "Olá mundo!"
   Olá mundo
   => nil

   Apos executar vera que irá exibir o "Olá mundo!" e também será retornado um "=> nil" que seria um objeto NULL;
2. Como comentei no blog em outro post, todas variáveis são objetos.

Operações aritméticas
Basta digitar uma operação, olhem que é muito simples: 

1. Somando:
   

   2+2
   => 4

2. Multiplicando:
   

   2*3
   => 6

3. Números na potenciação: 2 na potencia de 3 como ficaria? o Ruby entende que dois asteriscos é reservado para potenciação:
   

   2**3
   => 8

4. Raiz quadrada: é preciso importar a classe Math e chamar a função "sqrt()"; ficaria assim:
   

   Math.sqrt(9)
   => 3.0

5. Se você ainda não testou a divisão verá que existe um pequena diferença no retorno, por padrão a saída virá um número inteiro em todas as operações, quando irá calcular uma operação do tipo 7 dividido por 3 verá que o retorno sera =>3
   

   7/3
   => 3

   Mas como isso? o Ruby esta doido? Não! Não criemos pânico! como comentei retorna somente números inteiros, e como faço para retornar o numero fracionário? Bom eu conheço duas formas! acredito que existam mais formas, a primeira seria colocar os números  em forma de fracionário, tipo:
   

   7.0/3.0
   => 3.5

   A outra seria mais avançada do tipo 'forçar' a conversão, importe a classe matemática: " require 'mathn' " agora aplique a operação acompanhada da função de conversão para float(fracionário):
   

   require 'mathn'
   => true
   (7/2).to_f
   => 3.5

Strings
Um conjunto de caracteres formam uma String. Vamos manipular as Strings usando funções nativas;

1. As aspas (simples ou duplas) definem uma String dando inicio e fim (abre e fecha)":
   

   'Darlan'
   => "Darlan"

2. Reverter a String:
   

   'Darlan'.reverse
   => "nalraD"

3. Tamanho String:
   

   'Darlan'.length
   => 6

4. Replicar String:
   

   'Darlan' * 3
   => "DarlanDarlanDarlan"

5. Converter inteiro para String:
   

   123.to_s.reverse
   => 321

6. Outra forma de converter:
   

   %q(Darlan Dieterich)
   => "Darlan Dieterich"

7. De novo:
   

   %|Darlan Dieterich|
   => "Darlan Dieterich"

8. Concatenar
   

   nome = 'Darlan' 'Dieterich' 
   => "DarlanDieterich"

9. Outra forma de concatenação
   

   nome = 'Darlan' 
   => "Darlan"
   sobrenome = 'Dieterich'
   => "Dieterich"
   nome << sobrenome
   => "DarlanDieterich"

Arrays
Uma coleção de referência de objetos, criadas a partir da classe Array;

1. Um array:
   

   [22,10,15]
   => [22,10,15]

2. Retornando o maior numero:
   

   [22,10,15].max
   => 22

3. Retornando o menor numero:
   

   [22,10,15].min
   => 10

4. Ordenar vetor:
   

   [22,10,15].sort
   => [10,15,22]

5. Array com somente Strings:
   

   z = %w(darlan dieterich)
   =>["darlan" , "dieterich"]

6. Inserindo elementos:
   

   z = [ ]
   =>[ ]
   z << "um"
   => ["um"]
   z << "dois"
   => ["um", "dois"]

7. Preenchendo array de forma bizarra usando potenciação de acordo com a posição do vetor (0x0=0, 1x1=1, 2x2=4, 3x3=9, 4x4=16):
   

   Array.new(5){ |i| i**2}
   => [0,1,4,9,16]

Isso que foi mostrado agora é uma pequena parte do que o Ruby pode fazer, pois existe muitos exemplos a serem mostrados. No próximo post irei mostrar mais exemplos...

Autor: Darlan Dieterich