Use o código e tenha 10% de desconto!

Ruby Aprenda a programar na linguagem mais divertida

Lucas Souza

Prefácio

Ruby é uma linguagem dinâmica, orientada a objetos e que possui algumas características funcionais. Seu criador, Yukihiro Matsumoto, queria uma linguagem que juntasse programação funcional e imperativa, mas acima de tudo que fosse uma linguagem legível. Esta é uma das grandes vantagens da linguagem, ser extremamente legível.

Este livro é basicamente um tutorial e uma referência para a linguagem Ruby. Ele cobre a maioria das características da linguagem e também suas principais APIs: String , Enumerable , File etc. Além disso, veremos questões mais avançadas, que permitirão um maior aproveitamento da linguagem, como metaprogramação, distribuição de código e gerenciamento de dependências. 

 

Por que Ruby?

Além das características citadas anteriormente, Ruby é a linguagem que eu utilizo para a maioria dos programas que escrevo, principalmente quando vou começar aplicações web. Trabalho há dois anos com Ruby, e posso dizer que a linguagem é extremamente produtiva e simples, consigo fazer coisas simples, com poucas linhas de código.

Nos últimos anos, a linguagem progrediu assustadoramente. A comunidade cresceu bastante: possui o Rubygems, onde se encontra um grande número de projetos que auxiliam o dia a dia do desenvolvedor Ruby. No GitHub, a grande maioria dos repositórios é escrita em Ruby, o que permite que a comunidade contribua cada vez mais para a melhoria do ambiente em volta da linguagem.

Além disso, o framework MVC Ruby on Rails permite a criação de aplicações web com extrema rapidez. Essa agilidade tem sido considerada por várias startups no momento da criação de seus produtos. A vantagem é que o número de vagas disponíveis no mercado cresce a cada dia, principalmente em polos de desenvolvimento como a Califórnia.

Atualmente, aprender apenas Rails não é o suficiente. É necessário um bom conhecimento da linguagem para criar códigos que facilitem a manutenção e criação de novas funcionalidades. Aprender mais sobre a linguagem Ruby faz com que você consiga escrever códigos mais legíveis e deixe de lado vícios que podem ter vindo de outras linguagens com as quais você trabalhava.

 

Sumário

  • 1 Uma introdução prática à linguagem Ruby
    • 1.1 Quando? Onde? Por quê?
    • 1.2 Instalação
    • 1.3 Tudo pronto... mãos à massa: inferência de tipos
    • 1.4 Tipagem forte e dinâmica
    • 1.5 Uma linguagem interpretada e com classes abertas
    • 1.6 Onde eu usaria Ruby?
  • 2 Seu primeiro passo no Ruby: convenções e as diferentes estruturas primitivas
    • 2.1 Mais tipos no Ruby
    • 2.2 Comente seu código
    • 2.3 O trabalho com números
    • 2.4 Representação de textos com as Strings
    • 2.5 Estruturas de controle
    • 2.6 Entenda o valor nulo
    • 2.7 Substitua o "if not" por "unless"
    • 2.8 Iterações simples com for, while, until
    • 2.9 As outras formas de declarar Strings
    • 2.10 Próximos passos
  • 3 O começo da nossa aplicação
    • 3.1 A definição da classe Livro
    • 3.2 Crie a estrutura do projeto
    • 3.3 Defina os atributos de instância
    • 3.4 Sobrescrevendo o método to_s
    • 3.5 Alteração e leitura de atributos
    • 3.6 Atributos nem tão privados assim
    • 3.7 Grandes poderes, grandes responsabilidades
  • 4 Estruturas de dados
    • 4.1 Trabalhe com Arrays
    • 4.2 Guardando nossos livros
    • 4.3 Percorrendo meu array
    • 4.4 Como separar os livros por categoria: trabalhe com Hash
    • 4.5 Indo mais a fundo: Hashes no Ruby 1.9
    • 4.6 Indo mais a fundo: o operador ||=
    • 4.7 Indo mais a fundo: o tipo Set
    • 4.8 Próximos passos
  • 5 Ruby e a programação funcional
    • 5.1 O que é programação funcional
    • 5.2 Funções puras
    • 5.3 Comandos que retornam valores
    • 5.4 Funções de alta ordem: higher-order functions
    • 5.5 Crie seu próprio código que usa um bloco de código
    • 5.6 Explorando a API Enumerable
    • 5.7 Para saber mais: outras maneiras de criar blocos
    • 5.8 Para saber mais: currying
    • 5.9 Para saber mais: closure
    • 5.10 Próximos passos
  • 6 Explorando API File
    • 6.1 Um pouco da classe File
    • 6.2 Serialização de objetos
    • 6.3 Salvando objetos em arquivos
    • 6.4 Recuperando objetos salvos
    • 6.5 Próximos passos
  • 7 Compartilhando comportamentos: herança, módulos e mixins
    • 7.1 Herança: compartilhando comportamentos com classes
    • 7.2 Herança e variáveis de instância
    • 7.3 Os custos no uso da herança
    • 7.4 Módulos
    • 7.5 Indo mais a fundo: constant Lookup de dentro para fora
    • 7.6 Duck Typing: o polimorfismo aplicado no Ruby
    • 7.7 Herança ou mixing? Qual devo usar?
  • 8 Metaprogramação e seus segredos
    • 8.1 Entenda o self e method calling
    • 8.2 O impacto do self na definição de classes
    • 8.3 Singleton Class e a ordem da busca de métodos
    • 8.4 Indo mais a fundo: acessando a singleton class
    • 8.5 Metaprogramação e as definições de uma classe
    • 8.6 Criando um framework para persistir objetos em arquivos
    • 8.7 Gerenciando exceções e erros
    • 8.8 A exclusão de dados implementada com metaprogramação
    • 8.9 Method lookup e method missing
    • 8.10 Utilizando expressões regulares nas buscas
    • 8.11 Próximos passos
  • 9 As bibliotecas no universo Ruby
    • 9.1 Como manusear suas gems com o Rubygems
    • 9.2 Gerenciando várias versões de uma gem
    • 9.3 Gerencie dependências com o Bundler
    • 9.4 Criando e distribuindo gems
    • 9.5 Distribuição da biblioteca
    • 9.6 Próximos passos
  • 10 Criando tasks usando rake
    • 10.1 Parâmetros na rake task
    • 10.2 Tasks com pré-requisitos
    • 10.3 Próximos passos
  • 11 RVM (Ruby Version Manager)
    • 11.1 Instalação
    • 11.2 Instalando diferentes Rubies
    • 11.3 Organize suas gems utilizando gemsets
    • 11.4 Troque automaticamente de gemsets com .rvmrc
    • 11.5 Próximos passos
  • 12 Ruby 2.0
    • 12.1 Evitando monkey patches com refinements
    • 12.2 Named parameters
    • 12.3 Utilize prepend em vez de include
    • 12.4 Utilizando lazy load no módulo Enumerable
    • 12.5 Encoding UTF-8
    • 12.6 Próximos passos
  • 13 Apêndice: concorrência e paralelismo
    • 13.1 Threads
    • 13.2 Múltiplos processos
    • 13.3 Fibers
    • 13.4 O design pattern Reactor
    • 13.5 Conclusão

Dados do produto

Número de páginas:
292
ISBN:
978-85-66250-24-4
Data publicação:
10/2012

Compartilhe!

Compartilhe no Facebook Compartilhe no Twitter