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:

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.

Estrutura

O Método em Ruby é declarado da seguinte forma:

def nomeDoMetodo
   #código
end

Só isso?
Não tenho que dizer o que ele retorna?
Ou dizer que ele não retorna nada “void” ?
É isso mesmo, no Ruby você não precisa definir o que o seu método retorna, também não temos obrigação de utilizar “return” o nosso método sempre vai retornar o ultimo valor atribuído.
É tão simples que deve ter ficado difícil de você visualizar:). Vamos ver um exemplo:

# criando um método chamado teste
def teste
  valor = 1
end
#chamando esse método
teste
=> 1

Parâmetros

O modo de passar parâmetros para um método em Ruby, é quase parecido com o das linguagens chatas:

 def nomeDoMetodo(parametro1,parametro2)
    valor = parametro1 + parametro2
 end

Ok! a similaridade com as linguagens chatas para por aqui.
Uma das coias legais de se trabalhar com uma linguagem dinamica é essa, note que não precisamos definir tipos para o parâmetro, isso nos da uma grande flexibilidade!
Você não acha?
Não!? e se eu disser para você que a flexibilidade não se limita a isso, e se eu disser que podemos também, passar um numero indeterminado de parâmetros para o nosso método?
você não acredita? vamos ver um exemplo então:

  # note como declaro o parâmetro no método
  def teste(*parametros)
    parametros.each { |parametro| puts parametro }
  end
  #chamando o método
  teste(1,2,3)
  1
  2
  3
  => [1,2,3]

Para finalizar esse post, vou dar um exemplo que os programadores Delphi vão adorar.

Caramba senti muita falta disso, quando comecei a programar em Java

Nos métodos em Ruby é possivel definir um valor default para o parâmetro. Heeeee!!!

  def teste(parametro="Não foi passado nenhum valor")
    parametro
  end
  teste("novo valor")
  => novo valor
  teste
  => Não foi passado nehum valor

pode falar… agora eu consegui te impressionar!

Por enquanto vamos ficar por aqui, mas ainda temos muito para ver sobre métodos em Ruby.
Aguardem o próximo post.

Abraço!

Iuri Menescal

Mas depois de publicar o último post, tive um retorno tão bom que fiquei empolgado em escrever outro logo .
Alem disso, fiquei com uma sensação de que estava faltando alguma coisa, como disse antes o foco não é mostrar os métodos de cada classe do Ruby, mas o Array em Ruby é tão maneiro que eu tinha que mostrar mais algumas coisas legais.

No post anterior eu disse que uma das coisas que me desanimou no Array, quando comecei a programar, era a dificuldade de recuperar os dados, então aqui vai mais alguns exemplos de como o Ruby resolve esse problema:

Ordenação

1
2
3
4
5
6
7

#o método sort ordena os valores em ordem alfabética
meuArray = %w(Alagoas Rio\ de\ Janeiro Brasília) 
=> ["Alagoas","Rio de Janeiro","Brasilia"]
#presto atenção na "\" para escrever algo com espaço dentro do mesmo item do array?
#agora vamos ordenar por nome
meuArray.sort
=> ["Alagoas","Brasilia","Rio de Janeiro"]

Grande coisa o exemplo acima, qual é a linguagem que não faz isso, né?
Então, vamos jogar um pouco do pó mágico do Ruby e deixar o próximo exemplo mais atraente.

1
2
3
4
5
6
7
8
9

meuArray = ["Alagoas","Brasilia","Rio de Janeiro"]
=> ["Alagoas","Brasilia","Rio de Janeiro"]
#olha o que podemos fazer acrescentando um bloco no final
#vamos ordenar ao contrario agora 
#mas lembre-se que você pode passar N condições 
#pois estamos trabalhando com blocos!
 
meuArray.sort {|x,y| y <=> x}
=> ["Rio de Janeiro", "Brasília", "Alagoas"]

Pesquisa

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

estados = ["RJ","MG","SP"]
=> ["RJ","MG","SP"]
#Quero confirmar se nesse Array 
#realmente existe o estado "Rio de Janeiro"
estados.include?("RJ")
=> true
 
#Agora queremos saber se algum item do meu array possui a letra "S"
estados.any? { |item| item.include?("S") }
=> true
#e se eu quiser saber se todos os itens do meu array possui a letra "S"?
#simples!
estados.all? { |item| item.include?("S") }
=> false
 
#quero separar do meu array os estados com letra "S"
estadosComS, estadosSemS = estados.partition { |item| item.include("S") }
estadosComS
=> ["SP"]
estadosSemS
=> ["RJ","MG"]

Olha só que linguagem linda! Notem a expressividade desse código: “include?”
Eu quero saber se o meu array de estados contem o estado “RJ”. Se eu quero saber algo sobre o meu array, eu tenho que perguntar para ele e uma pergunta deve terminar com interrogação, então: estados.include?(“RJ”).

Pode falar… da vontade de congelar esse projeto, que você ta desenvolvendo ai na sua empresa e reescreve tudo em Ruby, não é? rs…

Mais uma vez utilizei bastante o conceito de blocos, que é um dos grandes baratos do Ruby.

Logo irão surgir outros conceitos que vão me obrigar a ter a mesma postura, no próximo post vamos ver um pouco sobre lambdas, que é um outro recurso bem bacana.
É importante fixar bem esses conceitos para programadores que vem de linguagens como Java, Delphi, C#, pois é mais difícil se acostumar com algo tão fora do trivial do seu dia a dia, é importante isso ficar na “veia”, para que você consiga lembrar de utilizar esses tipos de recursos quando precisar. Tenho certeza que isso vai facilitar muito a sua vida quando estiver programando em Ruby.

Acho que agora deu para fechar com chave de ouro o nosso estudo sobre arrays.

Até a próxima!

Iuri

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

Eu sei que não é um assunto muito empolgante, ou melhor não é muito “Ruby” (ou seja Dinamico, Agil, Divertido), mas para ter um bom entendimento temos que consolidar os fundamentos.
“Espero que o Luiz não leia isto rs.. “piada interna” hehe!”

Mas logo logo vamos entrar na parte legal, pense nessa fase como o primeiro periodo da faculdade, só que com mais serventia

Como falei anteriormente tudo em Ruby é objeto. Variaveis são apenas referencias para objetos e bla bla bla bla…

Vamos ver mais alguns exemplos:

Viu? o valor1 ficou com o mesmo valor2, isso por que as duas variáveis são referencias para o mesmo objeto.
Note que eu alterei a variável “Var2[5] = 2″ ao invés de atribuir um outro valor para ela “var2 = valor2″, nesse ultimo caso eu estaria atribuindo um novo objeto String para a variável var2.
Mas isso você já sabia né? hum… Você lembra de todo aquela papo de linguagem dinâmica e tipagem forte do primeiro post? Não? putz.. seu fanfarrão! da uma olhada lá novamente: post1

Existem métodos que nos ajudam a manipular variáveis, como o método freeze que congela a variável e não permite que ela seja alterada.

Outro método legal é o método dup:

variavel1 = "Valor1"
variavel2 = variavel1.dup

Esse método deveria ser usado no exemplo anterior, para impedir que as duas variáveis ficassem com a mesma referencia.

Operadores

Grande parte dos operadores são métodos e podem ser alterados.

+,-,*	adição,subtração,multiplicação
/,%	divisão,resto
**	Expoente
&	AND binario
^ ou |	OR binario
>,>=,<,<=	maior, maior ou igual, menor, menor ou igual
<=>,==,===,!=, =~, !~	Operadores de igualdade, você vai entender melhor nos próximos post`s
=, %=, -=, +=, /=,*=,**=, ||=, &&=, <<,	Atribuição
Lógicos
&&	AND
||	OR
.. e …	Ranges
? :	If Then else “Adoro esse ”
not	negação
or e and	composição

Durante nosso aprendizado, vamos ter oportunidade de ver mais detalhes de alguns operadores.
Ai você vai começar a entender por quê programar em ruby é tão legal

Só para deixar esse post menos chato, vamos ver um exemplo:

#só quero atribuir um valor quando a variável for nil
variavel = 1
=> 1
variavel ||= 2
=> 1
variavel = nil
=> nil
variavel ||= 2
=> 2
#agora o oposto
variavel = 1
=> 1
variavel &&= 2
=> 2
variavel = nil
=> nil
variavel &&= 1
=> nil

Por enquanto é só, tenho certeza que já no próximo post, as coisas vão ficar mais empolgantes, ainda essa semana vou publicar a terceira parte aonde vamos ver alguns detalhes da classe String.
Não deixe de continuar acompanhando, agora já passamos pela pior parte, o que vem pela frente é só diversão tenho certeza que do decorrer dos exemplos que estão por vir você vai dizer algumas vezes “Caramba! que f0d@!!” :p

Fica aqui uma charada para o próximo post:

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?

Abraço!

Iuri Menescal
Diga não as drogas, não use IE!