Problema Inicial:

Devemos criar um  método que seja capaz de percorrer um array, exibindo seus elementos. (Ok, tudo bem nós sabemos que todo array possui um método each. Mas vamos fingir que esse kra não existe)

lista = ["sergio","roberto", "iuri","luiz"]
def mostra_elementos( array )
  for elemento in array
    puts elemento
  end
end
mostra_elementos(lista)

Ótimo! Atingimos nosso objetivo. O codigo acima exibira os nomes contidos no array.

Os requisitos mudaram:

Agora nós queremos  percorrer o array exibindo cada um de seus elementos ao contrario, por exemplo, "sergio" será exibido como "oigres". Podemos criar um novo método para isso, então vamos ao trabalho:

<span id="more-451"></span>def mostra_elementos_ao_contrario( array )
  for elemento in array
    puts elemento.reverse
  end
end
mostra_elementos_ao_contrario( lista )

Perfeito! Mais uma vez concluímos nossa tarefa.

DRY, mais um princípio de Desenvolvimento de Software:

Os problemas anteriores envolviam operações com elementos de um array (uma lista), e assim acabamos criando dois métodos para resolver os problemas propostos. Existe um princípio de desenvolvimento de software que é focado em reduzir a repetição/duplicação de código, ele é conhecido como: Don't Repeat Yourself - (DRY). Este principio diz que:

"Every piece of knowledge must have a single, unambiguous, authoritative representation within a system."

O que poderiamos traduzir como: "Cada parte do conhecimento deve ter uma representação única e não ambigua dentro de um sistema". Desta forma utilizando o DRY para analisar as funções que escrevemos até agora, podemos notar que a parte do conhecimento de percorrer um array não possui uma representação única em nosso sistema. O ideal seria que o codigo de percorrer um array nao fosse mais repetido, e é exatamente nisso que vamos trabalhar agora.

Aplicando o DRY

A maneira mais simples de resolvemos o problema de duplicação do codigo de percorrer o array, é sem duvida realizar um refactor chamado extract method, e assim isolar a lógica de percorrer arrays em um método. Entao vamos lá:

def percorre_array( array )
  for elemento in array
 
  end
end
def mostra_elementos( array )
   percorre_array( array)
   puts elemento
end
def mostra_elementos_ao_contrario( array )
  percorre_array(array)
  puts elemento.reverse
end
lista = ["sergio","roberto", "iuri","luiz"]
mostra_elementos(lista)
mostra_elementos_ao_contrario(lista)

Pronto! Com este método que acabamos de criar eliminamos o problema de  repetição de código. Porém ao executar este programa receberemos uma mensagem de erro. O grande problema aqui é que agora os métodos mostra_elementos e mostra_elementos_ao_contrario não conseguem mais acessar cada elemento do array. Estes métodos agora usam a função percorre_array, e somente dentro desta função é que a variavel elemento existe. Neste ponto podemos pensar que, ou fazemos a coisa ficar DRY, ou fazemos o programa funcionar. Calma, com Ruby nos poderemos fazer isso funcionar e ainda ser DRY. Para isso só precisamos aprender a usar os famosos blocos do Ruby.

Ruby block's

Com certeza você já ouviu, que tudo em ruby é objeto. Na verdade mesmo, quase tudo em Ruby é objeto, por exemplo blocos de código não são objetos. Mas o importante é  que  em Ruby podemos armazenar trechos de código em um objeto especial que se chama Proc. Veja:

bloco = Proc.new { puts "sou um bloco de codigo" }
bloco.call

Acabamos de criar um objeto, que contem código, e fizemos isso utilizando Proc.new e fornecendo o código através das chaves  "{ }". De posse de uma Proc, podemos executar o código que ela contem a qualquer momento. Basta pra isso usar o método call da Proc. No exemplo acima ao chamar bloco.call veremos o texto sou um bloco de codigo. O interessante disso é que agora podemos passar código como parametro, veja um exemplo:

def faco_o_que_mandar( block )
  block.call
end
bloco = Proc.new {puts "sou um bloco de codigo"}
faco_o_que_mandar(bloco)
faco_o_que_mandar Proc.new{puts "Mais um bloco"}

Mas podemos fazer como os rubistas fazem na maioria das vezes. Eles chamam a função e passam o bloco como parametro, para isso precisamos fazer uma pequena alteração em nossa função, basta colocar um & a frente do nome do nosso parametro. Outra coisa é que geralmente os rubistas utilizam a plavara yield ao invés de coisas como bloco.call, vamos mudar isso também:

def faco_o_que_mandar( &block )
  yield
end
faco_o_que_mandar {puts "sou um bloco de codigo tipo rubista"}
faco_o_que_mandar do
  puts "blocos do end sao usados quando vc quer"
  puts "fazer coisas que precisem de mais de uma"
  puts "linha =)"
end

O grande barato é que agora escrevemos uma função que recebe e executa um código "visitante". Este é um recurso muito poderoso, e é graças a ele que vamos conseguir resolver o problema de percorrer um array para fazer coisas diferentes com seus elementos, sem precisar repetir código.

Tirando vantagem dos blocos

Bem, nós já temos uma função que sabe andar em um array. Agora só precisamos fazer esta função receber um bloco de código "visitante" e assim teremos tudo resolvido. Vamos então ao trabalho:

def percorre_array( array, &block )
  for elemento in array
    yield
  end
end
lista = ["sergio","roberto", "iuri","luiz"]
percorre_array(lista) { puts elemento }
percorre_array(lista) { puts elemento.reverse }

Neste momento você pode estar se perguntando o porquê do bloco de código estar fora dos parênteses. Por mais estranho que possa parecer é desse jeito que funciona mesmo. Os blocos são informados depois dos parametros "convencionais".

Agora seria ótimo se isso funcionasse, não é? Pena que não vai funcionar. Ao executar esse código veremos o seguinte erro: undefined local variable or method `elemento' for main:Object (NameError).

Repare no erro, ele diz que a variavel elemento não está definida. Isso aconteceu porque esta variavel é local do método percorre_array, ou seja só existe, e só é visivel naquele método. Nós precisamos manipular esta variavel, para que isto seja possível o método que possui a variavel precisa permitir que os blocos visitantes utilizem esta variavel. Fazer isso é simples, basta que no yield nos passemos a variavel em questão como parâmetro.

Quando colocamos o  yield na função é como se dissesemos: "Rode o codigo visitante agora". E quando colocamos a frente do yield parâmetros é como se dissessemos: "Ei código vistante, se você quiser pode usar estes caras aqui que eu tenho". Vejamos como fica isso no nosso codigo:

def percorre_array( array, &block )
  for elemento in array
    #agora estamos expondo a variavel elemento
    # para o codigo visitante
    yield elemento
  end
end
lista = ["sergio","roberto", "iuri","luiz"]
# uma pequena alteracao é necessaria aqui
percorre_array(lista) { |elemento| puts elemento }
percorre_array(lista) do |elemento|
  puts elemento.reverse
end

Agora sim o código funciona. A linha yield elemento, tem o efeito de enviar para o bloco visitante a variavel elemento como parametro. Assim a cada iteracao do loop for um novo valor é enviado ao código visitante através da variavel elemento. Com isso nosso trabalho está terminado, implementamos as funcionalidades solicitadas, sem repetir código, e de quebra aprendemos sobre DRY e blocos de código em Ruby.

Bloco de código é um assunto bem interessante, e aqui nós abordamos só uma pequena parte. Tem ainda um lance de lambdas, enfim como disse antes o assunto é muito interessante, e se você quiser saber mais pode olhar um post do Anderson Leite sobre isso, o link é este.

Abraços.

Acho que agora as coisas começam a ficar mais divertidas

Não é minha intenção, ficar explicando cada classe básica do Ruby, acho que mais importante focarmos no conceito da linguagem, acredito que a melhor forma de aprender a programar é praticando, por tanto vou usar alguns exemplos utilizando funcionalidades da String e do Array, para explicar os conceitos e ao mesmo tempo mostrar como é produtivo programar em Ruby.

Para entender os recursos de cada classe, basta olhar a documentação do Ruby que é bem abrangente.

Vamos ver alguns exemplos, de como podemos concatenar valores em uma string:

variavel = "um dois tres"
variavel = variavel+" quatro cinco seis"
 
#pode ser assim também
variavel = "um dois tres"
variavel += " quatro cinco seis"
 
#Também podemos fazer assim
variavel = "um dois tres"
variavel.concat(" quatro cinco seis")
 
#ou melho ainda, esse é muito maneiro, o código fica claro!
variavel = "um dois tres"
variavel << " quatro cinco seis"
#alem de claro, esse tipo de atribuição é mais rápido.

Viu por que Ruby é agil?
- Até minha mãe entende que com esse simbolo "<<" estou inserindo uma valor na String
É claro que em java temos outros modos de concatenar valores em uma String, mas provavelmente alguns deles nos obriga a instanciar alguma classe utilitária como o StringBuilder, por exemplo.

Gostou? você ainda não viu nada, olha só que F0D@! :p

Delete

#aqui eu quero remover todas as vogais de uma String
"a b c d e f g h i ".delete "aeiou"
=> "b c d f g h"
 
#podemos utilizar exceções.
#vamos remover todas as vogais, exceto a vogal "i"
"a b c d e f g h i".delete "aeiou", "^i"
=> "b c d f g h i"

Quer ver mais?

#Conversão de case
"saga do programador".upcase
=> "SAGA DO PROGRAMADOR"
"SAGA DO PROGRAMADOR".downcase
=>"saga do programador"

#olha só que maneiro:
#veja como esse código é expressivo!
"saga do programador".include? "programador"
=> true
#é esse tipo de coisa q faz a diferença
#quero saber quantos caracteres diferentes existem entre as Strings
"Iuri" <=> "Iure"
=> 1
#agora eu quero tirar caracteres duplicados de uma String
"google".tr_s("o","o")
=> "gogle"
"google".tr_s("o","")
=> ggle

Arrays:

Na boa! Quando comecei a programar, aprendi sobre Arrays com o velho Pascal, achei muito chato. Pelas dificuldades apresentandas para recuperar os dados.

Com a evolução das linguagens as coisas foram melhorando, mas definitivamente trabalhar com Arrays em linguagens dinâmicas, supera as expectativas!

Vamos aos exemplos:

#Criando uma array em Ruby:
meuArray = [“um”, “dois”,3]
=> [“um”,”dois”,3]
#Sim é isso mesmo! Eu posso ter tipos diferentes dentro do mesmo Array

Olha com as coisas ficam ainda mais legais, quando nos aproveitamos das facilidades que a linguagem Ruby nos proporciona com o conceito de blocos:

meuArray = Array.new(2) {1}
=> [1,1]

Alguma vez você imaginou preencher um Array de maneira tão simples, como no exemplo abaixo:

meuArray = Array.new(5) {|n| n+1}
=> [1,2,3,4,5]

No post anterior eu finalizei com a seguinte pergunta:
Tenho uma String com seguinte valor “um dois tres quatro cinco”, como você faria em uma linguagem chata para transformar essa String em um array contendo cinco itens?

Bom, existe N maneires de fazer isso em N linguagens, meu exemplo de linguagem chata, será em delphi, vamos a roubada rs.. :

//Para facilitar, ao invés de utilizar um Array, vou usar a classe TStringList.
Var
  valor: String;
  listaValor: TStringList;
begin
  valor := 'um dois tres quatro cinco';
  listaValor := TStringList.Create;
  valor := StringReplace(valor,' ',',',[rfReplaceAll]);
  listaValor.CommaText := valor;
end;

Agora em Ruby:

#Preste atenção como é complexo rs...
meuArray = %w(um dois tres quatro cinco)
=> [“um”,”dois”,”tres”,”quatro”,”cinco”]

Outros exemplos:

#Sim! O operador "<<" também funciona para o Array
 
meuArray = [1]
=> [1]
meuArray << 2
=> [1,2]

No incio desse topico sobre arrays, comentei que um dos grandes problemas de trabalhar com Arrays nas linguagens chatas, e a dificuldade para manipular os dados, vamos ver agora uma pequena amostra, das facilidades que o Ruby nos oferece para trabalhar com isso:

meuArray = [1,2,3,4,5]
=> [1,2,3,4,5]
 
#Retornar só os numero pares, mais uma vez vou me prevalecer do conceito de blocos.
 
arrayPares = meuArray.select{ |valor| valor%2==0 }
=> [2,4]

Bom, por enquanto é só!
Acho que agora as coisas estão ficando mais com a cara do Ruby, pois deixamos de lado o bla bla e passamos para a pratica, algo mais produtivo, talvez você ainda não tenha notado, mas nesse post conseguimos trabalhar bastante um otimo conceito do Ruby que são os blocos. A intenção daqui para frente é utilizar exemplos de códigos, para expressar os conceitos das funcionalidades que essa maravilhosa linguagem nos proporciona

Até a próxima!

Iuri Menescal