CURSO DE EXTENSÃO: Desenvolvimento de Aplicativos WEB com Ruby on Rails

Transcrição

1 CURSO DE EXTENSÃO: Desenvolvimento de Aplicativos WEB com Ruby on Rails Jackson Pires de O. S. Júnior Abril de 2008

2 2ª Semana Classes, Objetos, Variáveis, Tipos, Métodos, Exceções, Entrada / Saída

3 Introdução Olá seja bem vindo à segunda aula do curso de extensão de Desenvolvimento de Aplicativos Web com Ruby on Rails. Todo conteúdo do curso está baseado em livros, tutoriais e cursos, a maioria disponíveis na internet, portanto, você pode ampliar ainda mais seu conhecimento procurando mais informações em ferramentas de busca e sites específicos sobre a tecnologia citada. Mais à frente darei algumas referências para que você possa continuar estudando sobre o assunto. Nesta aula faremos uma breve introdução à linguagem Ruby tocando os pontos que facilitarão o desenvolvimento de aplicações Web com o Ruby on Rails. Abaixo temos o conteúdo programático que seguiremos nessa segunda semana: Ruby o Linguagem Classes, Objetos, Variáveis Tipos Métodos Exceções Entrada / Saída

4 Linguagem Dando continuidade ao nosso curso, não poderíamos deixar de nos aprofundar um pouco mais na linguagem que é a base para todo o entimento do framework Ruby on Rails. So assim, tentaremos trazer os conceitos mais importantes da linguagem para que mais à frente possamos desfrutar de suas facilidades no desenvolvimento dos aplicativos WEB. É bom lembrar que não falaremos de conceitos básicos de programação e algorítimo, esse passo já deve ter sido visto em sala de aula. Então mãos à obra!

5 Classes, Objetos e Variáveis Considerando que o Ruby é completamente orientado a objetos, nada mais apropriado que começar nossa exploração do mesmo por essa parte. A primeira coisa que precisamos no nosso processo de compreensão do Ruby é enter como variáveis funcionam. No Ruby, como na maior parte das linguagens orientadas a objeto, as variáveis são simplesmente referências a objetos. Veja o exemplo abaixo: ~$ irb irb(main):001:0> a = 1 => 1 irb(main):002:0> a = "1" => "1" No exemplo acima, atribuímos a valor inteiro 1 à variável a e depois atribuímos à mesma variável, o valor 1, que é uma seqüência de caracteres. Isso, e o fato de que nenhum erro ocorreu, demonstram duas coisas sobre o Ruby. Primeiro, variáveis simplesmente apontam para os valores atribuídos à mesma, e, por causa disso, podem ser re-atribuídas de acordo com necessidade; segundo, variáveis não precisam ser declaradas. Um exemplo posterior poderia ser: ~$ irb irb(main):001:0> a = 1 => 1 irb(main):002:0> a.class => Fixnum irb(main):003:0> a = "1 " => "1 " irb(main):004:0> a.class => String Note que mesmo tipos primitivos como o número inteiro 1 são membros de uma classe no caso Fixnum, que é a classe que define números com representação fixa. Considere agora o seguinte trecho de código: ~$ irb irb(main):001:0> 1.class

6 => Fixnum irb(main):002:0> 1.class.class => Class irb(main):003:0> 1.class.superclass => Integer irb(main):004:0> Note que 1 é uma instância da classe Fixnum. A classe Fixnum, por sua vez, é também um objeto, uma instância da classe Class, que define todas as classes em Ruby. Class é chamada a metaclasse de Fixnum, ou seja, é uma classe que descreve uma classe. Na terceira linha temos outro conceito de orientação a objetos que é a superclasse de uma classe, ou seja, a classe da qual a mesma é derivada. No caso de Fixnum, temos a seguinte hierarquia: Object => Numeric => Integer => Fixnum. Esses dois conceitos, metaclasses e superclasses, são importantes em qualquer linguagem orientada a objeto e precisam ser compreidos por qualquer programador. Outro aspecto com o qual os programadores estão acostumados é ter uma separação muito distinta entre tipos primitivos e objetos. Em Java, 3 é um inteiro, uma estrutura primitiva de 32-bits. Se precisamos de um objeto em torno desse primitivo, embrulhamos em torno uma instância da classe Integer. Em Ruby 3 é um objeto, tipo Fixnum. Como tal, tem diversos métodos. Por Exemplo: ~$ irb irb(main):001:0> 1.to_s => "1" irb(main):002:0> => 2 irb(main):003:0> 1.+(1) => 2 irb(main):004:0> -1.abs => 1 irb(main):005:0> "123".length => 3 No exemplo acima, temos várias invocações de métodos de determinados objetos. O primeiro método invocado, to_s, converte um valor numérico em

7 uma string correspondente. O segundo exemplo é ainda mais interessante. Note que fizemos uma operações, somando dois números. Mas, como podemos ver logo abaixo, a operação é simplesmente uma invocação de um método do objeto. Obviamente que, para uso diário, utilizaremos à primeira sintaxe. É importante, porém, compreer que isso é válido para basicamente todos os métodos do Ruby e que isso pode ser usado em suas próprias classes. Uma maneira fácil de visualizar os métodos que uma classe possui é chamar o seu método methods, como pode ser visto abaixo: ~$ irb irb(main):001:0> 1.methods => ["%", "inspect", "<<", "singleton_method_added", "&", "clone", ">>", "ceil", "public_methods", "instance_variable_defined?", "div", "equal?", "freeze", "times", "*", "+", "to_i", "methods", "respond_to?", "-", "upto", "between?", "prec", "round", "/", "method", "dup", "instance_variables", " id ", "divmod", "chr", "succ", " ", "eql?", "integer?", "~", "id", "to_f", "singleton_methods", "s", "prec_i", "taint", "truncate", "to_int", "frozen?", "instance_variable_get", " s ", "^", "instance_of?", "modulo", "to_a", "object_id", "+@", "zero?", "-@", "type", "**", "<", "protected_methods", "<=>", "instance_eval", "==", "prec_f", "quo", ">", "===", "step", "id2name", "size", "instance_variable_set", "kind_of?", "remainder", "ext", ">=", "nonzero?", "next", "to_s", "<=", "coerce", "hash", "floor", "class", "tainted?", "=~", "private_methods", "display", "fdiv", "nil?", "untaint", "downto", "to_sym", "[]", "is_a?", "abs"] Esses são todos os métodos públicos compartilhados pelas instâncias da classe Fixnum. Como classes podem possuir métodos públicos, protegidos e privados, a distinção pode ser obtida invocando os métodos public_methods, protected_methods e private_methods de uma instância qualquer. Incidentemente, classes são objetos também, com seus próprios métodos. Você pode observar isso invocando o método acima em uma classe, usando, por exemplo: ~$ irb irb(main):001:0> String.public_methods

8 => ["inspect", "private_class_method", "const_missing", "clone", "public_methods", "public_instance_methods", "instance_variable_defined?", "method_defined?", "superclass", "equal?", "freeze", "included_modules", "const_get", "autoload?", "methods", "respond_to?", "module_eval", "class_variables", "method", "dup", "protected_instance_methods", "instance_variables", "public_method_defined?", " id ", "eql?", "const_set", "id", "singleton_methods", "s", "class_eval", "taint", "frozen?", "instance_variable_get", "include?", "private_instance_methods", " s ", "instance_of?", "private_method_defined?", "to_a", "object_id", "name", "type", "new", "<", "protected_methods", "instance_eval", "<=>", "==", ">", "===", "instance_variable_set", "kind_of?", "ext", "protected_method_defined?", "const_defined?", ">=", "ancestors", "to_s", "<=", "public_class_method", "autoload", "allocate", "hash", "class", "instance_methods", "tainted?", "=~", "private_methods", "class_variable_defined?", "display", "nil?", "instance_method", "untaint", "constants", "is_a?"] Aqui cabe uma explicação sobre uma diferença do Ruby para outras linguagens orientadas a objetos. Métodos públicos são métodos acessíveis a todo o programa. Métodos protegidos são acessíveis somente a instâncias da própria classe e subclasses da mesma. Em Ruby, porém, métodos privados possuem uma distinção sutil: eles somente podem ser chamados com um receptor explícito, ou seja, dentro do próprio objeto. Isso significa que subclasses podem também chamar os métodos privados de sua superclasse, mas somente dentro do seu próprio contexto de execução. Objetos, como instâncias de classes, podem ser criados implicitamente ou explicitamente em Ruby. Acima, vimos alguns exemplos de criação implícita, que é comum a todos os tipos primitivos. A criação explícita, porém, é feita através da invocação do método new: ~$ irb irb(main):001:0> a = "Uma string qualquer" => "Uma string qualquer" irb(main):002:0> b = String.new("Uma string qualquer") => "Uma string qualquer" irb(main):003:0> a == b => true irb(main):004:0> require 'date' => true

9 irb(main):005:0> d = Date.new(2007, 1, 1) => #<Date: /2,0, > irb(main):006:0> d.day => 1 irb(main):007:0> d.year => 2007 Note que nas primeiras declarações criamos uma string de maneira implícita e de maneira explícita. Uma comparação entre as duas revela que não há diferença na criação, ou seja, a criação implícita é essencialmente o mesmo que uma chamada ao método new seguida de uma atribuição. No exemplo seguinte, temos a criação de um objeto que não possui criação implícita. Note também que o objeto não faz parte do núcleo do Ruby, mas é implementado em uma biblioteca externa que é adquirida para o contexto atual através do método require. Esse método, embora seja invocado aparentemente sem um objeto receptor, é na verdade um método do módulo Kernel, incluindo na classe Object, que provê uma série de métodos comuns para o ambiente de execução Ruby. Veremos mais sobre módulos em seções seguintes. Como podemos notar de tudo o que foi visto acima, o Ruby é realmente uma linguagem orientada a objetos em toda a sua extensão. Todo valor criado é uma instância de uma classe qualquer, mesmo as próprias classes. Desafio 1.O Ruby possui um método chamado id, comum a todas as classes e objetos. O que esse método faz? 2.Faça um teste, criando duas variáveis inteiras. Compare os ids das mesmas. Qual é o resultado? 3.Faça o mesmo teste com duas variáveis String. Qual é o resultado agora? 4.Por que você acha que isso acontece?

10 Mas o que são Símbolos no Ruby? Bom, esse trechinho da apostila entra pra deixar você ainda mais à vontade com a linguagem Ruby. Mais à frente vamos nos deparar com trechos de códigos mais ou menos assim: a = :teste Vamos notar então que existe : (dois pontos) na frente do nome teste, não se preocupe, não é erro de digitação, isto meu caro amigo é um símbolo ou se preferir um symbol. Bom, para começarmos a enter símbolos no Ruby é interessante ler um post que o Fabio Akita deixou em seu blog < esse post faz demonstrações muito boas para o entimento do assunto, não deixem de visitá-lo. Por hora, basta termos em mente o seguinte. Pense em símbolos como Strings Leves. Eles representam nomes e algumas String dentro do interpretador Ruby, e são sempre o mesmo objeto durante a execução de um programa. Ou ainda dizemos que são representações eficientes de um valor qualquer, não muito diferentes de constantes Um exemplo prático seria: ~$ irb irb(main):001:0> s1 = :fasete => :fasete irb(main):002:0> s2 = :fasete => :fasete irb(main):003:0> s3 = :fasete => :fasete irb(main):004:0> s1.object_id => irb(main):005:0> s2.object_id => irb(main):006:0> s3.object_id =>

11 Observe que todos apontam para o mesmo objeto, diferentemente da utilização de Strings comuns. Continuando... Agora que trabalhamos um pouco com os conceitos básicos de classes, objetos e variáveis, é hora de criar as nossas próprias classes, experimentando um pouco mais com o sistema de objetos do Ruby. Criar uma classe é bem simples em Ruby. Basta fazer o seguinte: class Carro def initialize(marca, = = modelo O código acima define uma classe chamada Carro que possui um método chamado initialize. Esse método possui uma conotação especial em Ruby, so o método que é invocado quando a instância de uma classe é criada. Vejamos isso em um exemplo: irb(main):007:0> gol = Carro.new("Volkswagem", "Gol") irb(main):008:0> O código acima cria uma instância da classe Carro, atribuindo os parâmetros a variáveis de instância da classe (identificadas pelo na frente dos seus nomes). Note que new é usado e não initialize, so que este último é invocado automaticamente. Esse é um detalhe de implementação do Ruby, so que o método initialize é automaticamente marcado com private.

12 Dica: Segundo convenções Ruby, nos nomes dos métodos devem-se usar letras minúsculas separando as palavras com um sublinhado (_), porém no nome das classes é utilizado camel case, da mesma maneira que no Java, com maiúsculas separando dois ou mais nomes da classe. Exemplos: MinhaClasse MeuTeste CarroPersonalizado. Dica: Caso você não queira ficar colando o código a todo momento, salve um arquivo com um nome qualquer e a extensão.rb e use o método load para carregar esse arquivo, lembrando que load requer o nome completo do arquivo a carregar, incluindo a extensão. Note que se você tentar extrair o valor de uma variável de instância acima, você verá um erro. Por exemplo: irb(main):009:0> gol.marca NoMethodError: undefined method `marca' from (irb):9 Variáveis de instância são automaticamente internas e você só pode extrair o valor das mesmas publicamente criando um método específico para isso. Falando em métodos, podemos criar um método para a nossa classe para ver como os mesmos funcionam. Antes vejamos a próxima linha: irb(main):010:0> gol.to_s => "#<Carro:0x2af9068>" Vamos aproveitar para substituir a inconveniente representação textual acima por uma de nosso interesse. Isso é feito criando um método chamado to_s, que já mencionamos anteriormente. Esse método converte um objeto qualquer em sua representação textual.

13 Todos objetos em Ruby possuem esse método, embora sua implementação inicial seja bem limitada. Podemos sobrescrever o método assim: class Carro def initialize(marca, = = modelo def to_s marca: #{@marca}, modelo #{@modelo} O código acima apresenta algumas características interessantes. Primeiro, ele retorna a representação textual do objeto, mas sem invocar qualquer expressão de retorno. Ruby possui, realmente, uma expressão return, mas a mesmo não precisa ser usada na maior parte dos casos. Isso acontece porque qualquer expressão em Ruby retorna automaticamente um valor. Se o valor não é explicitamente retornado, o valor nil é usado implicitamente. Isso significa que um método retorna o resultado de sua última expressão, sem necessidade de chamar return. No método acima, estamos retornando também uma string, usando o que é chamado de interpolação de valores. Qualquer expressão entre os delimitadores #{} dentro de uma string será executada e seu valor representacional retornado isto é o método to_s do valor resultante é invocado automaticamente. Veja o resultado do método acima: irb(main):010:0> gol = Carro.new("Volkswagem", "Gol") irb(main):011:0> gol irb(main):012:0> gol.to_s => "marca: Volksvagem, modelo Gol" Voltando à questão dos atributos, se quisermos torná-los manipuláveis, podemos usar a seguinte implementação:

14 class Carro def initialize(marca, = = modelo def to_s marca: #{@marca}, modelo #{@modelo} def def Isso permite o seguinte código: irb(main):016:0> gol = Carro.new("Volkswagem","Gol") irb(main):017:0> gol.marca => "Volkswagem" irb(main):018:0> gol.marca = "Nova Volks" => "Nova Volks" irb(main):019:0> gol.marca => "Nova Volks" Note que agora temos métodos que podemos usar para obter ou mudar o valor de um atributo do objeto. Os métodos que mudam o valor possuem um sinal de igual (=) em seu nome e são usados automaticamente pelo Ruby em caso de atribuição como o exemplo demonstra. Para encurtar ainda mais, Ruby permite que declaremos métodos de acesso à essas variáveis de uma forma diferente, observe o código: class Carro attr_reader :marca attr_writer :modelo def initialize(marca, = marca

15 @modelo = modelo def to_s marca: #{@marca}, modelo #{@modelo} ou ainda: class Carro attr_accessor :marca attr_reader :modelo def initialize(marca, = = modelo def to_s marca: #{@marca}, modelo #{@modelo} Note o início de cada código temos readers, writers e accessors e que eles usam símbolos para fazerem referências à variáveis de classe. Estes funcionam como um atalho para a operação tediosa que fizemos anteriormente. Resumindo, o attr_reader permite apenas leitura, o attr_writer permite apenas escrita e o attr_accessor permite escrita e leitura. Observe: irb(main):012:0> gol = Carro.new("Volkswagem", "Gol") irb(main):013:0> gol.marca => "Volkswagem" irb(main):014:0> gol.modelo NoMethodError: undefined method `modelo' from (irb):14 irb(main):015:0> gol.marca = "Nova Volks" NoMethodError: undefined method `marca=' from (irb):15 irb(main):016:0> gol.modelo = "Novo Gol" => "Novo Gol"

16 Pra fechar essa parte, como seriam feitas heranças em Ruby? Herança simples em Ruby é bastante trivial: class B < A A declaração acima indica que a classe B herda os métodos da classe A. Variáveis de classe, variáveis de instância, e variáveis de instância de classe seguem as regras descritas anteriormente. Ou seja o exts utilizado no Java, fica assim classe filha < classe pai, no Ruby. Veremos isso com mais detalhes em nossas andanças pelo Rails.

17 Tipos Considerando o fato de que o Ruby é completamente orientado a objetos, todos os seus tipos são representados por classes e uso dos mesmos é bem objetivo e direto. Ainda assim, é bom enter quais são os tipos básicos, quais são os seus detalhes de implementação, e, acima de tudo, quais são as suas limitações. O Ruby possui uma hierarquia relativamente extensa até mesmo para os tipos primitivos. Conhecer essa hierarquia é interessante como uma forma de enter mais como o Ruby funciona e serve como um bom exercício. O tipo mais básico do Ruby é o tipo numérico, em suas duas variantes: inteiro e de ponto flutuante. Os tipos são implementados por classes diferentes, mas a interoperabilidade dos mesmos é similar ao que se vê em outras linguagens de programação. ~$ irb irb(main):001:0> 1.class => Fixnum irb(main):002:0> 1.0.class => Float irb(main):003:0> 1_000_000.class => Fixnum Como o exemplo acima mostra, o Ruby é inteligente o bastante para conseguir operar com métodos mesmo no caso de números de ponto flutuante. A forma exemplificada na terceira linha de código é uma maneira de representar números com mais clareza, e pode ser usada em opção à maneira usual de declaração de números. Um detalhe interessante é que a exemplo do Smalltalk, Lisp e outras linguagens similares o Ruby permite o uso de número inteiros de tamanho arbitrário. Inclusive, há uma conversão automática quando o número excede a capacidade de representação dos inteiros. Veja o exemplo abaixo:

18 ~$ irb irb(main):001:0> 1_000_000_000 * 1_000_000_000 => irb(main):001:2> (1_000_000_000 * 1_000_000_000).class => Bignum A classe Bignum é capaz de representar número com precisão infinita, restrita somente à memória e processamento da máquina hospedeira. O próximo tipo primitivo do Ruby descreve a representação de valores booleanos. O Ruby possui duas pseudo-variáveis que representam esses valores, so essas variáveis as únicas instâncias das suas respectivas classes. Veja o exemplo abaixo: ~$ irb irb(main):001:0> true => true irb(main):002:0> false => false irb(main):003:0> true.class => TrueClass irb(main):004:0> false.class => FalseClass irb(main):005:0> true.class.superclass => Object irb(main):006:0> false.class.superclass => Object irb(main):007:0> TrueClass.new NoMethodError: undefined method `new' for TrueClass:Class from (irb):7 from :0 Note que uma tentativa de instanciar qualquer das duas classes booleanas resulta em um erro. O Ruby remove a definição do método new dessas classes para evitar qualquer problema. Além dessas duas variáveis, existe outra pseudo-variável especial que é o valor nil, que representa nulo. A exemplo das variáveis booleanas, esse valor é a única instância da classe NilClass.. Prosseguindo, temos o tipo que representa seqüências de caracteres, tipo este que é definido pela classe String:

19 ~$ irb irb(main):001:0> "123".length => 3 Considerando que o Ruby é muito voltado para processamento de texto inspirado sem dúvida por sua herança Perl a classe String foi desenhada com uma enorme gama de métodos que podem ser utilizados para esse tipo de trabalho. Além disso, há várias bibliotecas completando o que a classe não apresenta por padrão um tributo à flexibilidade do Ruby. Dois detalhes devem ser considerados quando se trabalha com textos em Ruby. O primeiro é que não existe um tipo para caracteres. Isso leva à situação abaixo: ~$ irb irb(main):001:0> "123"[0] => 49 irb(main):002:0> "123"[0].chr => "1" irb(main):003:0> "123"[0, 1] => "1" Acessar diretamente uma posição de uma String retorna o valor inteiro que representa aquele caractere. As duas outras linhas mostram a forma de obter o valor como uma String de tamanho um: você pode usar o método chr, ou pode obter um pedaço posicionado da String, do tamanho desejado. O segundo detalhe é que o Ruby não suporta Unicode ou UTF-8 por padrão. Veja o exemplo abaixo: ~$ irb irb(main):001:0> "Sábado"[0,2] => "S\303" irb(main):002:0> "Sábado"[0,3] => "S\303\241" irb(main):003:0> "Sábado"[0,4] => "S\303\241b" irb(main):004:0> "Sábado"[1].chr => "\303" irb(main):005:0> "Sábado"[2].chr

20 => "\241" irb(main):006:0> "Sábado"[3].chr => "b" irb(main):007:0> "Sábado".length => 7 Note que pelo fato do a acentuado ocupar dois bytes em uma representação não-ascii, o Ruby falha em suas funções mais elementares. Existem bibliotecas que procuram resolver o problema em graus variados, com inclusive uma delas estando embutida no próprio Rails. Os planos são de que a próxima versão do Ruby suporte Unicode nativamente. Uma característica da manipulação de texto em Ruby é que as strings geradas no mesmo são mutáveis, isto é, qualquer operação normal em uma string aloca uma nova string automaticamente. Por isso, é possível encontrar vários métodos com duas versões: uma que retorna um novo objeto e uma que modifica o objeto existente. Veja o exemplo abaixo: irb(main):001:0> s1 = "abc" => "abc" irb(main):002:0> s2 = s1 => "abc" irb(main):003:0> s2.object_id == s1.object_id => true irb(main):004:0> s2 = s1.upcase => "ABC" irb(main):005:0> s2 => "ABC" irb(main):006:0> s2.object_id => irb(main):007:0> s1 => "abc" irb(main):008:0> s1.object_id => irb(main):009:0> s1.upcase! => "ABC" irb(main):010:0> s1.object_id =>

21 O exemplo mostra que existem métodos que retornam uma nova string com as modificações e métodos que modificam a string sem alocar nova memória. Esses métodos destrutivos geralmente possuem o sufixo! (upcase!, gsub!, etc) para distingui-los dos métodos não-destrutivos (upcase, gsub, etc). Essa característica do Ruby pode causar algumas diferenças de performance em loops se o programador não for cuidadoso. Considere a seguinte situação: um loop em que uma variável string é concatenada repetidamente. O exemplo abaixo mostra essa diferença: ~$ irb irb(main):001:0> s = "" => "" irb(main):005:0> for a in [1, 2, 3] irb(main):006:1> s = s + a.to_s irb(main):007:1> puts s.object_id irb(main):008:1> => [1, 2, 3] irb(main):009:0> for a in [1, 2, 3] irb(main):010:1> s << a.to_s irb(main):011:1> puts s.object_id irb(main):012:1> => [1, 2, 3] irb(main):013:0> s => "123123" O exemplo mostra claramente que, no primeiro caso, um objeto novo é gerado a cada iteração do loop; no segundo caso, entretanto, isso não acontece: a string é meramente re-alocada de maneira eficiente. Isso pode significar uma boa diferença de performance quando se trabalha com textos de tamanho razoável. Existem várias formas de declarar strings em Ruby. Veja o exemplo abaixo:

22 ~$ irb irb(main):001:0> a = "valor" => "valor" irb(main):002:0> 'string com aspas simples: #{a}' => "string com aspas simples: \#{a}" irb(main):003:0> "string com aspas duplas: #{a}" => "string com aspas duplas: valor" irb(main):004:0> %(string com marcadores especiais: #{a}) => "string com marcadores especiais: valor" irb(main):005:0> s = <<EOF irb(main):006:0" uma string com irb(main):007:0" quebra de linha irb(main):008:0" e espacamento irb(main):009:0" EOF => "uma string com\n quebra de linha\n e espacamento\n" Com exceção da aspas simples, todas as outras formas de declaração de strings aceitam interpolação, isto é, a inserção de valores por meio de marcadores especiais em uma string usando #{expressão}. O Ruby aceita essa gama de declarações de strings com o objetivo de facilitar o uso de caracteres especiais. A lista abaixo é um resumo dessas formas de declaração. 'sem interpolacao,' interpolacao e contra-barras %q(sem interpolacao) %Q(interpolacao e contra-barras) %(interpolacao e contra-barras) Um outro tipo interessante do Ruby é o range, que define uma faixa de valores. Ele é muito útil para loops e muito fácil de ser usado: ~$ irb irb(main):001:0> (1..10) => irb(main):002:0> ('A'..'Z') => "A".."Z" irb(main):003:0> 'A'..'Z' => "A".."Z" irb(main):004:0> for i in ('A'..'C')

23 irb(main):005:1> puts i irb(main):006:1> A B C Dois outros tipos básicos que vamos explorar são Array e Hash, que possuem muitas similaridades. Um Array é uma vetor numericamente indexado, enquanto um Hash é um vetor associativo, que permite acesso randômico com maior eficiência. Veja os exemplos abaixo: ~$ irb irb(main):001:0> a = [1, 2, 3] => [1, 2, 3] irb(main):002:0> b = { :a => "Valor 1", :b => "Valor 2" } => {:b=>"valor 2", :a=>"valor 1"} irb(main):003:0> a[0] => 1 irb(main):004:0> a[:b] TypeError: Symbol as array index from(irb):4:in `[]' from (irb):4 from :0 irb(main):005:0> b[:a] => "Valor 1" irb(main):006:0> b[0] => nil irb(main):007:0> b.default = "Valor Default" => "Valor Default" irb(main):008:0> b[0] => "Valor Default" Note que o Array somente permite acesso por índices numéricos, enquanto Hash aceita qualquer objeto, retornando o valor nil se nenhuma chave correspondente for encontrada. Um valor padrão pode ser dado ao Hash para facilitar o retorno se necessário.

24 Métodos Até o momento já usamos bastante os vários métodos das classes primitivas do Ruby, mas ainda não utilizamos plenamente as características dos mesmos. Um método é simplesmente uma mensagem que um objeto pode executar. Se dois objetos respondem à mesma mensagem, eles podem ser trabalhados pelo mesmo código, indepentemente das classes em questão. Essa é uma das maiores vantagens de linguagens dinâmicas com Ruby, Python e Smalltalk e embora possa parecer que isso dá origem a mais erros no desenvolvimento, o inverso é verdadeiro: a flexibilidade da linguagem propicia um código mais limpo com menor incidência de erros. O uso simples de métodos é bem trivial: ~$ irb irb(main):001:0> def metodo(param1, param2) irb(main):002:1> param1 + param2 irb(main):003:1> => nil irb(main):004:0> metodo(1, 2) => 3 irb(main):005:0> metodo 1, 2 => 3 Note que não é necessário usar parênteses a menos que você precise desambiguar algum parâmetro. O mesmo é válido para a própria declaração do método, embora isso não esteja demonstrado acima. E embora seja possível ignorá-los em muitos casos, usar parênteses confere uma legibilidade melhor ao código e é mais desejável na maioria dos casos. O exemplo abaixo, mostra uma outra característica dos métodos Ruby: a possibilidade de receber uma quantidade de parâmetros arbitrária:

25 ~$ irb irb(main):001:0> def metodo(*args) irb(main):002:1> for a in args irb(main):003:2> puts a irb(main):004:2> irb(main):005:1> => nil irb(main):006:0> metodo(1) 1 => [1] irb(main):007:0> metodo(1, 2, 3) => [1, 2, 3] irb(main):008:0> metodo((1..3)) 1..3 => [1..3] irb(main):009:0> metodo(*(1..3)) No exemplo acima, criamos um método que simplesmente imprime todos os valores que lhe foram passados. O sinal de * é conhecido como splat operator e possui dois propósitos: primeiro, na declaração de um método, como na primeira linha, ele especifica que o Ruby deve pegar todos os parâmetros e passá-los em um array para o método. Segundo, como na última linha, ele tem o efeito contrário, ele pede ao Ruby que expanda uma seqüência qualquer em um array. Essas duas aplicações são igualmente importantes e devem ser entidas com clareza. Por fim, métodos podem receber blocos como parâmetros, tanto para execução interna como para retorno parcial de valores. Vamos mostrar no momento somente o uso simples de blocos e retornar ao assunto mais adiante, quando necessário:

26 ~$ irb irb(main):001:0> def metodo(s) irb(main):002:1> yield(s) irb(main):003:1> => nil irb(main):004:0> metodo(2) { i i + i } => 4 irb(main):005:0> metodo("2") { i i + i } => "22" Esse é um exemplo muito simples, mas mostra que blocos de código são variáveis de primeira classe, capaz de interagir com o ambiente como qualquer outro objeto. Aqui notamos o uso dos blocos associadas a código do Ruby, que existem na seguinte forma: do parametros { parametros } O exemplo acima poderia ser reescrito na outra variante: ~$ irb irb(main):001:0> def metodo(s) irb(main):002:1> yield(s) irb(main):003:1> => nil irb(main):004:0> metodo(2) do i irb(main):005:1* i + i irb(main):006:1> => 4irb(main):007:0> metodo("2") do i irb(main):008:1* i + i irb(main):009:1> => "22" Não existe diferença funcional entre os dois estilos, mas a forma { } é geralmente usada mais quando o resultado é importante, e do quando o resultado pode ser descartado, principalmente em loops mais extensos.

27 Expressões Agora que experimentamos um pouco com métodos e tipos em Ruby, podemos partir para a verificação das expressões possíveis na linguagem. Essa verificação é interessante, inclusive, por nos permitir comparar as possibilidades que o Ruby oferece em termos de construções sintáticas versus métodos de primeira classe presentes em sua hierarquia de objetos. A maior diferença entre o Ruby e a maioria das outras linguagens é que basicamente tudo o que pode retornar um valor em Ruby, retorna. Isso permite encadear expressões de uma maneira bem eficiente e prática. Por exemplo: ~$ irb irb(main):001:0> a = b = c = 0 => 0 irb(main):002:0> Class.superclass.superclass Isso se aplica também ao que seriam meras declarações em outras linguagens. Por exemplo: rating = if value == 0 "Terrible" elsif value < 2 "Passable" elseif value < 4 "Nice" else "Superb" Basicamente toda expressão em Ruby pode ser usada dessa forma. A sintaxe das principais expressões é a seguinte: