Introdução
Este é um pequeno tutorial de Ruby que não deverá demorar mais de 20 minutos a completar. Assume-se á partida que já tem o Ruby instalado. (Se não tem o Ruby no seu computador, faça o download e instale-o antes de começar.)Ruby Interactivo
Abrir o IRB.- Se está a usar Mac OS X abra o
Terminal, escrevairb, e depois pressione a tecla enter. - Se está a usar Linux, abra uma shell e escreva
irb, seguido de enter. - Se está a usar Windows, abra
fxria partir do atalho para o Ruby no seu menu Iniciar.
irb(main):001:0>Escreva isto:
"Ola Mundo"irb(main):001:0> "Ola Mundo"
=> "Ola Mundo"O Ruby obedeceu-lhe!
O que é que sucedeu? Será que acabamos de escrever o mais pequeno programa «Olá mundo»? Não exactamente, a segunda linha é a forma de o IRB nos dizer qual o resultado da última expressão que avaliou. Se desejarmos imprimir «Ola Mundo» necessitamos de um pouco mais:irb(main):002:0> puts "Ola Mundo"
Ola Mundo
=> nilputs é o comando básico para imprimir algo em Ruby. Mas então o que é aquele => nil ? É o resultado da expressão. puts retorna sempre nil, o que em Ruby é o valor que representa o nada absoluto.Uma Máquina Calculadora gratuita
Já temos neste momento conhecimento suficiente para utilizar o IRB como uma calculadora básica:irb(main):003:0> 3+2
=> 53+2. Se tal suceder, use a tecla da seta para a esquerda para mover o cursor para a frente do sinal de mais + e depois use a tecla de backspace para mudar o sinal para *.irb(main):004:0> 3*2
=> 6irb(main):005:0> 3**2
=> 9** é a forma de dizer potência de. Mas o que acontece quando queremos saber o inverso disto ou seja a raiz quadrada de algo?irb(main):006:0> Math.sqrt(9)
=> 3.0Math?Módulos, Agrupar Código por Tópico
Math é um módulo nativo para funções matemáticas. Os módulos têm dois papeis em Ruby. Este é um desses papeis: agrupar métodos semelhantes em conjunto sobre um nome familiar. Math também contém métodos como sin() e tan().Depois segue-se um ponto final. O que faz o ponto? O ponto final é como se identifica o receptor de uma mensagem. Qual é a mensagem? Neste caso é
sqrt(9), o que significa chamar o método sqrt, uma abreviatura em língua inglesa para “square root (raiz quadrada)” com o parâmetro 9.O resultado desta chamada de método é o valor
3.0. Se repararmos bem, o resultado não é apenas 3. Mas isso deve-se ao facto da raiz quadrada de um número na maioria dos casos não ser um inteiro e, assim sendo, o método retorna sempre um número de vírgula flutuante.E se nos quisermos lembrar do resultado desta matemática toda? Podemos atribuir o resultado a uma variável.
irb(main):007:0> a = 3 ** 2
=> 9
irb(main):008:0> b = 4 ** 2
=> 16
irb(main):009:0> Math.sqrt(a+b)
=> 5.0Ola Mundo que os guias de iniciação normalmente focam…E se quisermos dizer “Olá” varias vezes sem cansar os dedos? Temos que definir um método!
irb(main):010:0> def h
irb(main):011:1> puts "Olá Mundo!"
irb(main):012:1> end
=> nildef h começa a definição do método. Diz ao Ruby que estamos a definir um método, cujo nome é h. A linha seguinte é o corpo do método, a mesma frase que vimos antes: puts "Olá Mundo". Finalmente, a última linha end diz ao Ruby que terminámos a definição do método. A resposta do Ruby => nil diz-nos que sabe que terminamos a definição do método.As Breves e Repetitivas Vidas de um Método
Agora tentemos correr o método algumas vezes:irb(main):013:0> h
Olá Mundo!
=> nil
irb(main):014:0> h()
Olá Mundo!
=> nilE se o que queremos é dizer ola a uma pessoa só, e não ao mundo inteiro? Para isso basta redifinir
h para que aceite um nome como parâmetro.irb(main):015:0> def h(nome)
irb(main):016:1> puts "Olá #{nome}!"
irb(main):017:1> end
=> nil
irb(main):018:0> h("Matz")
Olá Matz!
=> nilReservando espaços numa String
O que significa a expressão @#{nome}? É a forma de inserir alguma coisa numa string. Aquilo que se encontra entre chavetas transforma-se numa string (se já não o for) e é substituído naquele ponto da string. Podemos também usar isto para ter a certeza de que o nome de alguém se apresenta em letra maiúscula:irb(main):019:0> def h(nome = "Mundo")
irb(main):020:1> puts "Olá #{nome.capitalize}!"
irb(main):021:1> end
=> nil
irb(main):022:0> h "chris"
Olá Chris!
=> nil
irb(main):023:0> h
Olá Mundo!
=> nilMundo usado por omissão. O que isto quer dizer é que “Se o nome não for fornecido, então usamos o nome por omissão "Mundo".Evoluindo para um Anfitrião
E se quisermos criar um Anfitrião mais “sério”? Um que se lembre do nosso nome, nos dê as boas vindas e nos trate com o respeio devido? Podemos usar um objecto para esse efeito. Vamos então criar, a classe “Anfitrião”.irb(main):024:0> class Anfitriao
irb(main):025:1> def initialize(nome = "Mundo")
irb(main):026:2> @nome = nome
irb(main):027:2> end
irb(main):028:1> def diz_ola
irb(main):029:2> puts "Olá #{@nome}!"
irb(main):030:2> end
irb(main):031:1> def diz_adeus
irb(main):032:2> puts "Adeus #{@nome}, volte sempre."
irb(main):033:2> end
irb(main):034:1> end
=> nilclass. Esta define uma nova classe chamada Anfitrião e uma quantidade de métodos para essa classe. E o @nome ? É uma variável de instância e está disponível para todos os métodos da classe. Como podemos ver está a ser utilizada por diz_ola e diz_adeus.Então como é que pomos a classe Anfitrião em movimento?
Vejamos então o nosso novo programa de modo mais aprofundado, de notar que as linhas iniciais começam com um sinal de cardinal(#). Em Ruby, algo após um sinal de cardinal é considerado um comentário e ignorado pelo interpretador. A primeira linha do ficheiro é um caso especial, sob um sistema operativo do tipo Unix, isto indica á shell como executar o ficheiro. Os restantes comentários só se encontram ali para clarificação.
O nosso método
dizer_ola tornou-se um pouco mais complexo:# Dizer ola a todos
def dizer_ola
if @nomes.nil?
puts "..."
elsif @nomes.respond_to?("each")
# @nomes é uma lista de algum tipo, iterar!
@nomes.each do |nome|
puts "Ola #{nome}!"
end
else
puts "Ola #{@nomes}!"
end
end@nomes e toma decisões. Se for nil, só imprime três pontinhos. Não há razão para cumprimentar ninguém, certo?Ciclos e Voltas—ou seja Iterações
Se o objecto@nomes responde a each, isto significa que é algo sobre o qual se pode iterar, assim, fazemos iterações sobre o mesmo e saudamos cada pessoa à sua vez. Finalmente, se @nomes é outra coisa qualquer, deixamos que se transforme numa string automaticamente e fazemos a saudação por omissão.Vejamos o iterador com mais profundidade:
@nomes.each do |nome|
puts "Ola #{nome}!"
endeach é um método que aceita um bloco de código e que depois o executa para cada elemento numa lista, e a parte entre do e end é exactamente um bloco desses. Um bloco é como uma função anónima ou lambda. A variável entre barras verticais é o parâmetro para este bloco.O que sucede aqui é que para cada entrada na lista se associa
nome a esse elemento da lista e depois a expressão puts "Ola #{nome}!" é executada com esse nome.A generalidade das outras linguagens tratar de passar por uma lista usando o ciclo
for, que em C se assemelha a algo como:for (i=0; i<numero_de_elementos; i++)
{
fazer_algo_com(elemento[i]);
}i, temos que determinar previamente qual o tamanho da lista e temos que explicar como percorrer a lista. O modo de operar em Ruby é muito mais elegante, os trabalhos domésticos são escondidos dentro do método each, tudo o que necessitamos de lhe dizer é o que fazer com cada elemento. Internamente, o método each irá essencialmente chamar yield "Albert", depois yield "Brenda" e depois yield "Charles", e assim sucessivamente.Blocos, Uma das funcionalidades mais poderosas da Ruby
O poder real dos blocos é quando tratam de algo mais complexo que listas. Para além de tratar dos detalhes simples de trabalhos domésticos dentro do método, também pode tratar da instalação, limpeza e erros—tudo de forma escondida das preocupações do utilizador.# Dizer adeus a toda a gente
def dizer_adeus
if @nomes.nil?
puts "..."
elsif @nomes.respond_to?("join")
# Juntar os elementos da lista com vírgulas
puts "Adeus #{@nomes.join(", ")}. Voltem em breve!"
else
puts "Adeus #{@nomes}. Volta em breve!"
end
enddizer_adeus não usa o método each, em vez disso verifica se @nomes responde ao método join e se sim, usa-o. Caso contrário limita-se a imprimir a variável como string. Este método não se preocupa com o verdadeiro tipo da variável, está só a limitar-se a tirar partido de algo conhecido por “Duck Typing”, no sentido de que “se anda como um pato, e faz quá quá como um pato então…”. A vantagem disto é não restringir desnecessariamente os tipos de variáveis suportados. Se alguém aparecer com um novo género de classe de lista, desde que essa lista tenha implementado método join com a mesma semântica que as outras listas, então tudo irá funcionar como planeado.Executar o Script
Está pois apresentada a classe MegaAnfitrião, o resto do ficheiro só chama os métodos nessa classe. Existe um último truque a tomar nota, é a linha:if __FILE__ == $0__FILE__ é uma variável mágica que contém o nome do ficheiro actual. $0 é o nome do ficheiro usado para iniciar o programa. Esta verificação diz: “Se este é o ficheiro principal a ser usado então…”, isto permite que um ficheiro seja usado como biblioteca e nesse contexto não executar código mas caso o ficheiro seja usado como executável então executa esse código.Foi um prazer
Pronto, isto foi uma visita rápida ao mundo do Ruby. Existe muito para explorar, as diferentes estruturas de controlo que Ruby oferece, o uso de blocos e deyield, módulos como mixins e muito mais. Espero que esta pequena amostra da linguagem Ruby tenha deixado o desejo de aprender mais.Se sim, por favor visite a nossa secção de Documentação , onde encontraram ligações para manuais e guias, todos disponíveis em formato digital.
Ou, se desejar ler mesmo um livro, veja a nossa biblioteca de livros (ligação ao exterior) para títulos disponíveis à venda online ou numa livraria aí perto.
Fonte
Postagens
