2
1.3
Tudo pronto... mãos à massa: Inferência de tipos . . . . . . . . . . . .
9
1.4
Tipagem forte e dinâmica . . . . . . . . . . . . . . . . . . . . . . . . . .
10
1.5
Uma linguagem interpretada e com classes abertas . . . . . . . . . . .
11
1.6
Onde eu usaria Ruby? . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13
2
Seu primeiro passo no Ruby: convenções e as diferentes estruturas primi-
tivas
15
2.1
Mais tipos no Ruby . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16
2.2
Comente seu código . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16
2.3
O trabalho com números . . . . . . . . . . . . . . . . . . . . . . . . . .
17
2.4
Representação de textos com as Strings . . . . . . . . . . . . . . . . . .
18
2.5
Estruturas de Controle . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.6
Entenda o valor nulo . . . . . . . . . . . . . . . . . . . . . . . . . . . .
21
2.7
Substitua o if not por unless . . . . . . . . . . . . . . . . . . . . . .
21
2.8
Iterações simples com for, while, until
. . . . . . . . . . . . . . . . . .
22
2.9
As outras formas de declarar Strings . . . . . . . . . . . . . . . . . . .
23
2.10 Próximos passos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
25
3
O começo da nossa aplicação
27
3.1
A definição da classe Livro . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.2
Crie a estrutura do projeto . . . . . . . . . . . . . . . . . . . . . . . . .
33
3.3
Defina os atributos de instância . . . . . . . . . . . . . . . . . . . . . .
35
vii
Sumário
Casa do Código
37section.3.4
3.5
Alteração e leitura de atributos . . . . . . . . . . . . . . . . . . . . . . .
38
3.6
Atributos nem tão privados assim . . . . . . . . . . . . . . . . . . . . .
43
3.7
Grandes poderes, grandes responsabilidades . . . . . . . . . . . . . . .
43
4
Estruturas de dados
47
4.1
Trabalhe com Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
4.2
Guardando nosso livros . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.3
Percorrendo meu array . . . . . . . . . . . . . . . . . . . . . . . . . . .
52
4.4
Como separar os livros por categoria: trabalhe com Hash . . . . . . .
52
4.5
Indo mais a fundo: Hashes no Ruby 1.9 . . . . . . . . . . . . . . . . . .
58
4.6
Indo mais a fundo: O operador ||= . . . . . . . . . . . . . . . . . . . .
59
4.7
Indo mais a fundo: O tipo Set . . . . . . . . . . . . . . . . . . . . . . .
59
4.8
E agora? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
5
Ruby e a programação funcional
65
5.1
O que é programação funcional . . . . . . . . . . . . . . . . . . . . . .
65
5.2
Funções puras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
5.3
Comandos que retornam valores . . . . . . . . . . . . . . . . . . . . . 67
5.4
Funções de alta ordem Higher-order functions . . . . . . . . . . . . . . 69
5.5
Crie seu próprio código que usa um bloco de código . . . . . . . . . . 70
5.6
Explorando a API Enumerable
. . . . . . . . . . . . . . . . . . . . . . .
74
5.7
Para saber mais: Outras maneiras de criar blocos . . . . . . . . . . . . 80
5.8
Para saber mais: Currying . . . . . . . . . . . . . . . . . . . . . . . . . 86
5.9
Para saber mais: Closure . . . . . . . . . . . . . . . . . . . . . . . . . . 88
5.10 Próximos passos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
6
Explorando API File
91
6.1
Um pouco da classe File . . . . . . . . . . . . . . . . . . . . . . . . . . .
91
6.2
Serialização de objetos . . . . . . . . . . . . . . . . . . . . . . . . . . .
93
6.3
Salvando objetos em arquivos . . . . . . . . . . . . . . . . . . . . . . . 94
6.4
Recuperando objetos salvos . . . . . . . . . . . . . . . . . . . . . . . .
97
6.5
Próximos passos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
viii
Casa do Código
Sumário
7
Compartilhando Comportamentos: Herança, Módulos e Mixins
101
7.1
Herança: Compartilhando comportamentos com classes
. . . . . . . 102
7.2
Herança e variáveis de instância . . . . . . . . . . . . . . . . . . . . . . 106
7.3
Os custos no uso da herança . . . . . . . . . . . . . . . . . . . . . . . . 112
7.4
Módulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
7.5
Indo mais a fundo: Constant Lookup de dentro para fora . . . . . . . 123
7.6
Duck Typing: o polimorfismo aplicado no Ruby
. . . . . . . . . . . . 125
7.7
Herança ou Mixing? Qual devo usar? . . . . . . . . . . . . . . . . . . . 130
8
Metaprogramação e seus segredos
133
8.1
Entenda o self e method calling . . . . . . . . . . . . . . . . . . . . . . 134
8.2
O impacto do self na definição de classes . . . . . . . . . . . . . . . . . 136
8.3
Singleton Class e a ordem da busca de métodos . . . . . . . . . . . . . 138
8.4
Indo mais a fundo: Acessando a Singleton Class . . . . . . . . . . . . . 142
8.5
Metaprogramação e as definições de uma classe . . . . . . . . . . . . . 144