Apostila Ruby

5/12/2018 Apostila Ruby - slidepdf.com

http://slidepdf.com/reader/full/apostila-ruby 1/10

A Linguagem de Programação Ruby

David Flanagan &Yukihiro Matsumoto

Rio de Janeiro, 2008



A Linguagem de Programação Ruby

Do original The Ruby Programming Language Copyright © 2009 da Starlin Alta Con. Com. Ltda.

Authorized translation rom English language edition, entitled The Ruby Programming Language by DavidFlanagan and Yukihiro Matsumoto, published by O’Reilly Media, Inc. Copyright © 2007 by O’Reilly Media,Inc.This translation is published and sold by permission o O’Reilly Media,Inc., the owner o all rights topublish and sell the same. PORTUGUESE language edition published by Starlin Alta Con. Com. Ltda, Copyright© 2009 by Starlin Alta Con. Com. Ltda.

Todos os direitos reservados e protegidos pela Lei 5988 de 14/12/73. Nenhuma parte deste livro, semautorização prévia por escrito da editora, poderá ser reproduzida ou transmitida sejam quais orem osmeios empregados: eletrônico, mecânico, otográfco, gravação ou quaisquer outros. Todo o esorço oi eitopara ornecer a mais completa e adequada inormação, contudo a editora e o(s) autor(es) não assumemresponsabilidade pelos resultados e usos da inormação ornecida. Recomendamos aos leitores testar ainormação, bem como tomar todos os cuidados necessários (como o backup), antes da eetiva utilização.Este livro não contém CD-ROM, disquete ou qualquer outra mídia.

Erratas e atualizações: Sempre nos esorçamos para entregar a você, leitor, um livro livre de erros

técnicos ou de conteúdo; porém, nem sempre isso é conseguido, seja por motivo de alteração de sotware,interpretação ou mesmo quando alguns deslizes constam na versão original de alguns livros que traduzi-mos. Sendo assim, criamos em nosso site, www.altabooks.com.br, a seção Erratas, onde relataremos, coma devida correção, qualquer erro encontrado em nossos livros.

Avisos e Renúncia de Direitos: Este livro é vendido como está, sem garantia de qualquer tipo, sejaexpressa ou implícita.

Marcas Registradas:Todos os termos mencionados e reconhecidos como Marca Registrada e/ou comercialsão de responsabilidade de seus proprietários. A Editora inorma não estar associada a nenhum produto e/ou ornecedor apresentado no livro. No decorrer da obra, imagens, nomes de produtos e abricantes podem

ter sido utilizados, e desde já a Editora inorma que o uso é apenas ilustrativo e/ou educativo, não visandoao lucro, avorecimento ou desmerecimento do produto/abricante.

Produção Editorial: Starlin Alta Con. Com. LtdaCoordenação Editorial: Marcelo Utrine

Tradução: Arcanjo MiguelRevisão: Mara Lucia

Revisão Técnica: Marcelo CastelanniDiagramação: Francisca Santos

Fechamento: Raael CondeImpresso no Brasil

O código de propriedade intelectual de 1º de Julho de 1992 proíbe expressamente o uso coletivo semautorização dos detentores do direito autoral da obra, bem como a cópia ilegal do original. Esta práticageneralizada nos estabelecimentos de ensino, provoca uma brutal baixa nas vendas dos livros a ponto deimpossibilitar os autores de criarem novas obras.

Rua Viúva Cláudio, 291 – Jacaré

Rio de Janeiro – RJ. CEP: 20970-031Tel: 21 3278-8069/ Fax: 3277-1253site: www.altabooks.com.br

e-mail: [email protected]



iii

Sumário

Preácio ............................................................................................................vii

1. Introdução ...................................................................................................1

1.1 Uma Viagem Através do Ruby ..................................................................................................2

1.2 Experimente o Ruby .................................................................................................................9

1.3 Sobre este Livro .....................................................................................................................13

1.4 Um solucionador de Sudoku no Ruby ....................................................................................14

2. A Estrutura e Execução dos Programas do Ruby ...................................21

2.1 Estrutura Léxica .....................................................................................................................22

2.2 Estrutura Sintática..................................................................................................................28

2.3 Estrutura de Arquivo ..............................................................................................................30

2.4 Codifcando o Programa ........................................................................................................30

2.5 Execução do Programa ..........................................................................................................32

3. Tipos de Dados e Objetos .........................................................................35

3.1 Números ................................................................................................................................36

3.2 Texto ...................................................................................................................................... 39

3.3 Arrays .....................................................................................................................................55

3.4 Hashes ...................................................................................................................................57

3.5 Ranges ...................................................................................................................................59

3.6 Símbolos ................................................................................................................................61

3.7 True, False e Nil ......................................................................................................................62

3.8 Objetos ..................................................................................................................................62



iv | A Linguagem de Programação Ruby

4. Expressões e Operadores ......................................................................... 73

4.1 Literais e Palavras-Chaves Literais .........................................................................................74

4.2 Reerências de Variável ..........................................................................................................75

4.3 Reerências Constantes ..........................................................................................................76

4.4 Métodos de Invocações .........................................................................................................77

4.5 Atribuição ..............................................................................................................................79

4.6 Operadores ............................................................................................................................86

5. Declarações e Estruturas do Controle .................................................. 101

5.1 Condicionais ........................................................................................................................102

5.2 Laços ....................................................................................................................................109

5.3 Iteradores e Objetos Enumeráveis ........................................................................................112

5.4 Blocos ..................................................................................................................................121

5.5 Alterando Fluxo do Controle ................................................................................................125

5.6 Exceções e Manipulação de Exceção ...................................................................................132

5.7 BEGIN e END ........................................................................................................................141

5.8 Threads, Fibers e Continuação ..............................................................................................142

6. Métodos, Procs, Lambdas e Closures .................................................... 149

6.1 Defnindo Métodos Simples .................................................................................................1506.2 Nomes de Métodos ..............................................................................................................153

6.3 Métodos e Parênteses ..........................................................................................................155

6.4 Argumentos de Métodos ......................................................................................................157

6.5 Procs e Lambdas ..................................................................................................................163

6.6 Closures ...............................................................................................................................170

6.7 Objetos dos Métodos ...........................................................................................................172

6.8 Programação Funcional .......................................................................................................174

7. Classes e Módulos ................................................................................... 181

7.1 Defnindo uma Classe Simples .............................................................................................182

7.2 Visibilidade do Método: Public, Protected, Private ............................................................... 197

7.3 Subclassifção e Herança ......................................................................................................199

7.4 Criação de Objeto e Inicialização .........................................................................................205

7.5 Módulos ...............................................................................................................................2107.6 Carregando e Solicitando Módulos ......................................................................................214

7.7 Métodos Singleton e o Eigenclass ........................................................................................218



Sumário | v

7.8 Método Lookup ....................................................................................................................219

7.9 Lookup em Constantes ........................................................................................................221

8. Refexão e Metaprogramação ............................................................... 225

8.1 Tipos, Classes e Módulos ...................................................................................................... 226

8.2 Avaliando Strings e Blocks ...................................................................................................228

8.3 Variáveis e Constantes .........................................................................................................230

8.4 Métodos ...............................................................................................................................231

8.5 Hooks ...................................................................................................................................235

8.6 Rastreamento.......................................................................................................................236

8.7 ObjectSpace e GC ................................................................................................................238

8.8 Estruturas de Controle Customizadas ..................................................................................238

8.9 Métodos Missing e Constantes Missing ...............................................................................2408.10 Criando Métodos Dinamicamente ........................................................................................243

8.11 Alias Chaining ......................................................................................................................245

8.12 Linguagens de Domínio Específco .......................................................................................250

9. A Plataorma Ruby .................................................................................. 255

9.1 Strings .................................................................................................................................256

9.2 Expressões Regulares ...........................................................................................................261

9.3 Números e Matemática ........................................................................................................271

9.4 Data e Hora ..........................................................................................................................274

9.5 Coleções ..............................................................................................................................276

9.6 Arquivos e Diretórios ............................................................................................................295

9.7 Input/Output ........................................................................................................................299

9.8 Networking ..........................................................................................................................308

9.9 Threads e Concorrência ........................................................................................................313

10. O Ambiente do Ruby .............................................................................. 327

10.1 Invocando o Tradutor do Ruby ............................................................................................. 328

10.2 O Ambiente Top de Linha .....................................................................................................332

10.3 Extração Prática e Reportando Atalhos ................................................................................340

10.4 Chamando o OS ...................................................................................................................342

10.5 Segurança ............................................................................................................................345

Índice ..............................................................................................................349



vii

Preácio

Este livro é uma versão atualizada e expandida do livro Ruby in a Nutshell (O’Reilly) de Yukihiro Matsumoto,conhecido apenas como Matz. Ele segue a linha do clássico The C Programming Language (Prentice Hall) deBrian Kernighan e Dennis Ritchie e visa documentar a linguagem Ruby de uma orma compreensiva, massem a ormalidade de uma especifcação de linguagem. Ele oi escrito para programadores experientes, masque não conhecem o Ruby e para Programadores em Ruby que querem se aproundar nos conhecimentos

e ter um total domínio da linguagem.Você encontrará um guia da estrutura e organização deste livro no capítulo 1.

Agradecimentos

David Flanagan

Antes de tudo, quero agradecer ao Matz pela maravilhosa linguagem que ele desenvolveu, por sua ajuda

no esclarecimento da linguagem e ao Nutshell de onde este livro nasceu.

Também quero agradecer:

Why the lucky sti pelas maravilhosas artes gráfcas que agraciam as páginas (você as encontraránas páginas com o título do capítulo); e naturalmente, pelo seu livro sobre o Ruby, why’s (poignant) guide to Rub y, que você pode encontrar on-line no site http://poignantguide.net/ruby/ .

Meus revisores técnicos: David A. Black, diretor da Ruby Power and Light, LLC (http://www.rubypal.com ); Charles Oliver Nutter do time JRuby (http://www.jruby.org) na Sun Microsystems;Shyouhei Urabe, o responsável pela flial Ruby 1.8.6 e Ken Cooper. Seus comentários ajudaram a

melhorar a qualidade e a clareza do livro. Quaisquer erros que ainda existam são, com certeza, deminha própria responsabilidade.

Meu editor, Mike Loukides, por pedir e sempre me encorajar a escrever este livro e por suapaciência enquanto eu o escrevia.

E fnalmente, mas não menos importante, a minha amada e minha amília.

—David Flanagan

http://www.davidfanagan.com

Janeiro de 2008



viii | A Linguagem de Programação Ruby

Yukihiro Matsumoto

Além das pessoas listadas por David (exceto eu mesmo), agradeço pela ajuda dos membros da comunidadedo mundo todo, especialmente do Japão: Koichi Sasada, Nobuyoshi Nakada, Akira Tanaka, Shugo Maeda,Usaku Nakamura e Shyouhei Urabe são apenas alguns deles (não necessariamente nesta ordem).

E fnalmente, agradeço a minha amília, no qual espero que me perdoem pelo tempo que dediquei nodesenvolvimento do Ruby.

—Yukihiro Matsumoto

Janeiro de 2008

Convenções Usadas Neste LivroAs seguintes convenções tipográfcas estão neste livro:

Itálico

Indica termos novos, URLs, endereços de e-mails, nomes de arquivos e extensões de arquivos.

Largura Constante

Usada para lista de programas e também dentro de parágraos para se reerir aos elementos dosprogramas como, por exemplo, variáveis, nomes de unções, tipos de dados, ambientes variáveis,declarações e palavras-chaves.

Largura Constante em Negrito

Mostra os comandos ou outro texto que devam ser digitados literariamente pelo usuário.

Largura Constante Itálica

Mostra textos que devem ser recolocados com valores supridos pelo usuário ou por valores deter-minados pelo contexto.

Exemplos do Uso de CódigosEsse livro existe para ajudar você em seu trabalho. De uma orma geral, você pode usar o código destelivro em seus programas e documentação. Você não precisa entrar em contato para pedir permissão, amenos que você esteja reproduzindo uma porção signifcativa do código. Por exemplo, para escrever um

programa que use vários pedaços do código deste livro não é necessário ter permissão. Vender ou distribuirum CD-ROM de exemplos do livro O’Reilly requer permissão. Responder uma pergunta citando este livro ecitando exemplos dos códigos não requer permissão. Incorporar uma grande quantidade de exemplos decódigos deste livro para sua documentação do produto requer permissão.

Agradecemos, mas não exigimos atribuição. Uma atribuição geralmente inclui o título, o autor, o editore o ISBN. Por exemplo: “A Linguagem de Programação Ruby por David Flanagan e Yukihiro Matsumoto.Direitos Reservados 2008 David Flanagan e Yukihiro Matsumoto, 978-0-596-51617-8”.

Se você acha que, de alguma orma, os exemplos dos códigos que você pode usar estão além do permitidoou da permissão dada acima, por avor nos contate pelo e-mail [email protected] .



Preácio | ix

Como Entrar em ContatoPor avor, enderece comentários e perguntas sobre este livro para o editor:

Editora Alta BooksRua Viúva Cláudio, 291 – JacaréRio de Janeiro – RJCEP – 20551-010Tels: (21) 3278-8069/8419Fax: (21) 3277-1253E-mail: [email protected]: www.altabooks.com.br

Apostila Ruby

Documents

Transcript of Apostila Ruby