Copyright © 2016 Eustáquio Rangel de Oliveira Jr.

Todos os direitos reservados.

Nenhuma parte desta publicação pode ser reproduzida, armazenada em bancos de dados ou transmitida sob qualquer forma ou meio, seja eletrônico, eletrostático, mecânico, por fotocópia, gravação, mídia magnética ou algum outro modo, sem permissão por escrito do detentor do copyright.

Sobre esse livro

O conteúdo que você tem agora nas mãos é a evolução do meu conhecido “Tutorial de Ruby”, lançado em Janeiro de 2005, que se transformou em 2006 no primeiro livro de Ruby do Brasil, “Ruby - Conhecendo a Linguagem”, da Editora Brasport, cujas cópias se esgotaram e, como não vai ser reimpresso, resolvi atualizar e lançar material nos formatos de ebook que agora você tem em mãos.

Quando comecei a divulgar Ruby aqui no Brasil, seja pela internet, seja por palestras em várias cidades, eram poucas pessoas que divulgavam e a linguagem era bem desconhecida, e mesmo hoje, vários anos após ela pegar tração principalmente liderada pela popularidade do framework Rails, que sem sombra de dúvidas foi o principal catalizador da linguagem, ainda continua desconhecida de grande parte das pessoas envolvidas ou começando com desenvolvimento de sistemas, especialmente a molecada que está começando a estudar agora em faculdades.

Como eu sou mais teimoso que uma mula, ainda continuo promovendo a linguagem por aí, disponibilizando esse material para estudos, não por causa do tutorial, do livro ou coisa do tipo, mas porque ainda considero a linguagem muito boa, ainda mais com toda a evolução que houve em todos esses anos, em que saímos de uma performance mais sofrível (mas, mesmo assim, utilizável) nas versões 1.8.x até os avanços das versões 1.9.x e agora, as 2.x.

Espero que o material que você tem em mãos sirva para instigar você a conhecer mais sobre a linguagem (aqui não tem nem de longe tudo o que ela disponibiliza) e a conhecer as ferramentas feitas com ela. É uma leitura direta e descontraída, bem direto ao ponto. Em alguns momentos eu forneço alguns “ganchos” para alguma coisa mais avançada do que o escopo atual, e até mostro algumas, mas no geral, espero que seja conteúdo de fácil digestão.

Durante o livro, faço alguns “desafios”, que tem a sua resposta no final do livro. Tentem fazer sem colar! :-)

Esse material também serve como base para os treinamentos de Ruby on Rails que ministramos na minha empresa, a Bluefish. Se precisar de cursos de Ruby on Rails, seja na nossa empresa, seja in-company, ou precisar de consultoria em projetos que utilizam essa ferramenta, entre em contato conosco através de contato@bluefish.com.br.

Um grande abraço!

Ruby

O que é Ruby?

Usando uma pequena descrição encontrada na web, podemos dizer que:

“Ruby é uma linguagem de programação interpretada multiparadigma, de tipagem dinâmica e forte, com gerenciamento de memória automático, originalmente planejada e desenvolvida no Japão em 1995, por Yukihiro “Matz”Matsumoto, para ser usada como linguagem de script. Matz queria uma linguagem de script que fosse mais poderosa do que Perl, e mais orientada a objetos do que Python. Ruby suporta programação funcional, orientada a objetos, imperativa e reflexiva.

Foi inspirada principalmente por Python, Perl, Smalltalk, Eiffel, Ada e Lisp, sendo muito similar em vários aspectos a Python.

A implementação padrão é escrita em C, como uma linguagem de programação de único passe. Não há qualquer especificação da linguagem, assim a implementação original é considerada de fato uma referência. Atualmente, há várias implementações alternativas da linguagem, incluindo YARV, JRuby, Rubinius, IronRuby, MacRuby e HotRuby, cada qual com uma abordagem diferente, com IronRuby, JRuby e MacRuby fornecendo compilação Just-In-Time e, JRuby e MacRuby também fornecendo compilação Ahead-Of-Time.

A série 1.9 usa YARV (Yet Another Ruby VirtualMachine), como também a 2.0, substituindo a mais lenta Ruby MRI (Matz’s Ruby Interpreter).”

Fonte: Wikipedia

Instalando Ruby

A instalação pode ser feita de várias maneiras, em diferentes sistemas operacionais, desde pacotes específicos para o sistema operacional, scripts de configuração ou através do download, compilação e instalação do código-fonte. Abaixo vão algumas dicas, mas não execute nenhuma delas pois vamos fazer a instalação de uma maneira diferente e mais moderna e prática.

Ubuntu

Se você está usando o Ubuntu, pode instalá-la com os pacotes nativos do sistema operacional:

1   $ sudo apt-get install ruby<versao>

OSX

Para instalá-la no OSX, pode utilizar o MacPorts:

1   $ port install ruby    

E até no Windows tem um instalador automático. Mais detalhes para esse tipo de instalação podem ser conferidas no site oficial da linguagem. Particularmente eu não recomendo utilizar a linguagem no Windows, aí vai de cada um, mas já aviso que vão arrumar sarna para se coçarem.

RVM

Vamos instalar Ruby utilizando a RVM - Ruby Version Manager, que é uma ferramenta de linha de comando que nos permite instalar, gerenciar e trabalhar com múltiplos ambientes Ruby, de interpretadores até conjunto de gems. Como alternativa ao RVM, temos também a rbenv. Vamos utilizar a RVM, mas se mais tarde vocês quiserem investigar a rbenv, fiquem à vontade pois o comportamento é similar.

A instalação da RVM é feita em ambientes que tem o shell bash (por isso ela não está disponível para Windows, nesse caso, verifique a ferramenta pik), sendo necessário apenas abrir um terminal rodando esse shell e executar:

1   $ curl -L https://get.rvm.io | bash

Isso irá gerar um diretório em nosso home (abreviado a partir de agora como ~) parecida com essa:

 1   $ ls .rvm
 2   total 92K
 3   .
 4   ..
 5   archives
 6   bin
 7   config
 8   environments
 9   examples
10   gems
11   gemsets
12   help
13   lib
14   LICENCE
15   log
16   patches
17   README
18   rubies
19   scripts
20   src
21   tmp
22   wrappers

e também com o diretório de gems:

1   $ ls .gem
2   total 28K
3   .
4   ..
5   credentials
6   ruby
7   specs

Após a instalação, dependendo da versão da RVM que foi instalada, temos que inserir o comando rvm no path, adicionando no final do arquivo ~/.bashrc (ou, dependendo da sua distribuição Linux, no ~/.bash_profile):

1   echo '[[ -s "$HOME/.rvm/scripts/rvm" ]] && . "$HOME/.rvm/scripts/rvm"' >> ~\
2 /.bashrc

Talvez na versão corrente, isso não seja mais necessário. Mas para confirmar se é necessário ou se a RVM já se encontra corretamente configurada e instalada, podemos executar os seguintes comandos:

1   $ type rvm | head -n1
2   rvm é uma função
3   $ rvm -v
4   rvm 1.27.0 (master) by Wayne E. Seguin <wayneeseguin@gmail.com>, Michal Pap\
5 is <mpapis@gmail.com> [https://rvm.io/]

E dependendo da versão da RVM instalada, devemos verificar quais são as notas para o ambiente que estamos instalando a RVM, que no caso do Ubuntu vai retornar:

 1   $ rvm notes
 2   Notes for Linux ( DISTRIB_ID=Ubuntu
 3   DISTRIB_RELEASE=11.04
 4   DISTRIB_CODENAME=natty
 5   DISTRIB_DESCRIPTION="Ubuntu 11.04" )
 6   
 7   # NOTE: MRI stands for Matz’s Ruby Interpreter (1.8.X, 1.9.X), 
 8   # ree stands for Ruby Enterprise Edition and rbx stands for Rubinius.
 9   
10   # curl is required.
11   # git is required.
12   # patch is required (for ree, some ruby head’s).
13   
14   # If you wish to install rbx and/or any MRI head (eg. 1.9.2-head) 
15   # then you must install and use rvm 1.8.7 first.
16   # If you wish to have the ’pretty colors’ again,
17   # set ’export rvm_pretty_print_flag=1’ in ~/.rvmrc.
18   dependencies:
19   
20   # For RVM
21   rvm: bash curl git
22   
23   # For JRuby (if you wish to use it) you will need:
24   jruby: aptitude install curl sun-java6-bin sun-java6-jre 
25   sun-java6-jdk
26   
27   # For MRI & ree (if you wish to use it) you will need 
28   # (depending on what you   # are installing):
29   ruby: aptitude install build-essential bison openssl libreadline5
30   libreadline-dev curl git zlib1g zlib1g-dev libssl-dev libsqlite3-0
31   libsqlite3-dev sqlite3 libxml2-dev
32   ruby-head: git subversion autoconf
33   # For IronRuby (if you wish to use it) you will need:
34   ironruby: aptitude install curl mono-2.0-devel

No caso do Ubuntu e da versão retornar esse tipo de informação, devemos executar a seguinte linha recomendada, em um terminal:

1   $ sudo aptitude install build-essential bison openssl libreadline5
2   libreadline-dev curl git zlib1g zlib1g-dev libssl-dev libsqlite3-0
3   libsqlite3-dev sqlite3 libxml2-dev

Desse modo, satisfazemos todas as ferramentas necessárias para utilizar a RVM. Apesar dela citar nas instruções o aptitude, podemos usar sem problemas o apt-get.

Nas últimas versões da RVM, executando

1   $ rvm requirements

vão ser instaladas as dependências necessárias, talvez requisitando acesso à mais permissões utilizando o sudo.

Instalando um interpretador Ruby

Após instalar a RVM e suas dependências, agora é hora de instalarmos um interpretador Ruby. Vamos utilizar a versão mais atual. Para verificar qual é, visitem a página de downloads da linguagem e verifiquem qual é a versão estável, ou executem esse comando no terminal (levando em conta que já esteja instalado o utilitário curl, que é ferramenta essencial hoje em dia):

1   curl https://www.ruby-lang.org/pt/downloads/ 2> /dev/null | grep -o "Ruby [\
2 0-9].[0-9].[0-9]" | sort | uniq | tail -n1
3   Ruby 2.3.1

Ali vimos que a última versão reconhecida (no momento em que estou escrevendo esse texto) é a 2.3.1.

Levando em conta que <versão> é a última versão que encontramos acima, podemos executar no terminal:

1   $ rvm install <versão>
2   Installing Ruby from source to: 
3   /home/taq/.rvm/rubies/ruby-<versão>
4   this may take a while depending on your cpu(s)...
5   #fetching
6   #downloading ruby-<versão>, this may 
7   take a while depending on your connection...
8   ...

Após instalado, temos que ativar a versão na RVM e verificar se ficou ok, digitando o comando rmv seguido do número da versão para ativá-la, o que pode ser conferido logo depois com o comando ruby -v:

1   $ rvm <versão>
2   $ ruby -v
3   ruby <versão> [i686-linux]

Uma coisa que enche o saco é ficar toda santa hora indicando qual a versão que queremos rodar. Para evitar isso, vamos deixar a versão instalada como a padrão do sistema:

1   $ rvm use <versão> --default
2   Using /home/taq/.rvm/gems/ruby-<versão>

Outra opção para gerenciar qual versão está ativa, é criar um arquivo chamado .ruby-version, com o número da versão que queremos ativar:

1   echo <versão> > .ruby-version
2   $ cat .ruby-version
3   <versão>

Importante notar que essa versão vai ser ativada somente quando navegarmos para o diretório onde o arquivo se encontra. Ou seja, toda vez que utilizamos, por exemplo, o comando cd para irmos para o diretório onde o arquivo se encontra, a versão especificada vai ser ativada.

Com tudo instalado e configurado, podemos prosseguir.

Básico da linguagem

Vamos conhecer agora alguns dos recursos, características, tipos e estruturas básicas da linguagem. Eu sempre cito em palestras e treinamentos uma frase do Alan Perlis, que é:

A language that doesn’t affect the way you think about programming, is not worth knowing.

Ou, traduzindo:

Não compensa aprender uma linguagem que não afeta o jeito que você pensa sobre programação.

O que vamos ver (pelo menos é a minha intenção) é o que Ruby tem de diferente para valer a pena ser estudada. Não vamos ver só como os if's e while's são diferentes, mas sim meios de fazer determinadas coisas em que você vai se perguntar, no final, “por que a minha linguagem preferida X não faz isso dessa maneira?”.

Tipagem dinâmica

Ruby é uma linguagem de tipagem dinâmica. Como mencionado na Wikipedia:

Tipagem dinâmica é uma característica de determinadas linguagens de programação, que não exigem declarações de tipos de dados, pois são capazes de escolher que tipo utilizar dinamicamente para cada variável, podendo alterá-lo durante a compilação ou a execução do programa.

Algumas das linguagens mais conhecidas a utilizarem tipagem dinâmica são: Python, Ruby, PHP e Lisp. A tipagem dinâmica contrasta com a tipagem estática, que exige a declaração de quais dados poderão ser associados a cada variável antes de sua utilização. Na prática, isso significa que:

1 > v = "teste"
2 
3 > v.class 
4 => String
5 
6 > v = 1
7 
8 > v.class 
9 => Fixnum

Pudemos ver que a variável ¹ v pode assumir como valor tanto uma String como um número (que nesse caso, é um Fixnum - mais sobre classes mais adiante), ao passo que, em uma linguagem de tipagem estática, como Java, isso não seria possível, com o compilador já não nos deixando prosseguir:

1 public class Estatica {
2   public static void main(String args[]) {
3     String v = "teste";
4     System.out.println(v);
5     v = 1;
6   }
7 }

Tentando compilar:

1 $ javac Estatica.java
2 Estatica.java:5: incompatible types
3 found : int
4 required: java.lang.String
5 v = 1;
6 ^
7 1 error

Tipagem forte

Ruby também tem tipagem forte. Segundo a Wikipedia:

Linguagens implementadas com tipos de dados fortes, tais como Java e Pascal, exigem que o tipo de dado de um valor seja do mesmo tipo da variável ao qual este valor será atribuído.

Isso significa que:

1 > i = 1
2 > s = "oi"
3 > puts i+s
4 => TypeError: String can’t be coerced into Fixnum

Enquanto em uma linguagem como PHP, temos tipagem fraca:

1 <?php
2 $i = 1;
3 $s = "oi";
4 print $i + $s;
5 ?>

Rodando isso, resulta em:

1 $ php tipagem_fraca.php
2 1

Tipos básicos

Não temos primitivos em Ruby, somente abstratos, onde todos exibem comportamento de objetos. Temos números inteiros e de ponto flutuante, onde podemos dividir os inteiros em Fixnums e Bignums, que são diferentes somente pelo tamanho do número, sendo convertidos automaticamente. A partir da versão 2.4 de Ruby, os inteiros foram convertidos em Integer, facilitando em um nível mais alto e mantendo o comportamento anterior em um nível mais baixo, se necessário identificar qual o tipo exato. Vamos ver alguns deles agora.

Fixnums

Para ver como é a implementação até antes das versões 2.4.x da linguagem, tudo o que estiver relacionado com Fixnums e Bignums nessa seção vai estar sendo executado em versões anteriores da 2.4.x. Se você estiver utilizando a 2.4.x ou maior (sendo que a 2.4 tem a data de liberação como 25/12/2016, sempre temos uma versão nova no Natal, ho-ho-ho), pode abstrair ambos os tipos como Integers.

Os Fixnums são números inteiros de 31 bits de comprimento (ou 1 word do processador menos 1 bit), usando 1 bit para armazenar o sinal e 1 bit para indicar que a referência corrente é um Fixnum (mais sobre isso logo abaixo, mencionando immediate values), resultando em um valor máximo de armazenamento, para máquinas de 32 bits, de 30 bits, ou seja:

1 > (2**30)-1 
2 => 1073741823
3 
4 > ((2**30)-1).class 
5 => Fixnum

Em máquinas com 64 bits:

1   > ((2**62)-1) 
2   => 4611686018427387903 
3   
4   > ((2**62)-1).class 
5   => Fixnum 

Vamos testar isso no IRB, o interpretador de comandos do Ruby. Para acionar o IRB, abra um emulador de terminal e digite:

1 $ irb
2 > (2**30)-1
3 => 1073741823
4 
5 > ((2**30)-1).class
6 => Fixnum

Os Fixnums tem características interessantes que ajudam na sua manipulação mais rápida pela linguagem, que os definem como immediate values, que são tipos de dados apontados por variáveis que armazenam seus valores na própria referência e não em um objeto que teve memória alocada para ser utilizado, agilizando bastante o seu uso. Para verificar isso vamos utilizar o método object_id.

Por exemplo:

1 > n = 1234
2 => 1234
3 
4 > n.object_id
5 => 2469
6 
7 > n.object_id >> 1
8 => 1234

Também podemos notar que esse comportamento é sólido verificando que o object_id de várias variáveis apontando para um mesmo valor continua sendo o mesmo:

 1 > n1 = 1234
 2 => 1234
 3 
 4 > n2 = 1234
 5 => 1234
 6 
 7 > n1.object_id
 8 => 2469
 9 
10 > n2.object_id
11 => 2469

Os Fixnums, como immediate values, também tem também uma característica que permite identificá-los entre os outros objetos rapidamente através de uma operação de and lógico, onde é verificado justamente o último bit, que é um dos 2 utilizados para controle, como explicado anteriormente:

1 > n = 1234
2 => 1234
3 
4 > n.object_id & 0x1
5 => 1

Isso nos mostra um comportamento interessante: qualquer variável que aponta para um objeto ou algo como um Fixnum ou immediate value, que apesar de carregar o seu próprio valor e ser bem light weight, ainda mantém características onde podem ter acessados os seus métodos como qualquer outro tipo na linguagem. Olhem, por exemplo, o número 1 (e qualquer outro número):

 1 > 1.methods 
 2 
 3 => [:to_s, :-, :, :-, :, :, :div, :, :modulo, :divmod, :fdiv, :, 
 4 :abs, :magnitude, :, :, :=>, :, :, :, :, :, :, :, :, :[], :, :, :to_f, 
 5 :size, :zero?, :odd?, :even?, :succ, :integer?, :upto, :downto, :times, 
 6 :next, :pred, :chr, :ord, :to_i, :to_int, :floor, :ceil, :truncate, 
 7 :round, :gcd, :lcm, :gcdlcm, :numerator, :denominator, :to_r, 
 8 :rationalize, :singleton_method_added, :coerce, :i, :, :eql?, :quo, 
 9 :remainder, :real?, :nonzero?, :step, :to_c, :real, :imaginary, 
10 :imag, :abs2, :arg, :angle, :phase, :rectangular, :rect,
11 :polar, :conjugate, :conj, :pretty_print_cycle, :pretty_print, 
12 :between?, :po, :poc, :pretty_print_instance_variables,     
13 :pretty_print_inspect, :nil?, :, :!, :hash, :class, :singleton_class, 
14 :clone, :dup, :initialize_dup, :initialize_clone, :taint, :tainted?, 
15 :untaint, :untrust, :untrusted?, :trust, :freeze, :frozen?, :inspect, 
16 :methods, :singleton_methods, :protected_methods, :private_methods, 
17 :public_methods, :instance_variables, :instance_variable_get,
18 :instance_variable_set, :instance_variable_defined?, :instance_of?, 
19 :kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?, 
20 :respond_to_missing?, :extend, :display, :method, :public_method, 
21 :define_singleton_method, :__id__, :object_id, :to_enum, :enum_for, 
22 :pretty_inspect, :ri, :equal?, :!, :!, :instance_eval, 
23 :instance_exec, :__send__]

No exemplo acima, estamos vendo os métodos públicos de acesso de um Fixnum. Mais sobre métodos mais tarde!

Bignums

Como vimos acima, os Fixnums tem limites nos seus valores, dependendo da plataforma. Os Bignums são os números inteiros que excedem o limite imposto pelos Fixnums, ou seja, em um computador de 32 bits:

1 > (2**30)
2 => 1073741824
3 
4 > (2**30).class
5 => Bignum

Uma coisa muito importante nesse caso, é que os Bignums alocam memória, diferentemente dos Fixnums e outros tipos que são immediate values!

Podemos ver isso criando algumas variáveis apontando para o mesmo valor de Bignum e vendo que cada uma tem um object_id diferente:

 1 > b1 = (2**30)
 2 => 1073741824
 3 
 4 > b2 = (2**30)
 5 => 1073741824
 6 
 7 > b1.object_id
 8 => 75098610
 9 
10 > b2.object_id
11 => 75095080

Tanto para Fixnums como para Bignums, para efeito de legibilidade, podemos escrever os números utilizando o sublinhado (_) como separador dos números:

1 > 1_234_567
2 => 1234567
3 
4 > 1_234_567_890
5 => 1234567890

Ponto flutuante

Os números de ponto flutuante podem ser criados utilizando … ponto, dã. Por exemplo:

1 > 1.23
2 => 1.23
3 
4 > 1.234
5 => 1.234

Importante notar que os Floats não são immediate values:

 1 > f1 = 1.23
 2 => 1.23
 3 
 4 > f2 = 1.23
 5 => 1.23
 6 
 7 > f1.object_id
 8 => 84116780
 9 
10 > f2.object_id
11 => 84114210

Racionais

É nóis, mano.

Mando um recado lá pro meu irmão: Se tiver usando droga, tá ruim na minha mão. Ele ainda tá com aquela mina. Pode crer, moleque é gente fina.

Podemos criar racionais (não os M.C.s) utilizando explicitamente a classe Rational:

1 > Rational(1,3)
2 => (1/3)
3 
4 > Rational(1,3) * 9
5 => (3/1) 

Ou, a partir da versão 1.9 de Ruby, utilizar to_r em uma String:

1 > "1/3".to_r * 9
2 => (3/1)

Booleanos

Temos mais dois immediate values que são os booleanos, os tradicionais true e false, indicando como object_ids, respectivamente, 2 e 0:

1 > true.object_id
2 => 2
3 
4 > false.object_id
5 => 0

Nulos

O tipo nulo em Ruby é definido como nil. Ele também é um immediate value, com o valor fixo de 4 no seu object_id:

1 > nil.object_id
2 => 4

Temos um método para verificar se uma variável armazena um valor nul, chamado nil?:

 1 > v = 1
 2 => 1
 3 
 4 > v.nil?
 5 => false
 6 
 7 > v = nil
 8 => nil
 9 
10 > v.nil?
11 => true

Strings

Strings são cadeias de caracteres, que podemos criar delimitando esses caracteres com aspas simples ou duplas, como por exemplo “azul” ou ‘azul’, podendo utilizar simples ou duplas dentro da outra como “o céu é ‘azul’” ou ‘o céu é “azul”’ e “escapar” utilizando o caracter :

 1 > puts "o céu é 'azul'"
 2 => o céu é 'azul'
 3 
 4 > puts "o céu é \"azul\""
 5 => o céu é "azul"
 6 
 7 > puts 'o céu é "azul"'
 8 => o céu é "azul"
 9 
10 > puts 'o céu é \'azul\''
11 => o céu é 'azul'

Também podemos criar Strings longas, com várias linhas, usando o conceito de heredoc, onde indicamos um terminador logo após o sinal de atribuição (igual) e dois sinais de menor (<<):

1 > str = <<FIM
2 criando uma String longa
3 com saltos de linha e
4 vai terminar logo abaixo.
5 FIM
6 => "criando uma String longa\ncom saltos de linha e \nvai terminar logo abaix\
7 o.\n"

O terminador tem que vir logo no começo da linha onde termina a String, e ser o mesmo indicado no começo. Nesse exemplo, foi utilizado o terminador FIM. Utilizar heredocs evita que façamos muitas linhas cheias de Strings uma concatenando com a outra.

Para cada String criada, vamos ter espaço alocado na memória, tendo um object_id distinto para cada uma:

 1 > s1 = "ola"
 2 => "ola"
 3 
 4 > s2 = "ola"
 5 => "ola"
 6 
 7 > s1.object_id
 8 => 84291220
 9 
10 > s2.object_id
11 => 84288510

Substrings

São partes de uma String (antes eu havia escrito “pedaços” de uma String, mas ficou um lance muito Tokyo Ghoul/Hannibal Lecter, então achei “partes” mais bonito). Para pegar algumas substrings, podemos tratar a String como um Array:

 1 > str = "string"
 2 => "string"
 3 
 4 > str[0..2]
 5 => "str"
 6 
 7 > str[3..4]
 8 => "in"
 9 
10 > str[4..5]
11 => "ng"

Podendo também usar índices negativos para recuperar as posições relativas ao final da String:

 1 > str[-4..3]
 2 => "ri"
 3 
 4 > str[-5..2]
 5 => "tr"
 6 
 7 > str[-4..-3]
 8 => "ri"
 9 
10 > str[-3..-1]
11 => "ing"
12 
13 > str[-1]
14 => "g"
15 
16 > str[-2]
17 => "n"

Ou utilizar o método slice, com um comportamento um pouco diferente:

1 > str.slice(0,2)
2 => "st"    
3 
4 > str.slice(3,2)
5 => "in"

Referenciando um caracter da String, temos algumas diferenças entre as versões 1.8.x e 1.9.x (ou maiores) do Ruby:

1 # Ruby 1.8.x
2 > str[0]
3 => 115
4 
5 # Ruby 1.9.x e maiores
6 > str[0]
7 => "s"

Mais sobre encodings, logo abaixo.

Concatenando Strings

Para concatenar Strings, podemos utilizar os métodos (sim, métodos, vocês não imaginam as bruxarias que dá para fazer com métodos em Ruby, como veremos adiante!) + ou <<:

 1 > nome = "Eustaquio"
 2 => "Eustaquio"
 3 
 4 > sobrenome = "Rangel"
 5 => "Rangel"
 6 
 7 > nome + " " + sobrenome
 8 => "Eustaquio Rangel"
 9 
10 > nome.object_id
11 => 84406670
12 
13 > nome << " "
14 => "Eustaquio "
15 
16 > nome << sobrenome
17 => "Eustaquio Rangel"
18 
19 > nome.object_id
20 => 84406670

A diferença é que + nos retorna um novo objeto, enquanto << faz uma realocação de memória e trabalha no objeto onde o conteúdo está sendo adicionado, como demonstrado acima, sem gerar um novo objeto.

Encoding

A partir da versão 1.9 temos suporte para encodings diferentes para as Strings em Ruby. Nas versões menores, era retornado o valor do caracter na tabela ASCII. Utilizando um encoding como o UTF-8, podemos utilizar (se desejado, claro!) qualquer caracter para definir até nomes de métodos!

Podemos verificar o encoding de uma String:

1 > "eustáquio".encoding
2 => #<Encoding:UTF-8>

Podemos definir o encoding de uma String:

1 > "eustáquio".encode "iso-8859-1"
2 => "eust\xE1quio"
3 
4 > "eustáquio".encode("iso-8859-1").encoding
5 => #<Encoding:ISO-8859-1>

Váriaveis são referências na memória

Em Ruby, os valores são transmitidos por referência, podendo verificar isso com Strings, constatando que as variáveis realmente armazenam referências na memória. Vamos notar que, se criarmos uma variável apontando para uma String, criamos outra apontando para a primeira (ou seja, para o mesmo local na memória) e se alterarmos a primeira, comportamento semelhante é notado na segunda variável:

 1 > nick = "TaQ"
 2 => "TaQ"
 3 
 4 > other_nick = nick
 5 => "TaQ"
 6 
 7 > nick[0] = "S"
 8 => "S"
 9 
10 > other_nick
11 => "SaQ"

Para evitarmos que esse comportamento aconteça e realmente obter dois objetos distintos, podemos utilizar o método dup:

 1 > nick = "TaQ"
 2 => "TaQ"
 3 
 4 > other_nick = nick.dup
 5 => "TaQ"
 6 
 7 > nick[0] = "S"
 8 => "S"
 9 
10 > nick
11 => "SaQ"
12 
13 > other_nick
14 => "TaQ"

Congelando objetos

Se, por acaso quisermos que um objeto não seja modificado, podemos utilizar o método freeze:

1 > nick = "TaQ"
2 => "TaQ"
3 
4 > nick.freeze
5 => "TaQ"
6 
7 > nick[0] = "S"
8 RuntimeError: can’t modify frozen string

Não temos um método unfreeze, mas podemos gerar uma cópia do nosso objeto “congelado” com dup, e assim fazer modificações nessa nova cópia:

 1 > nick = "TaQ"
 2 => "TaQ"
 3 
 4 > nick.freeze
 5 => "TaQ"
 6 
 7 > new_nick = nick.dup
 8 => "TaQ"
 9 
10 > new_nick[0] = "S"
11 => "SaQ"

Importante notar que é criada uma tabela de Strings congeladas, assim toda String congelada vai ser o mesmo objeto:

 1   > s1 = "taq".freeze
 2   => "taq" 
 3   
 4   > s1.object_id
 5   => 10988480 
 6   
 7   > s2 = "taq".freeze
 8   => "taq" 
 9   
10   > s2.object_id
11   => 10988480 

Alguns métodos e truques com Strings

 1 > str = "tente"
 2 > str["nt"] = "st" => "teste"
 3 > str.size => 5
 4 > str.upcase => "TESTE"
 5 > str.upcase.downcase => "teste"
 6 > str.sub("t","d") => "deste"
 7 > str.gsub("t","d") => "desde"
 8 > str.capitalize => "Desde"
 9 > str.reverse => "etset"
10 > str.split("t") => ["","es","e"]
11 > str.scan("t") => ["t","t"]
12 > str.scan(/^t/) => ["t"]
13 > str.scan(/./) => ["t","e","s","t","e"]

Alguns métodos acima, como sub, gsub e scan aceitam expressões regulares (vamos falar delas daqui a pouco) e permitem fazer algumas substituições como essa:

1   > "apenas um [teste]".gsub(/[\[\]]/, { "[" => "(", "]" => ")" })
2   => "apenas um (teste)"

Símbolos

Símbolos, antes de mais nada, são instâncias da classe Symbol. Podemos pensar em um símbolo como uma marca, um nome, onde o que importa não é o que contém a sua instância, mas o seu nome.

Símbolos podem se parecer com um jeito engraçado de Strings, mas devemos pensar em símbolos como significado e não como conteúdo. Quando escrevemos “azul”, podemos pensar como um conjunto de letras, mas quando escrevemos :azul, podemos pensar em uma marca, uma referência para alguma coisa.

Símbolos também compartilham o mesmo object_id, em qualquer ponto do sistema:

1 > :teste.class 
2 => Symbol
3 
4 > :teste.object_id
5 => 263928
6 
7 > :teste.object_id
8 => 263928

Como pudemos ver, as duas referências para os símbolos compartilham o mesmo objeto, enquanto que foram alocados dois objetos para as Strings. Uma boa economia de memória com apenas uma ressalva: símbolos não são objetos candidatos a limpeza automática pelo garbage collector, ou seja, se você alocar muitos, mas muitos símbolos no seu sistema, você poderá experimentar um nada agradável esgotamento de memória que com certeza não vai trazer coisas boas para a sua aplicação, ao contrário de Strings, que são alocadas mas liberadas quando não estão sendo mais utilizadas.

Outra vantagem de símbolos é a sua comparação. Para comparar o conteúdo de duas Strings, temos que percorrer os caracteres um a um e com símbolos podemos comparar os seus object_ids que sempre serão os mesmos, ou seja, uma comparação O(1) (onde o tempo para completar é sempre constante e o mesmo e não depende do tamanho da entrada).

Imaginem o tanto que economizamos usando tal tipo de operação!

Expressões regulares

Outra coisa muito útil em Ruby é o suporte para expressões regulares (regexps). Elas podem ser facilmente criadas das seguintes maneiras:

1 > regex1 = /^[0-9]/
2 => /^[0-9]/
3 
4 > regex2 = Regexp.new("^[0-9]")
5 => /^[0-9]/
6 
7 > regex3 = %r{^[0-9]}
8 => /^[0-9]/

Para fazermos testes com as expressões regulares, podemos utilizar os operadores =~ (“igual o tiozinho quem vos escreve”) que indica se a expressão “casou” e !~ que indica se a expressão não “casou”, por exemplo:

 1 > "1 teste" =~ regex1
 2 => 0
 3 
 4 > "1 teste" =~ regex2
 5 => 0
 6 
 7 > "1 teste" =~ regex3
 8 => 0
 9 
10 > "outro teste" !~ regex1
11 => true
12 
13 > "outro teste" !~ regex2
14 => true
15 
16 > "outro teste" !~ regex3
17 => true
18 
19 > "1 teste" !~ regex1
20 => false
21 
22 > "1 teste" !~ regex2
23 => false
24 
25 > "1 teste" !~ regex3
26 => false

No caso das expressões que “casaram”, foi retornada a posição da String onde houve correspondência. Também podemos utilizar, a partir da versão 2.4, o método match?:

1   > regex1.match? "1 teste"
2   => true 
3   
4   > regex1.match? "outro teste"
5   => false 

O detalhe é que o método match?, que retorna somente um boolean indicando se a expressão “casou” ou não (diferente do =~ que retorna onde casou) é até 3 vezes mais rápido.

Podemos fazer truques bem legais com expressões regulares e Strings, como por exemplo, dividir a nossa String através de uma expressão regular, encontrando todas as palavras que começam com r:

1 > "o rato roeu a roupa do rei de Roma".scan(/r[a-z]+/i)
2 => ["rato", "roeu", "roupa", "rei", "Roma"]

Fica uma dica que podemos utilizar alguns modificadores no final da expressão regular, no caso acima, o /i indica que a expressão não será case sensitive, ou seja, levará em conta caracteres em maiúsculo ou minúsculo.

Outra dica interessante é o construtor %r{}, mostrado acima. Quando temos barras para “escapar” dentro da expressão regular, ele nos permite economizar alguns caracteres, como nesse exemplo:

1   > /\Ahttp:\/\/(www\.)?eustaquiorangel\.com\z/ =~ "http://eustaquiorangel.co\
2 m"
3   => 0 
4   > %r{http://(www\.)?eustaquiorangel\.com} =~ "http://eustaquiorangel.com"
5   => 0 

Também podemos utilizar interpolação de expressão:

1   > host = "eustaquiorangel.com"
2   => "eustaquiorangel.com" 
3   > %r{\Ahttp://(www\.)?#{host}\z} =~ "http://eustaquiorangel.com"
4   => 0 

Grupos

Podemos utilizar grupos nas expressões regulares, utilizando ( e ) para delimitar o grupo, e $<número> para verificar onde o grupo “casou”:

 1 > "Alberto Roberto" =~ /(\w+)( )(\w+)/
 2 => 0
 3 
 4 > $1
 5 => "Alberto"
 6 
 7 > $2
 8 => " "
 9 
10 > $3
11 => "Roberto"

Também podemos utilizar \<número> para fazer alguma operação com os resultados da expressão regular assim:

1 > "Alberto Roberto".sub(/(\w+)( )(\w+)/,’\3 \1’)
2 => "Roberto Alberto"

Grupos nomeados

A partir da versão 1.9, podemos usar grupos nomeados em nossas expressões regulares, como por exemplo:

1 > matcher = /(?<objeto>\w{5})(.*)(?<cidade>\w{4})$/.match("o rato roeu a roup\
2 a do rei de Roma")
3 
4 > matcher[:objeto] 
5 => "roupa"
6 
7 > matcher[:cidade] 
8 => "Roma"

A partir da versão 2.4, temos o método named_captures que nos retorna uma Hash com os valores que foram capturados:

1   > matcher = /(?<objeto>\w{5})(.*)(?<cidade>\w{4})$/.match("o rato roeu a ro\
2 upa do rei de Roma")
3   => #<MatchData "roupa do rei de Roma" objeto:"roupa" cidade:"Roma"> 
4   
5   > matcher.named_captures
6   => {"objeto"=>"roupa", "cidade"=>"Roma"} 

Caracteres acentuados

E se precisarmos utilizar caracteres com acento nas expressões? Por exemplo, eu juro que o meu nome está correto, mas:

1   > "eustáquio" =~ /\A\w+\z/
2   => nil

Para resolver esse problema, podemos utilizar tanto as propriedades de caracteres ²:

1   > "eustáquio" =~ /\A\p{Latin}+\z/
2   => 0

como a indicação de que os caracteres são Unicode:

1   > "eustáquio" =~ /\A(?u)\w+\z/
2   => 0 

Arrays

Arrays podemos definir como objetos que contém coleções de referências para outros objetos. Vamos ver um Array simples com números:

1 > array = [1, 2, 3, 4, 5] 
2 => [1, 2, 3, 4, 5]

Em Ruby os Arrays podem conter tipos de dados diferentes também, como esse onde misturamos inteiros, flutuantes e Strings:

1 > array = [1, 2.3, "oi"] 
2 => [1, 2.3, "oi"]

Podemos também criar Arrays com tamanho inicial pré-definido utilizando o tamanho na criação do objeto:

1 > array = Array.new(5)
2 => [nil, nil, nil, nil, nil]

Para indicar qual valor ser utilizado ao invés de nil nos elementos do Array criado com tamanho definido, podemos usar:

1 > array = Array.new(5, 0)
2 => [0, 0, 0, 0, 0]

Vamos verificar um efeito interessante, criando um Array com tamanho de 5 e algumas Strings como o valor de preenchimento:

1 > array = Array.new(5, "oi")
2 => ["oi", "oi", "oi", "oi", "oi"]

Foi criado um Array com 5 elementos, mas são todos os mesmos elementos. Duvidam? Olhem só:

1 > array[0].upcase!
2 => "OI"
3 
4 > array
5 => ["OI", "OI", "OI", "OI", "OI"]

Foi aplicado um método destrutivo (que alteram o próprio objeto da referência, não retornando uma cópia dele no primeiro elemento do Array, que alterou todos os outros elementos, pois são o mesmo objeto. Para evitarmos isso, podemos utilizar um bloco (daqui a pouco mais sobre blocos!) para criar o Array:

1 > array = Array.new(5) { "oi" }
2 => ["oi", "oi", "oi", "oi", "oi"]
3 
4 > array[0].upcase!
5 => "OI"
6 
7 > array
8 => ["OI", "oi", "oi", "oi", "oi"]

Pudemos ver que agora são objetos distintos.

Aqui temos nosso primeiro uso para blocos de código, onde o bloco foi passado para o construtor do Array, que cria elementos até o número que especificamos transmitindo o valor do índice (ou seja, 0, 1, 2, 3 e 4) para o bloco.

Os Arrays tem uma característica interessante que vários outros objetos de Ruby tem: eles são iteradores, ou seja, objetos que permitem percorrer uma coleção de valores, pois incluem o módulo (hein? mais adiante falaremos sobre módulos!) Enumerable, que inclui essa facilidade.

Como parâmetro para o método que vai percorrer a coleção, vamos passar um bloco de código e vamos ver na prática como que funciona isso. Dos métodos mais comuns para percorrer uma coleção, temos each, que significa “cada”, e que pode ser lido “para cada elemento da coleção do meu objeto, execute esse bloco de código”, dessa maneira:

1 > array.each { |numero| puts "O Array tem o numero " + numero.to_s }
2 
3 => O Array tem o numero 1
4 => O Array tem o numero 2
5 => O Array tem o numero 3
6 => O Array tem o numero 4

Ou seja, para cada elemento do Array, foi executado o bloco - atenção aqui - passando o elemento corrente como parâmetro, recebido pelo bloco pela sintaxe |<parâmetro>| (o caracter | é o pipe no Linux). Podemos ver que as instruções do nosso bloco, que no caso só tem uma linha (e foi usada a convenção de { e }), foram executadas com o valor recebido como parâmetro.

Podemos pegar sub-arrays utilizando o formato [início..fim] ou o método take:

 1 > a = %w(john paul george ringo)
 2 => ["john", "paul", "george", "ringo"]
 3 
 4 > a[0..1]
 5 => ["john", "paul"]
 6 
 7 > a[1..2]
 8 => ["paul", "george"]
 9 
10 > a[1..3]
11 => ["paul", "george", "ringo"]
12 
13 > a[0]
14 => "john"
15 
16 > a[-1]
17 => "ringo"
18 
19 > a.first
20 => "john"
21 
22 > a.last
23 => "ringo"
24 
25 > a.take(2) 
26 => ["john", "paul"]

Reparem no pequeno truque de usar -1 para pegar o último elemento, o que pode ficar bem mais claro utilizando o método last (e first para o primeiro elemento).

Agora que vimos como um iterador funciona, podemos exercitar alguns outros logo depois de conhecer mais alguns outros tipos.

Para adicionar elementos em um Array, podemos utilizar o método push ou o << (lembram desse, nas Strings?), desse modo:

1 > a = %w(john paul george ringo)
2 
3 > a.push("stu")
4 => ["john", "paul", "george", "ringo", "stu"]
5 
6 > a << "george martin"
7 => ["john", "paul", "george", "ringo", "stu", "george martin"]

Se quisermos pesquisar em Arrays dentro de Arrays, podemos utilizar o método dig:

1   > array = [0, [1, [2, 3]]]
2   => [0, [1, [2, 3]]] 
3   
4   > array[1][1][0]
5   => 2 
6   
7   > array.dig(1, 1, 0)
8   => 2 

Duck Typing

Pudemos ver que o operador/método << funciona de maneira similar em Strings e Arrays, e isso é um comportamento que chamamos de Duck Typing, baseado no duck test, de James Whitcomb Riley, que diz o seguinte:

“Se parece com um pato, nada como um pato, e faz barulho como um pato, então provavelmente é um pato”.

Isso nos diz que, ao contrário de linguagens de tipagem estática, onde o tipo do objeto é verificado em tempo de compilação, em Ruby nos interessa se um objeto é capaz de exibir algum comportamento esperado, não o tipo dele.

Se você quer fazer uma omelete, não importa que animal que está botando o ovo (galinha, pata, avestruz, Tiranossauro Rex, etc), desde que você tenha um jeito/método para botar o ovo.

“Ei, mas como vou saber se um determinado objeto tem um determinado método?” Isso é fácil de verificar utilizando o método respond_to?:

1 > String.new.respond_to?(:<<)
2 => true
3 
4 > Array.new.respond_to?(:<<)
5 => true

“Ei, mas eu realmente preciso saber se o objeto em questão é do tipo que eu quero. O método << é suportado por Arrays, Strings, Fixnums mas tem comportamento diferente nesses últimos!”. Nesse caso, você pode verificar o tipo do objeto utilizando kind_of?:

 1 > String.new.kind_of?(String)
 2 => true
 3 
 4 > 1.kind_of?(Fixnum)
 5 => true
 6 
 7 > 1.kind_of?(Numeric)
 8 => true
 9 
10 > 1.kind_of?(Bignum)
11 => false

Ranges

Ranges são intervalos que podemos definir incluindo ou não o último valor referenciado. Vamos exemplificar isso com o uso de iteradores, dessa maneira:

 1 > range1 = (0..10)
 2 => 0..10
 3 
 4 > range2 = (0...10)
 5 => 0...10
 6 
 7 > range1.each { |valor| print "#{valor} " }
 8 => 0 1 2 3 4 5 6 7 8 9 10 
 9 
10 => 0..10
11 > range2.each { |valor| print "#{valor} " }
12 
13 => 0 1 2 3 4 5 6 7 8 9 
14 => 0...10

Como pudemos ver, as Ranges são declaradas com um valor inicial e um valor final, separadas por dois ou três pontos, que definem se o valor final vai constar ou não no intervalo.

Um truque legal é que podemos criar Ranges com Strings:

1 > ("a".."z").each { |valor| print "#{valor} " }
2 => a b c d e f g h i j k l m n o p q r s t u v w x y z
3 
4 => "a".."z"
5 > ("ab".."az").each { |valor| print "#{valor} " }
6 
7 => ab ac ad ae af ag ah ai aj ak al am an ao ap aq ar as at au av aw ax ay az
8 => "ab".."az"

Outro bem legal é converter uma Range em um Array:

1 > ("a".."z").to_a
2 => ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o"\
3 , "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]

Hashes

As Hashes são, digamos, Arrays indexados, com chaves e valores, que podem ser quaisquer tipos de objetos, como por exemplo:

1 > hash = { :john => "guitarra e voz", :paul => "baixo e voz", :george => "gui\
2 tarra", :ringo => "bateria" }
3 => {:john=>"guitarra e voz", :paul=>"baixo e voz", :george=>"guitarra", :ring\
4 o=>"bateria"}

A partir de Ruby 1.9.x as Hashes mantém a ordem dos elementos do jeito que foram criadas, porém em algumas versões do Ruby 1.8.x essa ordem é aleatória. Depois de declaradas, podemos buscar os seus valores através de suas chaves:

1 > hash[:paul]
2 => "baixo e voz"
3 
4 > hash[:ringo]
5 => "bateria"

Utilizar símbolos como chaves de Hashes é uma operação costumeira em Ruby. Se utilizarmos Strings, elas serão tratadas como Strings congeladas, o que podemos verificar comparando os seus object_ids:

 1   > h1 = { "name" => "John" }
 2   => {"name"=>"John"} 
 3 
 4   > h2 = { "name" => "Paul" }
 5   => {"name"=>"Paul"} 
 6 
 7   > h1.keys.first.object_id
 8   => 12256640 
 9 
10   > h2.keys.first.object_id
11   => 12256640 

Vamos ver um exemplo de como podemos armazenar diversos tipos tanto nas chaves como nos valores de uma Hash:

 1 > hash = { "fixnum" => 1, :float => 1.23, 1 => "um" }
 2 => {1=>"um", :float=>1.23, "fixnum"=>1}
 3 
 4 > hash["fixnum"]
 5 => 1
 6 
 7 > hash[:float]
 8 => 1.23
 9 
10 > hash[1]
11 => "um"

Podemos criar Hashes com valores default:

1 > hash = Hash.new(0)
2 => {}
3 
4 > hash[:um]
5 => 0
6 
7 > hash[:dois]
8 => 0

Nesse caso, quando o valor da chave ainda não teve nada atribuído e é requisitado, é retornado o valor default que especificamos em new, que foi 0. Vamos testar com outro valor:

1 > hash = Hash.new(Time.now)
2 => {}
3 
4 > hash[:um]
5 => Tue Jun 05 23:53:22 -0300 2011
6 
7 > hash[:dois]
8 => Tue Jun 05 23:53:22 -0300 2011

No caso acima, passei Time.now no método new da Hash, e toda vez que tentei acessar um dos valores que ainda não foram atribuídos, sempre foi retornado o valor da data e hora de quando inicializei a Hash. Para que esse valor possa ser gerado dinamicamente, podemos passar um bloco para o método new:

 1 > hash = Hash.new { Time.now }
 2 => {}
 3 
 4 > hash[:um]
 5 => 2008-12-31 11:31:28 -0200
 6 
 7 > hash[:dois]
 8 => 2008-12-31 11:31:32 -0200
 9 
10 > hash[:tres]
11 => 2008-12-31 11:31:36 -0200

Hashes são bastante utilizadas como parâmetros de vários métodos do Rails.

Podemos utilizar, assim como em Arrays, o método dig para “cavar” nas estruturas das Hashes:

1   > hash = { a: { b: { c: 3 } } }
2   => {:a=>{:b=>{:c=>3}}} 
3 
4   > hash[:a][:b][:c]
5   => 3 
6 
7   > hash.dig(:a, :b, :c)
8    => 3 

Blocos de código

Um conceito interessante do Ruby são blocos de código (similares ou sendo a mesma coisa em certos sentidos que funções anônimas, closures, lambdas etc). Vamos ir aprendendo mais coisas sobre eles no decorrer do curso, na prática, mas podemos adiantar que blocos de código são uma das grande sacadas de Ruby e são muito poderosos quando utilizados com iteradores.

Por convenção os blocos com uma linha devem ser delimitados por { e } e com mais de uma linha com do ... end (duende???), mas nada lhe impede de fazer do jeito que mais lheagradar. Como exemplo de blocos, temos:

1 > puts { "Oi, mundo" }

e

1 > do
2 >     puts "Oi, mundo"
3 >     puts "Aqui tem mais linhas!"
4 > end

Esses blocos podem ser enviados para métodos e executados pelos iteradores de várias classes. Imaginem como pequenos pedaços de código que podem ser manipulados e enviados entre os métodos dos objetos (tendo eles próprios, comportamento de métodos).

Conversões de tipos

Agora que vimos os tipos mais comuns, podemos destacar que temos algumas métodos de conversão entre eles, que nos permitem transformar um tipo (mas não o mesmo objeto, será gerado um novo) em outro. Alguns dos métodos:

 1 # Fixnum para Float
 2 > 1.to_f 
 3 => 1.0
 4 
 5 # Fixnum para String
 6 > 1.to_s 
 7 => "1"
 8 
 9 # String para Fixnum
10 > "1".to_i 
11 => 1
12 
13 # String para flutuante
14 > "1".to_f 
15 => 1.0
16 
17 # String para símbolo
18 > "azul".to_sym 
19 => :azul
20 
21 # Array para String
22 > [1, 2, 3, 4, 5].to_s 
23 => "12345"
24 
25 # Array para String, com delimitador
26 > [1, 2, 3, 4, 5].join(",") 
27 => "1,2,3,4,5"
28 
29 # Range para Array
30 > (0..10).to_a 
31 => [0,1,2,3,4,5,6,7,8,9,10]
32 
33 # Hash para Array
34 > {:john => "guitarra e voz" }.to_a
35 => [ [:john, "guitarra e voz"] ]

Conversões de bases

De inteiro para binário:

1 > 2.to_s(2) 
2 => "10"

De binário para inteiro:

1 > "10".to_i(2)
2 => 2
3 > 0b10.to_i
4 => 2

De inteiro para hexadecimal:

1 > 10.to_s(16)
2 => "a"

De hexadecimal para inteiro:

1 > 0xa.to_i
2 => 10

Tratamento de exceções

Exceções nos permitem “cercar” erros que acontecem no nosso programa (afinal, ninguém é perfeito, não é mesmo?) em um objeto que depois pode ser analisado e tomadas as devidas providências ao invés de deixar o erro explodir dentro do nosso código levando à resultados indesejados. Vamos gerar um erro de propósito para testar isso.

Lembram-se que Ruby tem uma tipagem forte, onde não podemos misturar os tipos de objetos? Vamos tentar misturar:

1 begin
2   numero = 1
3   string = "oi"
4   numero + string
5 rescue StandardError => exception
6   puts "Ocorreu um erro: #{exception}"
7 end

Rodando o programa, temos:

1 $ ruby exc.rb
2 Ocorreu um erro: String can’t be coerced into Fixnum

O programa gerou uma exceção no código contido entre begin e rescue interceptando o tipo de erro tratado pela exceção do tipo StandardError, em um objeto que foi transmitido para rescue, através da variável exception, onde pudemos verificar informações sobre o erro, imprimindo-o como uma String.

Se não quisermos especificar o tipo de exceção a ser tratada, podemos omitir o tipo, e verificar a classe da exceção gerada dessa maneira:

1 begin
2   numero = 1
3   string = "oi"
4   numero + string
5 rescue => exception
6   puts "Ocorreu um erro do tipo #{exception.class}: #{exception}"
7 end

Rodando o programa, temos:

1 $ ruby exc2.rb
2 Ocorreu um erro do tipo TypeError: String can’t be coerced into Fixnum

Podemos utilizar ensure como um bloco para ser executado depois de todos os rescues:

 1 begin
 2   numero = 1
 3   string = "oi"
 4   numero + string
 5 rescue => exception
 6   puts "Ocorreu um erro do tipo #{exception.class}: #{exception}"
 7 ensure
 8   puts "Lascou tudo."
 9 end
10 puts "Fim de programa."

Rodando o programa:

1 $ ruby exc3.rb
2 Ocorreu um erro do tipo TypeError: String can’t be coerced into Fixnum
3 Lascou tudo.
4 Fim de programa.

Isso é particularmente interessante se houver algum problema dentro de algum bloco de rescue:

 1 begin
 2   numero = 1
 3   string = "oi"
 4   numero + string
 5 rescue => exception
 6   puts "Ocorreu um erro do tipo #{exception.class}: #{exception}"
 7   puts msg
 8 ensure
 9   puts "Lascou tudo."
10 end
11 puts "Fim de programa."

Rodando o programa:

1 $ ruby exc4.rb
2 Ocorreu um erro do tipo TypeError: String can’t be coerced into Fixnum
3 Lascou tudo.
4 exc4.rb:7: undefined local variable or method ‘msg’ for main:Object (NameErro\
5 r)

Podemos ver que foi gerada uma nova exceção dentro do bloco do rescue e apesar do comando final com a mensagem “Fim de programa” não ter sido impressa pois a exceção “jogou” o fluxo de processamento para fora, o bloco do ensure foi executado.

Se por acaso desejarmos tentar executar o bloco que deu problema novamente, podemos utilizar retry:

1 numero1 = 1
2 numero2 = "dois"
3 begin
4   puts numero1 + numero2
5 rescue => exception
6   puts "Ops, problemas aqui (#{exception.class}), vou tentar de novo."
7   numero2 = 2
8   retry
9 end

Rodando o programa:

1 $ ruby retry.rb
2 Ops, problemas aqui (TypeError), vou tentar de novo.
3 3

Se desejarmos ter acesso a backtrace (a lista hierárquica das linhas dos programas onde o erro ocorreu), podemos utilizar:

 1 numero1 = 1
 2 numero2 = "dois"
 3 begin
 4   puts numero1 + numero2
 5 rescue => exception
 6   puts "Ops, problemas aqui (#{exception.class}), vou tentar de novo."
 7   puts exception.backtrace
 8   numero2 = 2
 9   retry
10 end

Rodando o programa, nesse caso chamado exc1.rb, vai nos retornar:

1 $ ruby backtrace.rb
2 Ops, problemas aqui (TypeError), vou tentar de novo.
3 backtrace.rb:4:in ‘+’
4 backtrace.rb:4
5 3

Disparando exceções

Podemos disparar exceções utilizando raise:

1 numero1 = 1
2 numero2 = 1
3 
4 begin
5   puts numero1 + numero2
6   raise Exception.new("esperava 3") if numero1+numero2!=3
7 rescue => exception
8   puts "Ops, problemas aqui (#{exception.class}), vou tentar de novo."
9 end

Descobrindo a exceção anterior

Podemos descobrir qual foi a exceção que foi disparada anteriormente utilizando cause, que nos dá acesso as nested exceptions (a partir da versão 2.1):

1 begin
2   begin
3     raise 'foo'
4   rescue Exception => foo
5     raise 'bar'
6   end
7 rescue Exception => bar
8   puts "a causa de #{bar} foi #{bar.cause}"
9 end

Para versões anteriores, dá para utilizar ou a gem cause ³.

Criando nossas próprias exceções

Se por acaso quisermos criar nossas próprias classes de exceções, é muito fácil, basta criá-las herdando de StandardError. Vamos criar uma que vamos disparar se um nome for digitado errado, NameNotEqual:

 1 class NameNotEqual < StandardError
 2   def initialize(current,expected)
 3     super "você digitou um nome inválido (#{current})! era esperado #{expecte\
 4 d}."
 5   end
 6 end
 7 
 8 begin
 9   correct = "eustaquio"
10   puts "digite o meu nome: "
11   name = gets.chomp
12   raise NameNotEqual.new(name,correct) if name!=correct
13   puts "digitou correto!"
14 rescue NameNotEqual => e
15   puts e
16 end

Rodando o programa e digitando qualquer coisa diferente de “eustaquio”:

1 $ ruby customexceptions.rb 
2 digite o meu nome: 
3 barizon
4 você digitou um nome inválido (barizon)! era esperado eustaquio.

Comparando exceções

Podemos fazer comparações entre duas exceções, como

1   > Exception.new == Exception.new
2   => true 

Elas vão ser diferentes se tiverem mensagens diferentes:

1   > Exception.new("hello") == Exception.new("world")
2   => false

Que funciona com a nossa exceção customizada demonstrada acima:

1   > NameNotEqual.new("eustaquio", "rangel") == NameNotEqual.new("eustaquio", \
2 "rangel")
3   => true 
4 
5   > NameNotEqual.new("eustaquio", "rangel") == NameNotEqual.new("taq", "range\
6 l")
7   => false

Utilizando catch e throw

Também podemos utilizar catch e throw para terminar o processamento quando nada mais é necessário, indicando através de um Symbol para onde o controle do código deve ser transferido (opcionalmente com um valor), indicado com catch, usando throw:

 1 def get_input
 2   puts "Digite algo (número termina):"
 3   resp = gets
 4   throw :end_of_response, resp if resp.chomp =~ /^\d+$/
 5   resp
 6 end
 7 
 8 num = catch(:end_of_response) do
 9   while true
10     get_input
11   end      
12 end
13 puts "Terminado com: #{num}"

Rodando o programa:

1 $ ruby catchthrow.rb
2 Digite algo (número termina):
3 oi
4 Digite algo (número termina):
5 123
6 Terminado com: 123

Estruturas de controle

Condicionais

if

É importante notar que tudo em Ruby acaba no fim – end – e vamos ver isso acontecendo bastante com nossas estruturas de controle. Vamos começar vendo nosso velho amigo if:

1 i = 10
2 if i == 10
3   puts "i igual 10"
4 else
5   puts "i diferente de 10"
6 end

Rodando o programa:

1   $ ruby if.rb
2   i igual 10

This is the end Beautiful friend This is the end My only friend, the end

Uma coisa bem interessante em Ruby é que podemos escrever isso de uma forma que podemos “ler” o código, se, como no caso do próximo exemplo, estivermos interessados apenas em imprimir a mensagem no caso do teste do ‘if’ ser verdadeiro:

1 > puts "i igual 10" if i == 10
2 => i igual 10

Isso é chamado de modificador de estrutura.

Também temos mais um nível de teste no if, o elsif:

1 i = 10
2 
3 if i > 10
4   puts "maior que 10"
5 elsif i == 10
6   puts "igual a 10"
7 else
8   puts "menor que 10"
9 end

Rodando o programa:

1 $ ruby elsif.rb
2 igual a 10

Podemos capturar a saída do teste diretamente apontando uma váriavel para ele:

 1 i = 10
 2 
 3 result =
 4 if i > 10
 5   "maior que 10"
 6 elsif i == 10
 7   "igual a 10"
 8 else
 9   "menor que 10"
10 end
11 
12 result

Rodando o programa:

1 $ ruby captureif.rb
2 "igual a 10"

unless

O unless é a forma negativa do if, e como qualquer teste negativo, pode trazer alguma confusão no jeito de pensar sobre eles. Particularmente gosto de evitar testes negativos quando pode-se fazer um bom teste positivo.

Vamos fazer um teste imaginando uma daquelas cadeiras de boteco e alguns sujeitos mais avantajados (em peso, seus mentes sujas):

 1 > peso = 150
 2 => 150
 3 
 4 > puts "pode sentar aqui" unless peso > 100
 5 => nil
 6 
 7 > peso = 100
 8 => 100
 9 
10 > puts "pode sentar aqui" unless peso > 100
11 => pode sentar aqui

Dá para lermos o comando como “diga ao sujeito que ele pode sentar aqui a menos que o peso dele for maior que 100 quilos”. Talvez um teste mais limpo seria:

 1 > peso = 150
 2 => 150
 3 
 4 > puts "pode sentar aqui" if peso <= 100
 5 => nil
 6 
 7 > peso = 100
 8 => 100
 9 
10 > puts "pode sentar aqui" if peso <= 100
11 => pode sentar aqui

Ler “diga ao sujeito que ele pode sentar aqui se o peso for menor ou igual a 100” talvez seja um jeito mais claro de fazer o teste, mas fica a critério de cada um e do melhor uso.

case

Podemos utilizar o case para fazer algumas comparações interessantes. Vamos ver como testar com Ranges:

 1 i = 10
 2 
 3 case i
 4 when 0..5
 5   puts "entre 0 e 5"
 6 when 6..10
 7   puts "entre 6 e 10"
 8 else
 9   puts "hein?"
10 end

Rodando o programa:

1 $ ruby case.rb
2 entre 6 e 10

No caso do case (redundância detectada na frase), a primeira coisa que ele compara é o tipo do objeto, nos permitindo fazer testes como:

 1 i = 10
 2 
 3 case i
 4 when Fixnum
 5   puts "Número!"
 6 when String
 7   puts "String!"
 8 else
 9   puts "hein???"
10 end

Rodando o programa:

1 $ ruby casetype.rb
2 Número!

Para provar que esse teste tem precedência, podemos fazer:

1 i = 10
2 
3 case i
4 when Fixnum
5   puts "Número!"
6 when (0..100)
7   puts "entre 0 e 100"
8 end

Rodando o programa:

1 $ ruby caseprec.rb
2 Número!

A estrutura case compara os valores de forma invertida, como no exemplo acima, Fixnum === e não i === Fixnum, não utilizando o operador == e sim o operador ===, que é implementado das seguintes formas:

Para módulos e classes (que vamos ver mais à frente), é comparado se o valor é uma instância do módulo ou classe ou de um de seus descendentes. No nosso exemplo, i é uma instância de Fixnum. Por exemplo:

1 > Fixnum === 1
2 => true
3 
4 > Fixnum === 1.23
5 => false

Para expressões regulares, é comparado se o valor “casou” com a expressão:

1 > /[0-9]/ === "123"
2 => true
3 
4 > /[0-9]/ === "abc"
5 => false

Para Ranges, é testado se o valor se inclui nos valores da Range (como no método include?):

1 > (0..10) === 1
2 => true
3 
4 > (0..10) === 100
5 => false

Loops

Antes de vermos os loops, vamos deixar anotado que temos algumas maneiras de interagir dentro de um loop:

1. break - sai do loop
2. next - vai para a próxima iteração
3. return - sai do loop e do método onde o loop está contido
4. redo - repete o loop do início, sem reavaliar a condição ou pegar o próximo elemento

Vamos ver exemplos disso logo na primeira estrutura a ser estudada, o while.

while

Faça enquanto:

1 i = 0
2 
3 while i < 5
4   puts i
5   i += 1
6 end

Rodando:

1 $ ruby while.rb
2 0
3 1
4 2
5 3
6 4

for

O for pode ser utilizado junto com um iterador para capturar todos os seus objetos e enviá-los para o loop (que nada mais é do que um bloco de código):

1 for i in (0..5)
2   puts i
3 end

Rodando:

1 $ ruby for.rb
2 0
3 1
4 2
5 3
6 4
7 5

Vamos aproveitar que é um loop bem simples e utilizar os comandos para interagir mostrados acima (mesmo que os exemplos pareçam as coisas mais inúteis e sem sentido do mundo - mas é para efeitos didáticos, gente!), menos o return onde precisaríamos de um método e ainda não chegamos lá. Vamos testar primeiro o break:

1 for i in (0..5)
2   break if i == 3
3   puts i
4 end

Rodando:

1 $ ruby for.rb
2 0
3 1
4 2

Agora o next:

1 for i in (0..5)
2   next if i == 3
3   puts i
4 end

Rodando:

1 $ ruby next.rb
2 0
3 1
4 2
5 4
6 5

Agora o redo:

1 for i in (0..5)
2   redo if i == 3
3   puts i
4 end

Rodando:

1 $ ruby for.rb
2 0
3 1
4 2
5 for.rb:2: Interrupt
6 from for.rb:1:in ‘each’
7 from for.rb:1

Se não interrompermos com Ctrl+C, esse código vai ficar funcionando para sempre, pois o redo avaliou o loop novamente mas sem ir para o próximo elemento do iterador.

until

O “faça até que” pode ser utilizado dessa maneira:

1 i = 0
2 
3 until i==5
4   puts i
5   i += 1
6 end

Rodando:

1 $ ruby until.rb
2 0
3 1
4 2
5 3
6 4

Operadores lógicos

Temos operadores lógicos em Ruby em duas formas: !, &&, || e not, and, or. Eles se diferenciam pela precedência: os primeiros tem precedência mais alta que os últimos sobre os operadores de atribuição. Exemplificando:

 1 > a = 1
 2 => 1
 3 
 4 > b = 2
 5 => 2
 6 
 7 > c = a && b
 8 => 2
 9 
10 > c
11 => 2
12 
13 > d = a and b
14 => 2
15 
16 > d
17 => 1

A variável c recebeu o resultado correto de a && b, enquanto que d recebeu a atribuição do valor de a e seria a mesma coisa escrito como (d = a) and b. O operador avalia o valor mais à direita somente se o valor mais a esquerda não for falso. É a chamada operação de “curto-circuito”.

Outro exemplo de “curto-circuito” é o operador ||= (chamado de “ou igual” ou “pipe duplo igual”, que funciona da seguinte maneira:

 1 > a ||= 10
 2 => 10 
 3 
 4 > a
 5 => 10 
 6 
 7 > a ||= 20
 8 => 10 
 9 
10 > a
11 => 10

O que ocorre ali é o seguinte: é atribuído o valor à variável apenas se o valor dela for false ou nil, do contrário, o valor é mantido. Essa é uma forma de curto-circuito pois seria a mesma coisa que:

1 a || a = 10

que no final das contas retorna a se o valor for diferente de false e nil ou, do contrário, faz a atribuição do valor para a variável. Seria basicamente

1 a || (a = 10)

Procs e lambdas

Procs são blocos de código que podem ser associados à uma variável, dessa maneira:

 1 > vezes3 = Proc.new { |valor| valor * 3 }
 2 => #<Proc:0xb7d959c4@(irb):1>
 3 
 4 > vezes3.call(3)
 5 => 9
 6 
 7 > vezes3.call(4)
 8 => 12
 9 
10 > vezes3.call(5)
11 => 15

Comportamento similar pode ser alcançada usando lambda:

 1 > vezes5 = lambda { |valor| valor * 5 }
 2 => #<Proc:0xb7d791d4@(irb):5>
 3 
 4 > vezes5.call(5)
 5 => 25
 6 
 7 > vezes5.call(6)
 8 => 30
 9 
10 > vezes5.call(7)
11 => 35

Pudemos ver que precisamos executar call para chamar a Proc, mas também podemos utilizar o atalho []:

1 > vezes5[8]
2 => 40

E também o atalho ., menos comum:

1 > vezes5.(5)
2 => 25

Podemos utilizar uma Proc como um bloco, mas para isso precisamos converte-la usando &:

1 > (1..5).map &vezes5
2 => [5, 10, 15, 20, 25]

Importante notar duas diferenças entre Procs e lambdas:

A primeira diferença, é a verificação de argumentos. Em lambdas a verificação é feita e gera uma exceção:

 1 > pnew = Proc.new { |x, y| puts x + y }
 2 => #<Proc:0x8fdaf7c@(irb):7>
 3 
 4 > lamb = lambda { |x, y| puts x + y }
 5 => #<Proc:0x8fd7aac@(irb):8 (lambda)>
 6 
 7 > pnew.call(2, 4, 11)
 8 => nil
 9 
10 > lamb.call(2, 4, 11)
11 ArgumentError: wrong number of arguments (3 for 2)

A segunda diferença é o jeito que elas retornam. O retorno de uma Proc retorna de dentro de onde ela está, como nesse caso:

1 def testando_proc
2   p = Proc.new { return "Bum!" }
3   p.call
4   "Nunca imprime isso."
5 end
6 
7 puts testando_proc

Rodando:

1 $ ruby procret.rb
2 Bum!

Enquanto que em uma lambda, retorna para onde foi chamada:

1 def testando_lambda
2   l = lambda { return "Oi!" }
3   l.call
4   "Imprime isso."
5 end
6 
7 puts testando_lambda

Rodando:

1 $ ruby lambret.rb
2 Imprime isso.

A partir do Ruby 1.9, temos suporte à sintaxe “stabby proc”:

1 > p = -> x,y { x* y }
2 
3 > puts p.call(2,3)
4 => 6

E também ao método curry, que decompõe uma lambda em uma série de outras lambdas. Por exemplo, podemos ter uma lambda que faça multiplicação:

1 > mult = lambda { |n1, n2| n1 * n2 }
2 => #<Proc:0x8fef1fc@(irb):13 (lambda)>
3 
4 > mult.(2, 3)
5 => 6

E podemos utilizar o método curry no final e ter o seguinte resultado:

1 > mult = lambda { |n1, n2| n1 * n2 }.curry
2 => #<Proc:0x8ffe4e0 (lambda)>
3 
4 > mult.(2).(3)
5 => 6

Reparem que o método call (na forma de .()) foi chamado duas vezes, primeiro com 2 e depois com 3, pois o método curry inseriu uma lambda dentro da outra, como se fosse:

1 > multi = lambda { |x| lambda { |y| x * y } }
2 => #<Proc:0x901756c@(irb):23 (lambda)>
3 
4 > mult.(2).(3)
5 => 6

Isso pode ser útil quando você deseja criar uma lambda a partir de outra, deixando um dos parâmetros fixo, como por exemplo:

 1 > mult = lambda { |n1, n2| n1 * n2 }.curry
 2 => #<Proc:0x901dd40 (lambda)>
 3 
 4 > dobro = mult.(2)
 5 => #<Proc:0x901c058 (lambda)>
 6 
 7 > triplo = mult.(3)
 8 => #<Proc:0x9026904 (lambda)>
 9 
10 > dobro.(8)
11 => 16
12 
13 > triplo.(9)
14 => 27

Iteradores

Agora que conhecemos os tipos básicos de Ruby, podemos focar nossa atenção em uma característica bem interessante deles: muitos, senão todos, tem coleções ou características que podem ser percorridas por métodos iteradores.

Um iterador percorre uma determinada coleção, que o envia o valor corrente, executando algum determinado procedimento, que em Ruby é enviado como um bloco de código e contém o módulo (hein?) Enumerable, que dá as funcionalidades de que ele precisa.

Dos métodos mais comuns para percorrer uma coleção, temos each, que significa “cada”, e que pode ser lido “para cada elemento da coleção do meu objeto, execute esse bloco de código”, dessa maneira:

1 > [1, 2, 3, 4, 5].each { |e| puts "o array contem o numero #{e}" }
2 
3 => array contem o numero 1
4 => array contem o numero 2
5 => array contem o numero 3
6 => array contem o numero 4
7 => array contem o numero 5

Ou seja, para cada elemento do Array, foi executado o bloco - atenção aqui - passando o elemento corrente como parâmetro, recebido pelo bloco pela sintaxe |<parâmetro>|. Podemos ver que as instruções do nosso bloco, que no caso só tem uma linha (e foi usada a convenção de { e }), foram executadas com o valor recebido como parâmetro.

Esse mesmo código pode ser otimizado e refatorado para ficar mais de acordo com a sua finalidade. Não precisamos de um loop de 1 até 5? A maneira mais adequada seria criar uma Range com esse intervalo e executar nosso iterador nela:

1 > (1..5).each { |e| puts "a range contem o numero #{e}" }
2 
3 => range contem o numero 1
4 => range contem o numero 2
5 => range contem o numero 3
6 => range contem o numero 4
7 => range contem o numero 5

Inclusive, podemos também utilizar times em um Fixnum, que se comporta como uma coleção nesse caso, que começa em 0:

1 5.times { |e| puts "numero #{e}" }
2 
3 => numero 0
4 => numero 1
5 => numero 2
6 => numero 3
7 => numero 4

Um Array só faria sentido nesse caso se os seus elementos não seguissem uma ordem lógica que pode ser expressa em um intervalo de uma Range! Quaisquer sequências que podem ser representadas fazem sentido em usar uma Range. Se por acaso quiséssemos uma lista de números de 1 até 21, em intervalos de 3, podemos utilizar:

 1 > (1..21).step(2).each { |e| puts "numero #{e}" }
 2 
 3 => numero 1
 4 => numero 3
 5 => numero 5
 6 => numero 7
 7 => numero 9
 8 => numero 11
 9 => numero 13
10 => numero 15
11 => numero 17
12 => numero 19
13 => numero 21

Em Rails utilizamos bastante a estrutura for <objeto> in <coleção>, da seguinte forma:

 1 > col = %w(uma lista de Strings para mostrar o for)
 2 > for str in col
 3 >     puts str
 4 > end
 5 
 6 => uma
 7 => lista
 8 => de
 9 => Strings
10 => para
11 => mostrar
12 => o
13 => for

Selecionando elementos

Vamos supor que queremos selecionar alguns elementos que atendam alguma condição nos nossos objetos, por exemplo, selecionar apenas os números pares de uma coleção:

1 > (1..10).select { |e| e.even? }
2 => [2, 4, 6, 8, 10]

Vamos testar com uma Hash:

1 { 1 => "um", 2 => "dois", 3 => "tres" }.select { |chave, valor| valor.length \
2 > 2 }
3 => {2=>"dois", 3=>"tres"}

Selecionando os elementos que não atendem uma condição

O contrário da operação acima pode ser feito com reject:

1 > (0..10).reject {|valor| valor.even?}
2 => [1, 3, 5, 7, 9]

Nada que a condição alterada do select também não faça.

Processando e alterando os elementos

Vamos alterar os elementos do objeto com o método map:

 1 > (0..10).map { |valor| valor * 2 }
 2 => [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
 3 
 4 > %w(um dois tres quatro cinco seis sete oito nove dez).map { |valor| "numero\
 5  #{valor}" }
 6 => ["numero um", "numero dois", "numero tres", "numero quatro",
 7 "numero cinco", "numero seis", "numero sete", "numero oito", "numero nove",
 8 "numero dez"]
 9 
10 > { 1 => "um", 2 => "dois", 3 => "tres" }.map { |chave, valor| "numero #{valo\
11 r}" }
12 => ["numero um", "numero dois", "numero tres"]

Detectando condição em todos os elementos

Vamos supor que desejamos detectar se todos os elementos da coleção atendem uma determinada condição com o método all?:

1 > (0..10).all? { |valor| valor > 1 }
2 => false
3 
4 > (0..10).all? { |valor| valor > 0 }
5 => false

Detectando se algum elemento atende uma condição

Vamos testar se algum elemento atende uma determinada condição com o método any?:

1 > (0..10).any? { |valor| valor == 3 }
2 => true
3 
4 > (0..10).any? { |valor| valor == 30 }
5 => false

Nesse caso específico, poderíamos ter escrito dessa forma também:

1 > (0..10).include?(3)
2 => true
3 
4 > (0..10).include?(30)
5 => false

Apesar da facilidade com um teste simples, o método any? é muito prático no caso de procurarmos, por exemplo, um determinado objeto com um determinado valor de retorno em algum de seus métodos.

Detectar e retornar o primeiro elemento que atende uma condição

Se além de detectar quisermos retornar o elemento que atende à uma condição, podemos utilizar o método detect?:

1 > (0..10).detect {|valor| valor>0 && valor%4==0}
2 => 4

Detectando os valores máximo e mínimo

Podemos usar max e min para isso:

1 > (0..10).max
2 => 10
3 > (0..10).min
4 => 0

É interessante notar que podemos passar um bloco onde serão comparados os valores para teste através do operador <=> (conhecido por “navinha”):

1 > %w(joao maria antonio).max { |elemento1, elemento2| elemento1.length <=> el\
2 emento2.length }
3 => "antonio"
4 
5 > %w(joao maria antonio).min { |elemento1, elemento2| elemento1.length <=> el\
6 emento2.length }
7 => "joao"

Olhem que interessante comparando valores de Hashes:

1 > { :joao => 33, :maria => 30, :antonio => 25 }.max { |elemento1, elemento2| \
2 elemento1[1] <=> elemento2[1] }
3 => [:joao, 33]
4 
5 > { :joao => 33, :maria => 30, :antonio => 25 }.min { |elemento1, elemento2| \
6 elemento1[1] <=> elemento2[1] }
7 => [:antonio, 25]

A partir da versão 2.4, a diferença entre os métodos min e max é brutal. Vamos rodar o seguinte código em ambas as versões (ok, a parte de benchmarks ainda está bem na frente aqui no livro, mas vamos considerar somente os resultados aqui):

1 require 'benchmark'
2 
3 a = (1..1_000_000).to_a.shuffle
4 
5 Benchmark.bm do |x|
6   x.report("min:") { 1000.times { a.min } }
7   x.report("max:") { 1000.times { a.max } }
8 end

Primeiro no Ruby 2.3.x:

1    ruby code/basico/minmax.rb 
2          user     system      total        real
3   min: 60.410000   0.020000  60.430000 ( 60.438673)
4   max: 59.420000   0.030000  59.450000 ( 59.461824)

Agora no Ruby 2.4.x:

1   $ ruby code/basico/minmax.rb 
2          user     system      total        real
3   min:  1.750000   0.000000   1.750000 (  1.753964)
4   max:  1.940000   0.000000   1.940000 (  1.943247)

Uau. De 60 segundos para menos de 2!

Acumulando os elementos

Podemos acumular os elementos com inject, onde vão ser passados um valor acumulador e o valor corrente pego do iterador. Se desejarmos saber qual é a soma de todos os valores da nossa Range:

1 > (0..10).inject { |soma, valor| soma + valor }
2 => 55

Podemos passar também um valor inicial:

1 > (0..10).inject(100) { |soma, valor| soma + valor }
2 => 155

E também podemos passar o método que desejamos utilizar para combinação como um símbolo:

1 > (0..10).inject(:+)
2 => 55
3 
4 > (0..10).inject(100, :+)
5 => 155

Para o pessoal que adora JavaScript, temos um alias simpático para inject, reduce:

1 > (0..10).reduce(:+)
2 => 55
3 
4 > (0..10).reduce(100, :+)
5 => 155

E a partir da versão 2.4, temos o método sum:

1   > (1..10).sum
2   => 55 
3   
4   > (1..10).sum(100)
5   => 155 

Dividir a coleção em dois Arrays obedecendo uma condição

Vamos separar os números pares dos ímpares usando partition:

1 > (0..10).partition { |valor| valor.even? }
2 => [[0, 2, 4, 6, 8, 10], [1, 3, 5, 7, 9]]

Percorrendo os elementos com os índices

Vamos ver onde cada elemento se encontra com each_with_index:

 1 > (0..10).each_with_index { |item, indice| puts "#{item} indice #{indice}" }
 2 
 3 => 0 indice 0
 4 => 1 indice 1
 5 => 2 indice 2
 6 => 3 indice 3
 7 => 4 indice 4
 8 => 5 indice 5
 9 => 6 indice 6
10 => 7 indice 7
11 => 8 indice 8
12 => 9 indice 9
13 => 10 indice 10

Ordenando uma coleção

Vamos ordenar um Array de Strings usando sort:

1 > %w(joao maria antonio).sort
2 => ["antonio", "joao", "maria"]

Podemos ordenar de acordo com algum critério específico, passando um bloco e usando sort_by:

1 > %w(antonio maria joao).sort_by { |nome| nome.length }
2 => ["joao", "maria", "antonio"]

Combinando elementos

Podemos combinar elementos com o método zip:

1 > (1..10).zip((11..20))
2 => [[1, 11], [2, 12], [3, 13], [4, 14], [5, 15], [6, 16], [7, 17], [8, 18], [\
3 9, 19], [10, 20]]
4 
5 > (1..10).zip((11..20),(21..30))
6 => [[1, 11, 21], [2, 12, 22], [3, 13, 23], [4, 14, 24], [5, 15, 25], [6, 16, \
7 26], [7, 17, 27], [8, 18, 28], [9, 19, 29], [10, 20, 30]]

Também podemos usar combination:

 1 > a = %w(john paul george ringo)
 2 => ["john", "paul", "george", "ringo"]
 3 
 4 > a.combination(2)
 5 => #<Enumerable::Enumerator:0xb7d711a0>
 6 
 7 > a.combination(2).to_a
 8 => [["john", "paul"], ["john", "george"], ["john", "ringo"], ["paul", "george\
 9 "], ["paul", "ringo"], ["george", "ringo"]]
10 
11 a.combination(2) { |comb| puts "combinando #{comb[0]} com #{comb[1]}" }
12 
13 => combinando john com paul
14 => combinando john com george
15 => combinando john com ringo
16 => combinando paul com george
17 => combinando paul com ringo
18 => combinando george com ringo

Ou permutation:

 1 > a = %w(john paul george ringo)
 2 => ["john", "paul", "george", "ringo"]
 3 > a.permutation(2)
 4 => #<Enumerable::Enumerator:0xb7ce41c4>
 5 > a.permutation(2).to_a
 6 => [["john", "paul"], ["john", "george"], ["john", "ringo"], ["paul", "john"]\
 7 , ["paul", "george"], ["paul", "ringo"], ["george", "john"], ["george", "paul\
 8 "], ["george", "ringo"], ["ringo", "john"], ["ringo", "paul"], ["ringo", "geo\
 9 rge"]]
10 
11 > a.permutation(2) { |comb| puts "combinando #{comb[0]} com #{comb[1]}" }
12 
13 => combinando john com paul
14 => combinando john com george
15 => combinando john com ringo
16 => combinando paul com john
17 => combinando paul com george
18 => combinando paul com ringo
19 => combinando george com john
20 => combinando george com paul
21 => combinando george com ringo
22 => combinando ringo com john
23 => combinando ringo com paul
24 => combinando ringo com george

Ou product:

 1 > beatles = %w(john paul george ringo)
 2 => ["john", "paul", "george", "ringo"]
 3 > stooges = %w(moe larry curly shemp)
 4 => ["moe", "larry", "curly", "shemp"]
 5 
 6 beatles.product(stooges)
 7 => [["john", "moe"], ["john", "larry"], ["john", "curly"], ["john", "shemp"],\
 8  ["paul", "moe"], ["paul", "larry"], ["paul", "curly"], ["paul", "shemp"], ["\
 9 george", "moe"], ["george", "larry"], ["george", "curly"], ["george", "shemp"\
10 ], ["ringo", "moe"], ["ringo", "larry"], ["ringo", "curly"], ["ringo", "shemp\
11 "]]

Percorrendo valores para cima e para baixo

Podemos usar upto, downto e step:

 1 > 1.upto(5) { |num| print num, " " }
 2 => 1 2 3 4 5 
 3 => 1
 4 
 5 > 5.downto(1) { |num| print num, " " }
 6 => 5 4 3 2 1 
 7 => 5
 8 
 9 > 1.step(10,2) { |num| print num, " " }
10 => 1 3 5 7 9 
11 => 1

Filtrando com o grep

Um método muito útil para coleções é o método grep (mesmo nome do utilitário de linha de comando - muito útil, por sinal). Podemos, por exemplo, encontrar determinadas Strings em um Array, no exemplo abaixo, todas as que tem comprimento entre 3 e 7 caracteres:

1   > %w(eustaquio rangel).grep(/\A\w{3,7}\z/)
2   => ["rangel"] 

Selecionar todos os elementos que sejam iguais ao informado:

1   > [1, 0, 1, 1, 0].grep(0)
2   => [0, 0] 

Encontrar os objetos de uma determinada classe ou módulo:

1   > [1, "String", 1.23, :aqui].grep(Numeric)
2   => [1, 1.23]

Selecionar os valores de uma determinada faixa, no exemplo abaixo, criando um Array com 10 elementos preechidos por números de até 10, selecionando somente os únicos que estão entre 5 e 10:

1   > Array.new(10) { rand(10) }.grep(5..10).uniq
2   => [7, 5]   

Utilizando uma lambda para selecionar determinada condição (no exemplo, as Strings cujo comprimento é maior que 3):

1   > lamb = ->(str) { str.length > 3 }
2   => #<Proc:0x00000003101ff0@(irb):47 (lambda)> 
3  
4   > %w(eustaquio taq rangel).grep(lamb)
5   => ["eustaquio", "rangel"]

E que tal fazer um sorteador de números da Megasena (se alguém ganhar, lembra de mim!) em apenas uma linha?

1   > (1..60).to_a.shuffle.take(6)
2   => [47, 8, 49, 19, 58, 22] 
3   
4   > (1..60).to_a.shuffle.take(6)
5   => [38, 17, 16, 29, 28, 37] 
6   
7   > (1..60).to_a.shuffle.take(6)
8   => [20, 28, 30, 16, 43, 52] 

Inspecionando no encadeamento de métodos

Um método bem útil para o caso de precisarmos inspecionar ou registrar o conteúdo de algum objeto durante algum encadeamento de iteradores é o método tap. Vamos supor que você tem o seguinte código:

1 > (0..10).select { |num| num.even? }.map { |num| num * 2 }
2 => [0, 4, 8, 12, 16, 20]

Isso nada mais faz do que separar os números pares e multiplicá-los por 2, mas imaginemos que a coleção inicial não é formada por números e sim por objetos da nossa tabela de funcionários onde vamos selecionar somente algumas pessoas que atendem determinadas condições (usando o select) e reajustar o seu salário baseado em várias regras complexas (o map), e algum problema está ocorrendo na seleção.

O jeito convencional é criar uma variável temporária armazenando o conteúdo retornado pelo select e a imprimirmos, executando o map logo em seguida. Ou podemos fazer assim:

1 > (0..10).select { |num| num.even? }.tap{ |col| p col }.map { |num| num * 2 }
2 => [0, 2, 4, 6, 8, 10]
3 => [0, 4, 8, 12, 16, 20]

Isso nos mostra o conteúdo antes de ser enviado para o próximo método encadeado.

Métodos

Podemos definir métodos facilmente em Ruby, usando def, terminando (como sempre) com end:

1 > def diga_oi
2 >     puts "Oi!"
3 > end
4 > diga_oi
5 => "Oi!"

Executando esse código, será impresso Oi!. Já podemos reparar que os parênteses não são obrigatórios para chamar um método em Ruby.

Retornando valores

Podemos retornar valores de métodos com ou sem o uso de return. Quando não utilizamos return, o que ocorre é que a última expressão avaliada é retornada, como no exemplo:

1 > def vezes(p1, p2)
2 >     p1 * p2
3 > end
4 > puts vezes(2, 3)
5 => 6

No caso, foi avaliado por último p1 * p2, o que nos dá o resultado esperado. Também podemos retornar mais de um resultado, que na verdade é apenas um objeto, sendo ele complexo ou não, dando a impressão que são vários, como no exemplo que vimos atribuição em paralelo.

Vamos construir um método que retorna cinco múltiplos de um determinado número:

1 > def cinco_multiplos(numero)
2 >     (1..5).map { |valor| valor * numero }
3 > end
4 
5 > v1, v2, v3, v4, v5 = cinco_multiplos(5)
6 > puts "#{v1}, #{v2}, #{v3}, #{v4}, #{v5}"
7 => 5, 10, 15, 20, 25

Enviando valores

Antes de mais nada, fica a discussão sobre a convenção sobre o que são parâmetros e o que são argumentos, convencionando-se à:

Parâmetros são as variáveis situadas na assinatura de um método; Argumentos são os valores atribuídos aos parâmetros

Vimos acima um exemplo simples de passagem de valores para um método, vamos ver outro agora:

1 > def vezes(n1, n2)
2 >     n1 * n2
3 > end
4 > puts vezes(3, 4)
5 => 12

Podemos contar quantos parâmetros um método recebe usando arity:

1 > def vezes(n1, n2)
2 >     n1 * n2
3 > end
4 > puts vezes(3, 4)
5 > puts "o metodo recebe #{method(:vezes).arity} parametros"

Métodos também podem receber parâmetros default, como por exemplo:

1 > def oi(nome = "Forasteiro")
2 >     puts "Oi, #{nome}!"
3 > end
4 > oi("TaQ")
5 => Oi, TaQ!
6 > oi
7 => Oi, Forasteiro!

E também valores variáveis, bastando declarar o nosso método como recebendo um parâmetro com o operador splat (asterisco, *) antes do nome do parâmetro:

 1 > def varios(*valores)
 2 >     valores.each { |valor| puts "valor=#{valor}" }
 3 >     puts "-"*25
 4 > end
 5 
 6 => varios(1)
 7 => valor=1
 8 => -------------------------
 9 => varios(1,2)
10 => valor=1
11 => valor=2
12 => -------------------------
13 => varios(1,2,3)
14 => valor=1
15 => valor=2
16 => valor=3
17 => -------------------------

O operador splat pode parecer meio estranho, mas ele nada mais faz, na definição do método, do que concentrar todos os valores recebidos em um Array, como pudemos ver acima. Pensem nele como um buraco negro que suga todos os valores!

Quando usamos o splat na frente do nome de uma variável que se comporta como uma coleção, ele “explode” os seus valores, retornando os elementos individuais:

 1 > array = %w(um dois tres)
 2 => ["um", "dois", "tres"]
 3 
 4 > p *array
 5 => "um"
 6 => "dois"
 7 => "tres"
 8 => nil
 9 
10 > hash = { :um => 1, :dois => 2, :tres => 3 }
11 => { :um => 1, :dois => 2, :tres => 3 }
12 
13 > p *hash
14 => [:tres, 3]
15 => [:um, 1]
16 => [:dois, 2]
17 => nil

Podemos fazer uso dos argumentos nomeados (keyword arguments), indicando que o método vai receber os seus valores identificados:

1   > def mostra(a:, b:)
2   >   puts "a é igual #{a}, b é igual #{b}"
3   > end
4   > mostra(a: 1, b: 2)
5   => a é igual 1, b é igual 2
6   > mostra(b: 2, a: 1)
7   => a é igual 1, b é igual 2

Do modo definido acima, ambos os argumentos são obrigatórios:

1   > mostra(b: 2)
2   ArgumentError: missing keyword: a
3   	from (irb):1:in `mostra'

Podemos também especificar valores default para eles:

1   def mostra(a: 1, b: 2)
2      puts "a é igual #{a}, b é igual #{b}"
3   end
4   > mostra(b: 2)
5   => a é igual 1, b é igual 2

E também misturar com os argumentos tradicionais:

1   > def mostra(a, b: 2)
2   >   puts "a é igual #{a}, b é igual #{b}"
3   > end
4   > mostra(1, b: 2)
5   => a é igual 1, b é igual 2

Importante notar que a definição do método retorna um símbolo com o nome do método, o que nos permite chamar ele mais tarde direto por essa referência:

1   > met = def mostra(a, b: 2)
2   >   puts "a é igual #{a}, b é igual #{b}"
3   > end
4   > send(met, 1, b: 10)
5   => a é igual 1, b é igual 10

Enviando e processando blocos e Procs

Como vimos com iteradores, podemos passar um bloco para um método, e para o executarmos dentro do método, usamos yield:

 1 > def executa_bloco(valor)
 2 >     yield(valor)
 3 > end
 4 
 5 > executa_bloco(2) { |valor| puts valor * valor }
 6 => 4
 7 
 8 > executa_bloco(3) { |valor| puts valor * valor }
 9 => 9
10 
11 > executa_bloco(4) { |valor| puts valor * valor }
12 => 16

Podemos usar block_given? para detectar se um bloco foi passado para o método:

1 > def executa_bloco(valor)
2 >     yield(valor) if block_given?
3 > end
4 > executa_bloco(2) {|valor| puts valor*valor}
5 => 4
6 > executa_bloco(3)
7 > executa_bloco(4) {|valor| puts valor*valor}
8 => 16

Podemos também converter um bloco em uma Proc especificando o nome do último parâmetro com & no começo:

1 > def executa_bloco(valor, &proc)
2 >     puts proc.call(valor)
3 > end
4 > executa_bloco(2) { |valor| valor * valor }
5 => 4

Valores são transmitidos por referência

Como recebemos referências do objeto nos métodos, quaisquer alterações que fizermos dentro do método refletirão fora, como já vimos um pouco acima quando falando sobre variáveis. Vamos comprovar:

1 > def altera(valor)
2 >     valor.upcase!
3 > end
4 > string = "Oi, mundo!"
5 > altera(string)
6 > puts string
7 => "OI, MUNDO!"

Interceptando exceções direto no método

Uma praticidade grande é usarmos o corpo do método para capturarmos uma exceção, sem precisar abrir um bloco com begin e end:

1 > def soma(valor1, valor2)
2 >     valor1 + valor2
3 > rescue
4 >     nil
5 > end
6 > puts soma(1, 2) 
7 => 3
8 > puts soma(1, :um) 
9 => nil

Também podemos utilizar o rescue direto em um modificador de estrutura, como em:

1   > value = soma(1, nil) rescue nil
2   > => nil 

Vale aqui lembrar que temos uma diferença de performance utilizando rescue dessa maneira, onde podemos utilizar o operador ternário:

 1 require 'benchmark'
 2 
 3 limit = 1_000_000
 4 str   = nil
 5 
 6 Benchmark.bm do |x|
 7   x.report("rescue") do 
 8     limit.times { str.upcase rescue nil } 
 9   end
10   x.report("ternário") do 
11     limit.times { str ? str.upcase : nil } 
12   end
13 end

Rodando o programa, podemos ver que a diferença em utilizar o ternário é mais brutal que escutar “Abyssal Gates”, do Krisiun:

1   $ ruby code/basico/rescue.rb 
2          user     system      total        real
3   rescue    1.850000   0.000000   1.850000 (  1.858982)
4   ternário  0.060000   0.000000   0.060000 (  0.058927)

Então, se performance é um problema, considere em evitar utilizar o rescue dessa maneira.

Métodos destrutivos e predicados

Também podemos utilizar os caracteres ! e ? no final dos nomes dos nossos métodos. Por convenção, métodos com ! no final são chamados de métodos destrutivos e com ? no final são chamados de métodos predicados e são utilizados para testar algo e devem ter retorno booleano, retornando true ou false:

 1 > def revup!(str)
 2 >     str.reverse!.upcase!
 3 > end
 4 > str = "teste"
 5 
 6 > puts str.object_id
 7 => 74439960
 8 
 9 > revup!(str)
10 => ETSET
11 
12 > puts str
13 => ETSET
14 
15 > puts str.object_id
16 => 74439960
17 
18 > def ok?(obj)
19 >    !obj.nil?
20 > end
21 
22 > puts ok?(1)
23 => true
24 
25 > puts ok?("um")
26 => true
27 
28 > puts ok?(:um)
29 => true
30 
31 > puts ok?(nil)
32 => false

Podemos simular argumentos nomeados usando uma Hash:

 1 > def test(args)
 2 >     one = args[:one]
 3 >     two = args[:two]
 4 >     puts "one: #{one} two: #{two}"
 5 > end
 6 
 7 > test(one: 1, two: 2)
 8 => one: 1 two: 2
 9 
10 > test(two: 2, one: 1)
11 => one: 1 two: 2

Também podemos capturar um método como se fosse uma Proc:

 1 class Teste
 2   def teste(qtde)
 3     qtde.times { puts "teste!" }
 4   end
 5 end
 6 
 7 t = Teste.new
 8 m = t.method(:teste)
 9 p m
10 m.(3)
11 p m.to_proc

Rodando o programa:

1 $ ruby capture.rb
2 #<Method: Teste#teste>
3 teste!
4 teste!
5 teste!
6 #<Proc:0x8d3c4b4 (lambda)>

Como podemos ver, o resultado é um objeto do tipo Method, mas que pode ser convertido em uma Proc usando o método to_proc.

E agora um método de nome totalmente diferente usando o suporte para encodings do Ruby a partir das versões 1.9.x:

1 module Enumerable
2   def ∑
3     self.inject { |memo, val| memo += val }
4   end
5 end
6 
7 puts [1,2,3].∑
8 puts (0..3).∑

Rodando o programa:

1 $ ruby encodingmeth.rb
2 6
3 6

Uau! Para quem quiser inserir esses caracteres malucos no Vim, consulte o help dos digraphs com :help digraphs. Esse do exemplo é feito usando, no modo de inserção, CTRL+K +Z.

Classes e objetos

Como bastante coisas em Ruby são objetos, vamos aprender a criar os nossos. Vamos fazer uma classe chamada Carro, com algumas propriedades:

 1 class Carro
 2   def initialize(marca,modelo,cor,tanque)
 3     @marca  = marca
 4     @modelo = modelo
 5     @cor    = cor
 6     @tanque = tanque
 7   end
 8 end
 9 corsa = Carro.new(:chevrolet, :corsa, :preto, 50)
10 p corsa
11 puts corsa

Rodando o programa:

1 $ ruby carro1.rb
2 #<Carro:0x894c674 @marca=:chevrolet, @modelo=:corsa, @cor=:preto, @tanque=50>
3 #<Carro:0x894c674>

Para criarmos uma classe, usamos a palavra-chave class, seguida pelo nome da classe.

Segundo as convenções de Ruby, nos nomes dos métodos deve-se usar letras minúsculas separando as palavras com um sublinhado (_), porém nos nomes das classes é utilizado camel case, da mesma maneira que em Java, com maiúsculas separando duas ou mais palavras no nome da classe. Temos então classes com nomes como MinhaClasse, MeuTeste, CarroPersonalizado.

As propriedades do nosso objeto são armazenadas no que chamamos de variáveis de instância, que são quaisquer variáveis dentro do objeto cujo nome se inicia com @. Se fizermos referência para alguma que ainda não foi criada, ela será. Podemos inicializar várias dessas variáveis dentro do método initialize, que é o construtor do nosso objeto, chamado após o método new, que aloca espaço na memória para o objeto sendo criado.

Não temos métodos destrutores em Ruby, mas podemos associar uma Proc para ser chamada em uma instância de objeto cada vez que ela for limpa pelo garbage collector. Vamos verificar isso criando o arquivo destructor.rb:

1 > string = "Oi, mundo!"
2 > ObjectSpace.define_finalizer(string,lambda {|id| puts "Estou terminando o o\
3 bjeto #{id}"})

E agora rodando, o que vai fazer com que todos os objetos sejam destruídos no final:

1 $ ruby destructor.rb 
2 Estou terminando o objeto 78268620

Pudemos ver acima que usando puts para verificar o nosso objeto, foi mostrada somente a referência dele na memória. Vamos fazer um método novo na classe para mostrar as informações de uma maneira mais bonita. Lembram-se que em conversões utilizamos um método chamado to_s, que converte o objeto em uma String?

Vamos criar um para a nossa classe:

 1 class Carro
 2   def initialize(marca,modelo,cor,tanque)
 3     @marca  = marca
 4     @modelo = modelo
 5     @cor    = cor
 6     @tanque = tanque
 7   end
 8 
 9   def to_s
10     "Marca:#{@marca} Modelo:#{@modelo} Cor:#{@cor} Tanque:#{@tanque}"
11   end
12 end
13 
14 corsa = Carro.new(:chevrolet,:corsa,:preto,50)
15 p corsa
16 puts corsa

Vamos ver o comportamento nas versões 1.8.x:

1 $ rvm 1.8.7
2 $ ruby carro2.rb
3 #<Carro:0xb75be6b0 @cor=:preto, @modelo=:corsa, @marca=:chevrolet, @tanque=50>
4 Marca:chevrolet Modelo:corsa Cor:preto Tanque:50

E agora nas versões 1.9.x:

1 $ rvm 1.9.3
2 $ ruby carro2.rb
3 Marca:chevrolet Modelo:corsa Cor:preto Tanque:50
4 Marca:chevrolet Modelo:corsa Cor:preto Tanque:50

E agora nas versões 2.x:

1 $ rvm 2.0.0
2 $ ruby carro2.rb 
3 #<Carro:0x85808b0 @marca=:chevrolet, @modelo=:corsa, @cor=:preto, @tanque=50>
4 Marca:chevrolet Modelo:corsa Cor:preto Tanque:50

Vimos como criar as propriedades do nosso objeto através das variáveis de instância, mas como podemos acessá-las? Isso vai nos dar um erro:

 1 class Carro
 2   def initialize(marca,modelo,cor,tanque)
 3     @marca  = marca
 4     @modelo = modelo
 5     @cor    = cor
 6     @tanque = tanque
 7   end
 8 
 9   def to_s
10     "Marca:#{@marca} Modelo:#{@modelo} Cor:#{@cor} Tanque:#{@tanque}"
11   end
12 end
13 
14 corsa = Carro.new(:chevrolet,:corsa,:preto,50)
15 puts corsa.marca

Rodando o programa:

1 $ ruby carro3.rb
2 code/carro3.rb:14:in ‘<main>’: undefined method ‘marca’ for Marca:chevrolet
3 Modelo:corsa Cor:preto Tanque:50:Carro (NoMethodError)

Essas variáveis são privadas do objeto, e não podem ser lidas sem um método de acesso. Podemos resolver isso usando attr_reader:

 1 class Carro
 2   attr_reader :marca, :modelo, :cor, :tanque
 3 
 4   def initialize(marca,modelo,cor,tanque)
 5     @marca  = marca
 6     @modelo = modelo
 7     @cor    = cor
 8     @tanque = tanque
 9   end
10 
11   def to_s
12     "Marca:#{@marca} Modelo:#{@modelo} Cor:#{@cor} Tanque:#{@tanque}"
13   end
14 end
15 
16 corsa = Carro.new(:chevrolet,:corsa,:preto,50)
17 puts corsa.marca

Rodando o programa:

1 $ ruby carro4.rb
2 chevrolet

Nesse caso, criamos atributos de leitura, que nos permitem a leitura da propriedade. Se precisarmos de algum atributo de escrita, para trocarmos a cor do carro, por exemplo, podemos usar:

 1 class Carro
 2   attr_reader :marca, :modelo, :cor, :tanque
 3   attr_writer :cor
 4 
 5   def initialize(marca,modelo,cor,tanque)
 6     @marca  = marca
 7     @modelo = modelo
 8     @cor    = cor
 9     @tanque = tanque
10   end
11 
12   def to_s
13     "Marca:#{@marca} Modelo:#{@modelo} Cor:#{@cor} Tanque:#{@tanque}"
14   end
15 end
16 
17 corsa = Carro.new(:chevrolet,:corsa,:preto,50)
18 corsa.cor = :branco
19 puts corsa

Rodando o programa:

1 $ ruby carro5.rb
2 Marca:chevrolet Modelo:corsa Cor:branco Tanque:50

Podemos até encurtar isso mais ainda criando direto um atributo de escrita e leitura com attr_accessor:

 1 class Carro
 2   attr_reader :marca, :modelo, :tanque
 3   attr_accessor :cor
 4 
 5   def initialize(marca,modelo,cor,tanque)
 6     @marca  = marca
 7     @modelo = modelo
 8     @cor    = cor
 9     @tanque = tanque
10   end
11 
12   def to_s
13     "Marca:#{@marca} Modelo:#{@modelo} Cor:#{@cor} Tanque:#{@tanque}"
14   end
15 end
16 
17 corsa = Carro.new(:chevrolet,:corsa,:preto,50)
18 corsa.cor = :branco
19 puts corsa

Rodando o programa:

1 $ ruby carro6.rb
2 Marca:chevrolet Modelo:corsa Cor:branco Tanque:50

Também podemos criar atributos virtuais, que nada mais são do que métodos que agem como se fossem atributos do objeto. Vamos supor que precisamos de uma medida como galões, que equivalem a 3,785 litros, para o tanque do carro. Poderíamos fazer:

 1 class Carro
 2   attr_reader :marca, :modelo, :tanque
 3   attr_accessor :cor
 4 
 5   def initialize(marca, modelo, cor, tanque)
 6     @marca  = marca
 7     @modelo = modelo
 8     @cor    = cor
 9     @tanque = tanque
10   end
11 
12   def to_s
13     "Marca:#{@marca} Modelo:#{@modelo} Cor:#{@cor} Tanque:#{@tanque}"
14   end
15 
16   def galoes
17     @tanque / 3.785
18   end
19 end
20 
21 corsa = Carro.new(:chevrolet, :corsa, :preto, 50)
22 corsa.cor = :branco
23 puts corsa.galoes

Rodando o programa:

1 $ ruby carro7.rb
2 13.21003963011889

Classes abertas

Uma diferença de Ruby com várias outras linguagens é que as suas classes, mesmo as definidas por padrão e base na linguagem, são abertas, ou seja, podemos alterá-las depois que as declararmos. Por exemplo:

 1 class Carro
 2   attr_reader :marca, :modelo, :tanque
 3   attr_accessor :cor
 4 
 5   def initialize(marca, modelo, cor, tanque)
 6     @marca  = marca
 7     @modelo = modelo
 8     @cor    = cor
 9     @tanque = tanque
10   end
11 
12   def to_s
13     "Marca:#{@marca} Modelo:#{@modelo} Cor:#{@cor} Tanque:#{@tanque}"
14   end
15 end
16 
17 corsa = Carro.new(:chevrolet, :corsa, :preto, 50)
18 
19 class Carro
20   def novo_metodo
21     puts "Novo método!"
22   end
23 end
24 corsa.novo_metodo
25 
26 class Carro
27   remove_method :novo_metodo
28 end
29 
30 corsa.novo_metodo

Rodando o programa:

1 $ ruby code/carro8.rb
2 Novo método!
3 code/carro8.rb:30:in ‘<main>’: undefined method ‘novo_metodo’ for
4 Marca:chevrolet Modelo:corsa Cor:preto Tanque:50:Carro (NoMethodError)

Pude inserir e remover um método que é incorporado aos objetos que foram definidos sendo daquela classe e para os novos a serem criados também. Também pudemos remover o método, o que gerou a mensagem de erro.

Navegação segura

Às vezes temos que testar determinados objetos e métodos verificando antes de eles existem. Podemos ver isso no código abaixo, onde os objetos e métodos são verificados usando primeiro um if verificando se não existe alguma referência nula, depois, comentado, o método try do ActiveSupport do Rails e por último o “navegador de operação segura” &., onde é tentado acessar objeto&.propriedade, retornando o valor ou nulo se falhar.

 1 class Volante
 2   attr_reader :cor
 3 
 4   def initialize(cor)
 5     @cor = cor
 6   end
 7 end
 8 
 9 class Carro
10   attr_reader :volante
11 
12   def initialize(volante)
13     @volante = volante
14   end
15 end
16 
17 volante = Volante.new(:preto)
18 carro   = Carro.new(volante)
19 
20 puts carro.volante.cor if carro && carro.volante && carro.volante.cor
21 #puts carro.try(:volante).try(:cor)
22 puts carro&.volante&.cor

Aliases

Se por acaso quisermos guardar uma cópia do método que vamos redefinir, podemos usar alias_method para dar outro nome para ele:

 1 class Carro
 2   attr_reader :marca, :modelo, :tanque
 3   attr_accessor :cor
 4 
 5   def initialize(marca,modelo,cor,tanque)
 6     @marca  = marca
 7     @modelo = modelo
 8     @cor    = cor
 9     @tanque = tanque
10   end
11 
12   def to_s
13     "Marca:#{@marca} Modelo:#{@modelo} Cor:#{@cor} Tanque:#{@tanque}"
14   end
15 end
16 
17 class Carro
18   alias_method :to_s_old, :to_s
19   def to_s
20     "Esse é um novo jeito de mostrar isso: #{to_s_old}"
21   end
22 end
23 
24 carro = Carro.new(:chevrolet,:corsa,:preto,50)
25 puts carro
26 puts carro.to_s_old

Rodando o programa:

1 $ ruby code/methalias.rb
2 Esse é um novo jeito de mostrar isso: Marca:chevrolet Modelo:corsa Cor:preto \
3 Tanque:50
4 Marca:chevrolet Modelo:corsa Cor:preto Tanque:50

Inserindo e removendo métodos

Podemos também inserir um método somente em uma determinada instância:

 1 class Carro
 2   attr_reader :marca, :modelo, :tanque
 3   attr_accessor :cor
 4 
 5   def initialize(marca,modelo,cor,tanque)
 6     @marca  = marca
 7     @modelo = modelo
 8     @cor    = cor
 9     @tanque = tanque
10   end
11 
12   def to_s
13     "Marca:#{@marca} Modelo:#{@modelo} Cor:#{@cor} Tanque:#{@tanque}"
14   end
15 end
16 
17 corsa = Carro.new(:chevrolet,:corsa,:preto,50)
18 gol   = Carro.new(:volks,:gol,:azul,42)
19 
20 class << corsa
21   def novo_metodo
22     puts "Novo método!"
23   end
24 end
25 
26 corsa.novo_metodo
27 gol.novo_metodo

Rodando o programa:

1 $ ruby code/insmethinst.rb
2 Novo método!
3 code/insmethinst.rb:28:in ‘<main>’: undefined method ‘novo_metodo’ for
4 Marca:volks Modelo:gol Cor:azul Tanque:42:Carro (NoMethodError)

Podemos ver que no caso do corsa, o novo método foi adicionado, mas não no gol. O que aconteceu ali com o operador/método <<? Hora de algumas explicações sobre metaclasses!

Metaclasses

Todo objeto em Ruby tem uma hierarquia de ancestrais, que podem ser vistos utilizando ancestors, como:

1 class Teste
2 end
3 p String.ancestors
4 p Teste.ancestors

Rodando o programa:

1 $ ruby ancestors.rb
2 [String, Comparable, Object, Kernel, BasicObject]
3 [Teste, Object, Kernel, BasicObject]

E cada objeto tem a sua superclasse:

1 class Teste
2 end
3 
4 class OutroTeste < Teste
5 end
6 
7 p String.superclass
8 p Teste.superclass
9 p OutroTeste.superclass

1 $ ruby superclasses.rb
2 Object
3 Object
4 Teste

Todos os objetos a partir das versões 1.9.x são derivados de BasicObject, que é o que chamamos de blank slate, que é um objeto que tem menos métodos que Object.

1 > BasicObject.instance_methods
2 => [:, :equal?, :!, :!, :instance_eval, :instance_exec, :__send__]

O que ocorreu no exemplo da inserção do método na instância acima (quando utilizamos <<), é que o método foi inserido na metaclasse, ou eigenclass, ou classe singleton, ou “classe fantasma” do objeto, que adiciona um novo elo na hierarquia dos ancestrais da classe da qual a instância pertence, ou seja, o método foi inserido antes da classe Carro. A procura do método (method lookup) se dá na eigenclass da instância, depois na hierarquia de ancestrais.

Para isso ficar mais legal e prático, vamos ver como fazer dinamicamente, já começando a brincar com metaprogramação ⁴. Primeiro, com a classe:

 1 class Carro
 2   attr_reader :marca, :modelo, :tanque
 3   attr_accessor :cor
 4 
 5   def initialize(marca, modelo, cor, tanque)
 6     @marca  = marca
 7     @modelo = modelo
 8     @cor    = cor
 9     @tanque = tanque    
10   end
11 
12   def to_s
13     "Marca:#{@marca} Modelo:#{@modelo} Cor:#{@cor} Tanque:#{@tanque}"
14   end
15 end
16 
17 corsa = Carro.new(:chevrolet, :corsa, :preto, 50)
18 gol   = Carro.new(:volks, :gol, :azul, 42)
19 
20 Carro.send(:define_method, "multiplica_tanque") do |valor|
21   @tanque * valor
22 end
23 
24 puts corsa.multiplica_tanque(2)
25 puts gol.multiplica_tanque(2)

Rodando o programa:

1 $ ruby code/carro9.rb
2 100
3 84

Agora, com as instâncias:

 1 class Carro
 2   attr_reader :marca, :modelo, :tanque
 3   attr_accessor :cor
 4 
 5   def initialize(marca, modelo, cor, tanque)
 6     @marca  = marca
 7     @modelo = modelo
 8     @cor    = cor
 9     @tanque = tanque
10   end
11 
12   def to_s
13     "Marca:#{@marca} Modelo:#{@modelo} Cor:#{@cor} Tanque:#{@tanque}"
14   end
15 end
16 
17 corsa = Carro.new(:chevrolet, :corsa, :preto, 50)
18 gol   = Carro.new(:volks, :gol, :azul, 42)
19 
20 (class << corsa; self; end).send(:define_method, "multiplica_tanque") do |val\
21 or|
22   @tanque * valor
23 end
24 
25 puts corsa.multiplica_tanque(2)
26 puts gol.multiplica_tanque(2)

Rodando o programa:

1 100
2 code/carro10.rb:25:in ‘<main>’: undefined method ‘multiplica_tanque’ for
3 Marca:volks Modelo:gol Cor:azul Tanque:42:Carro (NoMethodError)

Depois de ver tudo isso sobre inserção e remoção de métodos dinamicamente, vamos ver um truquezinho para criar um método “autodestrutivo”:

 1 class Teste
 2   def apenas_uma_vez
 3     def self.apenas_uma_vez
 4       raise Exception, "Esse metodo se destruiu!"
 5     end
 6     puts "Vou rodar apenas essa vez hein?"
 7   end
 8 end
 9 
10 teste = Teste.new
11 teste.apenas_uma_vez
12 teste.apenas_uma_vez

Rodando o programa:

1 $ ruby code/autodestruct.rb
2 Vou rodar apenas essa vez hein?
3 code/autodestruct.rb:4:in ‘apenas_uma_vez’: Esse metodo se destruiu!
4 (Exception) from code/autodestruct.rb:12:in ‘<main>’

Isso não é algo que se vê todo dia, yeah! :-)

Variáveis de classe

Também podemos ter variáveis de classes, que são variáveis que se encontram no contexto da classe e não das instâncias dos objetos da classe. Variáveis de classes tem o nome começado com @@ e devem ser inicializadas antes de serem usadas. Por exemplo:

 1 class Carro
 2   attr_reader :marca, :modelo, :tanque
 3   attr_accessor :cor
 4   @@qtde = 0
 5 
 6   def initialize(marca, modelo, cor, tanque)
 7     @marca  = marca
 8     @modelo = modelo
 9     @cor    = cor
10     @tanque = tanque
11     @@qtde += 1
12   end
13 
14   def to_s
15     "Marca:#{@marca} Modelo:#{@modelo} Cor:#{@cor} Tanque:#{@tanque}"
16   end
17 
18   def qtde
19     @@qtde
20   end
21 end
22 
23 corsa    = Carro.new(:chevrolet, :corsa, :preto, 50)
24 gol      = Carro.new(:volks, :gol, :azul, 42)
25 ferrari  = Carro.new(:ferrari, :viper, :vermelho, 70)
26 
27 puts ferrari.qtde

Rodando o programa:

1 $ ruby code/classvar1.rb
2 3

Para que não precisemos acessar a variável através de uma instância, podemos criar um método de classe, utilizando self. antes do nome do método:

 1 class Carro
 2   attr_reader :marca, :modelo, :tanque
 3   attr_accessor :cor
 4   @@qtde = 0
 5 
 6   def initialize(marca, modelo, cor, tanque)
 7     @marca  = marca
 8     @modelo = modelo
 9     @cor    = cor
10     @tanque = tanque
11     @@qtde += 1
12   end
13 
14   def to_s
15     "Marca:#{@marca} Modelo:#{@modelo} Cor:#{@cor} Tanque:#{@tanque}"
16   end
17 
18   def self.qtde
19     @@qtde
20   end
21 end
22 
23 corsa   = Carro.new(:chevrolet, :corsa, :preto, 50)
24 gol     = Carro.new(:volks, :gol, :azul, 42)
25 ferrari = Carro.new(:ferrari, :enzo, :vermelho, 70)
26 puts Carro.qtde

Rodando o programa:

1 $ ruby code/classvar2.rb
2 3

Os métodos de classe também podem ser chamados de métodos estáticos, em que não precisam de uma instância da classe para funcionar. Fazendo uma pequena comparação com variáveis e métodos estáticos em Java, no arquivo CarroEstatico.java:

 1 public class CarroEstatico {
 2   private static int qtde = 0;
 3 
 4   public CarroEstatico() {
 5     ++qtde;
 6   }
 7 
 8   public static int qtde() {
 9     return qtde;
10   }
11 
12   public static void main(String args[]) {
13     CarroEstatico[] carros = new CarroEstatico[10];
14 
15     for (int i = 0; i < carros.length; i++) {
16       carros[i] = new CarroEstatico();
17       System.out.println(CarroEstatico.qtde() + " carros");
18     }
19   }
20 }

Rodando o programa:

 1 $ java CarroEstatico
 2 1 carros
 3 2 carros
 4 3 carros
 5 4 carros
 6 5 carros
 7 6 carros
 8 7 carros
 9 8 carros
10 9 carros
11 10 carros

Interfaces fluentes

O método self é particularmente interessante para desenvolvermos interfaces fluentes ⁵, que visa a escrita de código mais legível, geralmente implementada utilizando métodos encadeados, auto-referenciais no contexto (ou seja, sempre se referindo ao mesmo objeto) até que seja encontrado e retornado um contexto vazio. Poderíamos ter uma interface fluente bem básica para montar alguns comandos select SQL dessa forma:

 1 class SQL
 2   attr_reader :table, :conditions, :order
 3 
 4   def from(table)
 5     @table = table
 6     self
 7   end
 8 
 9   def where(cond)
10     @conditions = cond
11     self
12   end
13 
14   def order(order)
15     @order = order
16     self
17   end
18 
19   def to_s
20     "select * from #{@table} where #{@conditions} order by #{@order}"
21   end
22 end
23 
24 sql = SQL.new.from("carros").where("marca='Ford'").order("modelo")
25 puts sql

Rodando o programa:

1   $ ruby fluent.rb 
2   select * from carros where marca='Ford' order by modelo

Reparem que self sempre foi retornado em todos os métodos, automaticamente retornando o próprio objeto de onde o método seguinte do encadeiamento foi chamado.

Variáveis de instância de classe

Um problema que acontece com as variáveis de classe utilizando @@ é que elas não pertencem realmente às classes, e sim à hierarquias, podendo permear o código dessa maneira:

 1 @@qtde = 10
 2 
 3 class Carro
 4   attr_reader :marca, :modelo, :tanque
 5   attr_accessor :cor
 6   @@qtde = 0
 7   puts self
 8 
 9   def initialize(marca, modelo, cor, tanque)
10     @marca  = marca
11     @modelo = modelo
12     @cor    = cor
13     @tanque = tanque
14     @@qtde += 1
15   end
16 
17   def to_s
18     "Marca:#{@marca} Modelo:#{@modelo} Cor:#{@cor} Tanque:#{@tanque}"
19   end
20 
21   def self.qtde
22     @@qtde
23   end
24 end
25 
26 puts self
27 puts @@qtde

Rodando o programa:

1 $ ruby code/classvar3.rb
2 Carro
3 main
4 0

Está certo que esse não é um código comum de se ver, mas já dá para perceber algum estrago quando as variáveis @@ são utilizadas dessa maneira. Repararam que a @@qtde externa teve o seu valor atribuído como 0 dentro da classe?

Podemos prevenir isso usando variáveis de instância de classe:

 1 class Carro
 2   attr_reader :marca, :modelo, :tanque
 3   attr_accessor :cor
 4 
 5   class << self
 6     attr_accessor :qtde
 7   end
 8   @qtde = 0
 9 
10   def initialize(marca, modelo, cor, tanque)
11     @marca  = marca
12     @modelo = modelo
13     @cor    = cor
14     @tanque = tanque
15     self.class.qtde += 1
16   end
17 
18   def to_s
19     "Marca:#{@marca} Modelo:#{@modelo} Cor:#{@cor} Tanque:#{@tanque}"
20   end
21 end
22 
23 corsa   = Carro.new(:chevrolet, :corsa, :preto, 50)
24 gol     = Carro.new(:volks ,:gol, :azul, 42)
25 ferrari = Carro.new(:ferrari, :enzo, :vermelho, 70)
26 puts Carro.qtde

1 $ ruby code/classvar4.rb
2 3      

Vejam que a variável está na instância da classe (sim, classes tem uma instância “flutuando” por aí) e não em instâncias de objetos criados pela classe (os @) e nem são variáveis de classe (os @@).

Herança

Em Ruby, temos herança única, que significa que uma classe pode apenas ser criada herdando de apenas outra classe, reduzindo a complexidade do código. Como exemplo de alguma complexidade (pouca, nesse caso), vamos pegar de exemplo esse código em C++:

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 class Automovel {
 6   public:
 7     void ligar() {
 8       cout << "ligando o automóvel\n";
 9     }
10 };
11 
12 class Radio {
13   public:
14     void ligar() {
15       cout << "ligando o rádio\n";
16     }
17 };
18 
19 class Carro: public Automovel, public Radio {
20   public:
21     Carro() {}
22 };
23 
24 int main() {
25   Carro carro;
26   carro.ligar(); // só compila com Automovel::ligar();
27   return 0;
28 }

Se compilarmos esse código, vamos ter esse resultado:

1 $ g++ -g -o carro carro.cpp 
2 carro.cpp: Na função ‘int main()’:
3 carro.cpp:26:10: erro: request for member ‘ligar’ is ambiguous
4 carro.cpp:14:9: erro: candidates are: void Radio::ligar()
5 carro.cpp:7:9: erro:                 void Automovel::ligar()

Não foi possível resolver qual método ligar era para ser chamado. Para isso, temos que indicar explicitamente em qual das classes herdadas o método vai ser chamado, trocando

1 carro.ligar();

para

1 carro.Automovel::ligar();

que resulta em

1 $ g++ -g -o carro carro.cpp 
2 $ ./carro
3 ligando o automóvel

Para fazermos a herança nas nossas classes em Ruby, é muito simples, é só utilizarmos class <nome da classe filha> < <nome da classe pai>:

 1 class Carro
 2   attr_reader :marca, :modelo, :tanque
 3   attr_accessor :cor
 4   @@qtde = 0
 5 
 6   def initialize(marca, modelo, cor, tanque)
 7     @marca  = marca
 8     @modelo = modelo
 9     @cor    = cor
10     @tanque = tanque
11     @@qtde += 1
12   end
13 
14   def to_s
15     "Marca:#{@marca} Modelo:#{@modelo} Cor:#{@cor} Tanque:#{@tanque}"
16   end
17 
18   def self.qtde
19     @@qtde
20   end
21 end
22 
23 class NovoCarro < Carro
24   def to_s
25     "Marca nova:#{@marca} Modelo:#{@modelo} Cor:#{@cor} Tanque:#{@tanque}"
26   end
27 end
28 
29 carro1 = Carro.new(:chevrolet, :corsa, :preto, 50)
30 carro2 = Carro.new(:chevrolet, :corsa, :prata, 50)
31 novo_carro = NovoCarro.new(:volks, :gol, :azul, 42)
32 
33 puts carro1
34 puts carro2
35 puts novo_carro
36 puts Carro.qtde
37 puts NovoCarro.qtde