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