Linguagem ruby

Sumário
I Sobre essa Apostila 2
II Informações Básicas 4
III GNU Free Documentation License 9
IV Linguagem Ruby 18
1 O que é a Linguagem Ruby 19
2 Plano de ensino 20
2.1 Objetivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.2 Público Alvo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.3 Pré-requisitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.4 Descrição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.5 Metodologia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.6 Cronograma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.7 Programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.8 Avaliação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.9 Bibliograﬁa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3 Introdução 22
3.1 Classes, Objetos e Métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.2 Variaveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.3 Outro conceitos importantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4 Instalação e Início da Linguagem 24
4.1 Instalação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
4.2 Início da Linguagem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
5 Conhecendo um pouco a linguagem 26
5.1 Variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
5.2 Tipos Básicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
6 Estruturas de Controle e Comentários no Código 40
6.1 Condicionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
6.1.1 If/Else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
1

CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
6.1.2 Case . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
6.2 Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
6.2.1 While . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
6.2.2 for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
6.2.3 until . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
6.3 Comentando o Código . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
7 Classes 45
7.1 Variáveis de Instância . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
7.2 Variáveis de Classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
8 Entradas e Saídas 57
8.1 Fluxos de Entradas e Saídas Simples . . . . . . . . . . . . . . . . . . . . . . . . . . 57
8.2 Arquivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
2

Conteúdo
O conteúdo dessa apostila é fruto da compilação de diversos materiais livres publicados na in-
ternet, disponíveis em diversos sites ou originalmente produzido no CDTC (http://www.cdtc.org.br.)
O formato original deste material bem como sua atualização está disponível dentro da licença
GNU Free Documentation License, cujo teor integral encontra-se aqui reproduzido na seção de
mesmo nome, tendo inclusive uma versão traduzida (não oﬁcial).
A revisão e alteração vem sendo realizada pelo CDTC (suporte@cdtc.org.br) desde outubro
de 2006. Críticas e sugestões construtivas serão bem-vindas a qualquer hora.
Autores
A autoria deste é de responsabilidade de Diego de Aquino Soares (diego@cdtc.org.br).
O texto original faz parte do projeto Centro de Difusão de Tecnologia e Conhecimento que
vêm sendo realizado pelo ITI (Instituto Nacional de Tecnologia da Informação) em conjunto com
outros parceiros institucionais, e com as universidades federais brasileiras que tem produzido e
utilizado Software Livre apoiando inclusive a comunidade Free Software junto a outras entidades
no país.
Informações adicionais podem ser obtidas através do email ouvidoria@cdtc.org.br, ou da
home page da entidade, através da URL http://www.cdtc.org.br.
Garantias
O material contido nesta apostila é isento de garantias e o seu uso é de inteira responsabi-
lidade do usuário/leitor. Os autores, bem como o ITI e seus parceiros, não se responsabilizam
direta ou indiretamente por qualquer prejuízo oriundo da utilização do material aqui contido.
Licença
Copyright ©2006, Instituto Nacional de Tecnologia da Informação (cdtc@iti.gov.br) .
Permission is granted to copy, distribute and/or modify this document under the terms
of the GNU Free Documentation License, Version 1.1 or any later version published by
the Free Software Foundation; with the Invariant Chapter being SOBRE ESSA APOS-
TILA. A copy of the license is included in the section entitled GNU Free Documentation
License.
4

Parte II
Informações Básicas
5

Sobre o CDTC
Objetivo Geral
O Projeto CDTC visa a promoção e o desenvolvimento de ações que incentivem a dissemina-
ção de soluções que utilizem padrões abertos e não proprietários de tecnologia, em proveito do
desenvolvimento social, cultural, político, tecnológico e econômico da sociedade brasileira.
Objetivo Específico
Auxiliar o Governo Federal na implantação do plano nacional de software não-proprietário e
de código fonte aberto, identificando e mobilizando grupos de formadores de opinião dentre os
servidores públicos e agentes políticos da União Federal, estimulando e incentivando o mercado
nacional a adotar novos modelos de negócio da tecnologia da informação e de novos negócios
de comunicação com base em software não-proprietário e de código fonte aberto, oferecendo
treinamento específico para técnicos, profissionais de suporte e funcionários públicos usuários,
criando grupos de funcionários públicos que irão treinar outros funcionários públicos e atuar como
incentivadores e defensores dos produtos de software não proprietários e código fonte aberto, ofe-
recendo conteúdo técnico on-line para serviços de suporte, ferramentas para desenvolvimento de
produtos de software não proprietários e do seu código fonte livre, articulando redes de terceiros
(dentro e fora do governo) fornecedoras de educação, pesquisa, desenvolvimento e teste de pro-
dutos de software livre.
Guia do aluno
Neste guia, você terá reunidas uma série de informações importantes para que você comece
seu curso. São elas:
• Licenças para cópia de material disponível;
• Os 10 mandamentos do aluno de Educação a Distância;
• Como participar dos foruns e da wikipédia;
• Primeiros passos.
É muito importante que você entre em contato com TODAS estas informações, seguindo o
roteiro acima.
Licença
Copyright ©2006, Instituto Nacional de Tecnologia da Informação (cdtc@iti.gov.br).
6

É dada permissão para copiar, distribuir e/ou modiﬁcar este documento sob os termos
da Licença de Documentação Livre GNU, Versão 1.1 ou qualquer versão posterior
públicada pela Free Software Foundation; com o Capitulo Invariante SOBRE ESSA
APOSTILA. Uma cópia da licença está inclusa na seção entitulada "Licença de Docu-
mentação Livre GNU".
Os 10 mandamentos do aluno de educação online
• 1. Acesso à Internet: ter endereço eletrônico, um provedor e um equipamento adequado é
pré-requisito para a participação nos cursos a distância;
• 2. Habilidade e disposição para operar programas: ter conhecimentos básicos de Informá-
tica é necessário para poder executar as tarefas;
• 3. Vontade para aprender colaborativamente: interagir, ser participativo no ensino a distân-
cia conta muitos pontos, pois irá colaborar para o processo ensino-aprendizagem pessoal,
dos colegas e dos professores;
• 4. Comportamentos compatíveis com a etiqueta: mostrar-se interessado em conhecer seus
colegas de turma respeitando-os e se fazendo ser respeitado pelos mesmos;
• 5. Organização pessoal: planejar e organizar tudo é fundamental para facilitar a sua revisão
e a sua recuperação de materiais;
• 6. Vontade para realizar as atividades no tempo correto: anotar todas as suas obrigações e
realizá-las em tempo real;
• 7. Curiosidade e abertura para inovações: aceitar novas idéias e inovar sempre;
• 8. Flexibilidade e adaptação: requisitos necessário à mudança tecnológica, aprendizagens
e descobertas;
• 9. Objetividade em sua comunicação: comunicar-se de forma clara, breve e transparente é
ponto - chave na comunicação pela Internet;
• 10. Responsabilidade: ser responsável por seu próprio aprendizado. O ambiente virtual não
controla a sua dedicação, mas reﬂete os resultados do seu esforço e da sua colaboração.
Como participar dos fóruns e Wikipédia
Você tem um problema e precisa de ajuda?
Podemos te ajudar de 2 formas:
A primeira é o uso dos fóruns de notícias e de dúvidas gerais que se distinguem pelo uso:
. O fórum de notícias tem por objetivo disponibilizar um meio de acesso rápido a informações
que sejam pertinentes ao curso (avisos, notícias). As mensagens postadas nele são enviadas a
7

todos participantes. Assim, se o monitor ou algum outro participante tiver uma informação que
interesse ao grupo, favor postá-la aqui.
Porém, se o que você deseja é resolver alguma dúvida ou discutir algum tópico específico do
curso. É recomendado que você faça uso do Fórum de dúvidas gerais que lhe dá recursos mais
efetivos para esta prática.
. O fórum de dúvidas gerais tem por objetivo disponibilizar um meio fácil, rápido e interativo
para solucionar suas dúvidas e trocar experiências. As mensagens postadas nele são enviadas
a todos participantes do curso. Assim, fica muito mais fácil obter respostas, já que todos podem
ajudar.
Se você receber uma mensagem com algum tópico que saiba responder, não se preocupe com a
formalização ou a gramática. Responda! E não se esqueça de que antes de abrir um novo tópico
é recomendável ver se a sua pergunta já foi feita por outro participante.
A segunda forma se dá pelas Wikis:
. Uma wiki é uma página web que pode ser editada colaborativamente, ou seja, qualquer par-
ticipante pode inserir, editar, apagar textos. As versões antigas vão sendo arquivadas e podem
ser recuperadas a qualquer momento que um dos participantes o desejar. Assim, ela oferece um
ótimo suporte a processos de aprendizagem colaborativa. A maior wiki na web é o site "Wikipé-
dia", uma experiência grandiosa de construção de uma enciclopédia de forma colaborativa, por
pessoas de todas as partes do mundo. Acesse-a em português pelos links:
• Página principal da Wiki - http://pt.wikipedia.org/wiki/
Agradecemos antecipadamente a sua colaboração com a aprendizagem do grupo!
Primeiros Passos
Para uma melhor aprendizagem é recomendável que você siga os seguintes passos:
• Ler o Plano de Ensino e entender a que seu curso se dispõe a ensinar;
• Ler a Ambientação do Moodle para aprender a navegar neste ambiente e se utilizar das
ferramentas básicas do mesmo;
• Entrar nas lições seguindo a seqüência descrita no Plano de Ensino;
• Qualquer dúvida, reporte ao Fórum de Dúvidas Gerais.
Perfil do Tutor
Segue-se uma descrição do tutor ideal, baseada no feedback de alunos e de tutores.
O tutor ideal é um modelo de excelência: é consistente, justo e profissional nos respectivos
valores e atitudes, incentiva mas é honesto, imparcial, amável, positivo, respeitador, aceita as
idéias dos estudantes, é paciente, pessoal, tolerante, apreciativo, compreensivo e pronto a ajudar.
8

A classificação por um tutor desta natureza proporciona o melhor feedback possível, é crucial, e,
para a maior parte dos alunos, constitui o ponto central do processo de aprendizagem.’ Este tutor
ou instrutor:
• fornece explicações claras acerca do que ele espera e do estilo de classificação que irá
utilizar;
• gosta que lhe façam perguntas adicionais;
• identifica as nossas falhas, mas corrige-as amavelmente’, diz um estudante, ’e explica por-
que motivo a classificação foi ou não foi atribuída’;
• tece comentários completos e construtivos, mas de forma agradável (em contraste com um
reparo de um estudante: ’os comentários deixam-nos com uma sensação de crítica, de
ameaça e de nervossismo’)
• dá uma ajuda complementar para encorajar um estudante em dificuldade;
• esclarece pontos que não foram entendidos, ou corretamente aprendidos anteriormente;
• ajuda o estudante a alcançar os seus objetivos;
• é flexível quando necessário;
• mostra um interesse genuíno em motivar os alunos (mesmo os principiantes e, por isso,
talvez numa fase menos interessante para o tutor);
• escreve todas as correções de forma legível e com um nível de pormenorização adequado;
• acima de tudo, devolve os trabalhos rapidamente;
9

Parte III
GNU Free Documentation License
10

(Traduzido pelo João S. O. Bueno através do CIPSGA em 2001)
Esta é uma tradução não oficial da Licença de Documentação Livre GNU em Português Brasi-
leiro. Ela não é publicada pela Free Software Foundation, e não se aplica legalmente a distribuição
de textos que usem a GFDL - apenas o texto original em Inglês da GNU FDL faz isso. Entretanto,
nós esperamos que esta tradução ajude falantes de português a entenderem melhor a GFDL.
This is an unofficial translation of the GNU General Documentation License into Brazilian Por-
tuguese. It was not published by the Free Software Foundation, and does not legally state the
distribution terms for software that uses the GFDL–only the original English text of the GFDL does
that. However, we hope that this translation will help Portuguese speakers understand the GFDL
better.
Licença de Documentação Livre GNU Versão 1.1, Março de 2000
Copyright (C) 2000 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
É permitido a qualquer um copiar e distribuir cópias exatas deste documento de licença, mas
não é permitido alterá-lo.
INTRODUÇÃO
O propósito desta Licença é deixar um manual, livro-texto ou outro documento escrito "livre"no
sentido de liberdade: assegurar a qualquer um a efetiva liberdade de copiá-lo ou redistribui-lo,
com ou sem modificações, comercialmente ou não. Secundariamente, esta Licença mantém
para o autor e editor uma forma de ter crédito por seu trabalho, sem ser considerado responsável
pelas modificações feitas por terceiros.
Esta Licença é um tipo de "copyleft"("direitos revertidos"), o que significa que derivações do
documento precisam ser livres no mesmo sentido. Ela complementa a GNU Licença Pública Ge-
ral (GNU GPL), que é um copyleft para software livre.
Nós fizemos esta Licença para que seja usada em manuais de software livre, por que software
livre precisa de documentação livre: um programa livre deve ser acompanhado de manuais que
provenham as mesmas liberdades que o software possui. Mas esta Licença não está restrita a
manuais de software; ela pode ser usada para qualquer trabalho em texto, independentemente
do assunto ou se ele é publicado como um livro impresso. Nós recomendamos esta Licença prin-
cipalmente para trabalhos cujo propósito seja de introdução ou referência.
APLICABILIDADE E DEFINIÇÕES
Esta Licença se aplica a qualquer manual ou outro texto que contenha uma nota colocada pelo
detentor dos direitos autorais dizendo que ele pode ser distribuído sob os termos desta Licença.
O "Documento"abaixo se refere a qualquer manual ou texto. Qualquer pessoa do público é um
11

licenciado e é referida como "você".
Uma "Versão Modificada"do Documento se refere a qualquer trabalho contendo o documento
ou uma parte dele, quer copiada exatamente, quer com modificações e/ou traduzida em outra
língua.
Uma "Seção Secundária"é um apêndice ou uma seção inicial do Documento que trata ex-
clusivamente da relação dos editores ou dos autores do Documento com o assunto geral do
Documento (ou assuntos relacionados) e não contém nada que poderia ser incluído diretamente
nesse assunto geral (Por exemplo, se o Documento é em parte um livro texto de matemática, a
Seção Secundária pode não explicar nada de matemática).
Essa relação poderia ser uma questão de ligação histórica com o assunto, ou matérias relaci-
onadas, ou de posições legais, comerciais, filosóficas, éticas ou políticas relacionadas ao mesmo.
As "Seções Invariantes"são certas Seções Secundárias cujos títulos são designados, como
sendo de Seções Invariantes, na nota que diz que o Documento é publicado sob esta Licença.
Os "Textos de Capa"são certos trechos curtos de texto que são listados, como Textos de Capa
Frontal ou Textos da Quarta Capa, na nota que diz que o texto é publicado sob esta Licença.
Uma cópia "Transparente"do Documento significa uma cópia que pode ser lida automatica-
mente, representada num formato cuja especificação esteja disponível ao público geral, cujos
conteúdos possam ser vistos e editados diretamente e sem mecanismos especiais com editores
de texto genéricos ou (para imagens compostas de pixels) programas de pintura genéricos ou
(para desenhos) por algum editor de desenhos grandemente difundido, e que seja passível de
servir como entrada a formatadores de texto ou para tradução automática para uma variedade
de formatos que sirvam de entrada para formatadores de texto. Uma cópia feita em um formato
de arquivo outrossim Transparente cuja constituição tenha sido projetada para atrapalhar ou de-
sencorajar modificações subsequentes pelos leitores não é Transparente. Uma cópia que não é
"Transparente"é chamada de "Opaca".
Exemplos de formatos que podem ser usados para cópias Transparentes incluem ASCII sim-
ples sem marcações, formato de entrada do Texinfo, formato de entrada do LaTex, SGML ou XML
usando uma DTD disponibilizada publicamente, e HTML simples, compatível com os padrões, e
projetado para ser modificado por pessoas. Formatos opacos incluem PostScript, PDF, formatos
proprietários que podem ser lidos e editados apenas com processadores de texto proprietários,
SGML ou XML para os quais a DTD e/ou ferramentas de processamento e edição não estejam
disponíveis para o público, e HTML gerado automaticamente por alguns editores de texto com
finalidade apenas de saída.
A "Página do Título"significa, para um livro impresso, a página do título propriamente dita,
mais quaisquer páginas subsequentes quantas forem necessárias para conter, de forma legível,
o material que esta Licença requer que apareça na página do título. Para trabalhos que não
tenham uma página do título, "Página do Título"significa o texto próximo da aparição mais proe-
minente do título do trabalho, precedendo o início do corpo do texto.
12

FAZENDO CÓPIAS EXATAS
Você pode copiar e distribuir o Documento em qualquer meio, de forma comercial ou não
comercial, desde que esta Licença, as notas de copyright, e a nota de licença dizendo que esta
Licença se aplica ao documento estejam reproduzidas em todas as cópias, e que você não acres-
cente nenhuma outra condição, quaisquer que sejam, às desta Licença.
Você não pode usar medidas técnicas para obstruir ou controlar a leitura ou confecção de
cópias subsequentes das cópias que você fizer ou distribuir. Entretanto, você pode aceitar com-
pensação em troca de cópias. Se você distribuir uma quantidade grande o suficiente de cópias,
você também precisa respeitar as condições da seção 3.
Você também pode emprestar cópias, sob as mesmas condições colocadas acima, e também
pode exibir cópias publicamente.
FAZENDO CÓPIAS EM QUANTIDADE
Se você publicar cópias do Documento em número maior que 100, e a nota de licença do
Documento obrigar Textos de Capa, você precisará incluir as cópias em capas que tragam, clara
e legivelmente, todos esses Textos de Capa: Textos de Capa da Frente na capa da frente, e
Textos da Quarta Capa na capa de trás. Ambas as capas também precisam identificar clara e
legivelmente você como o editor dessas cópias. A capa da frente precisa apresentar o título com-
pleto com todas as palavras do título igualmente proeminentes e visíveis. Você pode adicionar
outros materiais às capas. Fazer cópias com modificações limitadas às capas, tanto quanto estas
preservem o título do documento e satisfaçam a essas condições, pode ser tratado como cópia
exata em outros aspectos.
Se os textos requeridos em qualquer das capas for muito volumoso para caber de forma
legível, você deve colocar os primeiros (tantos quantos couberem de forma razoável) na capa
verdadeira, e continuar os outros nas páginas adjacentes.
Se você publicar ou distribuir cópias Opacas do Documento em número maior que 100, você
precisa ou incluir uma cópia Transparente que possa ser lida automaticamente com cada cópia
Opaca, ou informar, em ou com, cada cópia Opaca a localização de uma cópia Transparente
completa do Documento acessível publicamente em uma rede de computadores, à qual o público
usuário de redes tenha acesso a download gratuito e anônimo utilizando padrões públicos de
protocolos de rede. Se você utilizar o segundo método, você precisará tomar cuidados razoavel-
mente prudentes, quando iniciar a distribuição de cópias Opacas em quantidade, para assegurar
que esta cópia Transparente vai permanecer acessível desta forma na localização especificada
por pelo menos um ano depois da última vez em que você distribuir uma cópia Opaca (direta-
mente ou através de seus agentes ou distribuidores) daquela edição para o público.
É pedido, mas não é obrigatório, que você contate os autores do Documento bem antes de
redistribuir qualquer grande número de cópias, para lhes dar uma oportunidade de prover você
com uma versão atualizada do Documento.
13

MODIFICAÇÕES
Você pode copiar e distribuir uma Versão Modificada do Documento sob as condições das se-
ções 2 e 3 acima, desde que você publique a Versão Modificada estritamente sob esta Licença,
com a Versão Modificada tomando o papel do Documento, de forma a licenciar a distribuição
e modificação da Versão Modificada para quem quer que possua uma cópia da mesma. Além
disso, você precisa fazer o seguinte na versão modificada:
A. Usar na Página de Título (e nas capas, se houver alguma) um título distinto daquele do Do-
cumento, e daqueles de versões anteriores (que deveriam, se houvesse algum, estarem listados
na seção "Histórico do Documento"). Você pode usar o mesmo título de uma versão anterior se
o editor original daquela versão lhe der permissão;
B. Listar na Página de Título, como autores, uma ou mais das pessoas ou entidades responsá-
veis pela autoria das modificações na Versão Modificada, conjuntamente com pelo menos cinco
dos autores principais do Documento (todos os seus autores principais, se ele tiver menos que
cinco);
C. Colocar na Página de Título o nome do editor da Versão Modificada, como o editor;
D. Preservar todas as notas de copyright do Documento;
E. Adicionar uma nota de copyright apropriada para suas próprias modificações adjacente às
outras notas de copyright;
F. Incluir, imediatamente depois das notas de copyright, uma nota de licença dando ao público
o direito de usar a Versão Modificada sob os termos desta Licença, na forma mostrada no tópico
abaixo;
G. Preservar nessa nota de licença as listas completas das Seções Invariantes e os Textos de
Capa requeridos dados na nota de licença do Documento;
H. Incluir uma cópia inalterada desta Licença;
I. Preservar a seção entitulada "Histórico", e seu título, e adicionar à mesma um item dizendo
pelo menos o título, ano, novos autores e editor da Versão Modificada como dados na Página de
Título. Se não houver uma sessão denominada "Histórico"no Documento, criar uma dizendo o
título, ano, autores, e editor do Documento como dados em sua Página de Título, então adicionar
um item descrevendo a Versão Modificada, tal como descrito na sentença anterior;
J. Preservar o endereço de rede, se algum, dado no Documento para acesso público a uma
cópia Transparente do Documento, e da mesma forma, as localizações de rede dadas no Docu-
mento para as versões anteriores em que ele foi baseado. Elas podem ser colocadas na seção
"Histórico". Você pode omitir uma localização na rede para um trabalho que tenha sido publicado
pelo menos quatro anos antes do Documento, ou se o editor original da versão a que ela se refira
der sua permissão;
K. Em qualquer seção entitulada "Agradecimentos"ou "Dedicatórias", preservar o título da
14

seção e preservar a seção em toda substância e fim de cada um dos agradecimentos de contri-
buidores e/ou dedicatórias dados;
L. Preservar todas as Seções Invariantes do Documento, inalteradas em seus textos ou em
seus títulos. Números de seção ou equivalentes não são considerados parte dos títulos da seção;
M. Apagar qualquer seção entitulada "Endossos". Tal sessão não pode ser incluída na Versão
Modificada;
N. Não reentitular qualquer seção existente com o título "Endossos"ou com qualquer outro
título dado a uma Seção Invariante.
Se a Versão Modificada incluir novas seções iniciais ou apêndices que se qualifiquem como
Seções Secundárias e não contenham nenhum material copiado do Documento, você pode optar
por designar alguma ou todas aquelas seções como invariantes. Para fazer isso, adicione seus
títulos à lista de Seções Invariantes na nota de licença da Versão Modificada. Esses títulos preci-
sam ser diferentes de qualquer outro título de seção.
Você pode adicionar uma seção entitulada "Endossos", desde que ela não contenha qual-
quer coisa além de endossos da sua Versão Modificada por várias pessoas ou entidades - por
exemplo, declarações de revisores ou de que o texto foi aprovado por uma organização como a
definição oficial de um padrão.
Você pode adicionar uma passagem de até cinco palavras como um Texto de Capa da Frente
, e uma passagem de até 25 palavras como um Texto de Quarta Capa, ao final da lista de Textos
de Capa na Versão Modificada. Somente uma passagem de Texto da Capa da Frente e uma de
Texto da Quarta Capa podem ser adicionados por (ou por acordos feitos por) qualquer entidade.
Se o Documento já incluir um texto de capa para a mesma capa, adicionado previamente por
você ou por acordo feito com alguma entidade para a qual você esteja agindo, você não pode
adicionar um outro; mas você pode trocar o antigo, com permissão explícita do editor anterior que
adicionou a passagem antiga.
O(s) autor(es) e editor(es) do Documento não dão permissão por esta Licença para que seus
nomes sejam usados para publicidade ou para assegurar ou implicar endossamento de qualquer
Versão Modificada.
COMBINANDO DOCUMENTOS
Você pode combinar o Documento com outros documentos publicados sob esta Licença, sob
os termos definidos na seção 4 acima para versões modificadas, desde que você inclua na com-
binação todas as Seções Invariantes de todos os documentos originais, sem modificações, e liste
todas elas como Seções Invariantes de seu trabalho combinado em sua nota de licença.
O trabalho combinado precisa conter apenas uma cópia desta Licença, e Seções Invariantes
Idênticas com multiplas ocorrências podem ser substituídas por apenas uma cópia. Se houver
múltiplas Seções Invariantes com o mesmo nome mas com conteúdos distintos, faça o título de
15

cada seção único adicionando ao final do mesmo, em parênteses, o nome do autor ou editor
origianl daquela seção, se for conhecido, ou um número que seja único. Faça o mesmo ajuste
nos títulos de seção na lista de Seções Invariantes nota de licença do trabalho combinado.
Na combinação, você precisa combinar quaisquer seções entituladas "Histórico"dos diver-
sos documentos originais, formando uma seção entitulada "Histórico"; da mesma forma combine
quaisquer seções entituladas "Agradecimentos", ou "Dedicatórias". Você precisa apagar todas as
seções entituladas como "Endosso".
COLETÂNEAS DE DOCUMENTOS
Você pode fazer uma coletânea consitindo do Documento e outros documentos publicados
sob esta Licença, e substituir as cópias individuais desta Licença nos vários documentos com
uma única cópia incluida na coletânea, desde que você siga as regras desta Licença para cópia
exata de cada um dos Documentos em todos os outros aspectos.
Você pode extrair um único documento de tal coletânea, e distribuí-lo individualmente sob
esta Licença, desde que você insira uma cópia desta Licença no documento extraído, e siga esta
Licença em todos os outros aspectos relacionados à cópia exata daquele documento.
AGREGAÇÃO COM TRABALHOS INDEPENDENTES
Uma compilação do Documento ou derivados dele com outros trabalhos ou documentos se-
parados e independentes, em um volume ou mídia de distribuição, não conta como uma Ver-
são Modificada do Documento, desde que nenhum copyright de compilação seja reclamado pela
compilação. Tal compilação é chamada um "agregado", e esta Licença não se aplica aos outros
trabalhos auto-contidos compilados junto com o Documento, só por conta de terem sido assim
compilados, e eles não são trabalhos derivados do Documento.
Se o requerido para o Texto de Capa na seção 3 for aplicável a essas cópias do Documento,
então, se o Documento constituir menos de um quarto de todo o agregado, os Textos de Capa
do Documento podem ser colocados em capas adjacentes ao Documento dentro do agregado.
Senão eles precisarão aparecer nas capas de todo o agregado.
TRADUÇÃO
Tradução é considerada como um tipo de modificação, então você pode distribuir traduções
do Documento sob os termos da seção 4. A substituição de Seções Invariantes por traduções
requer uma permissão especial dos detentores do copyright das mesmas, mas você pode incluir
traduções de algumas ou de todas as Seções Invariantes em adição às versões orignais dessas
Seções Invariantes. Você pode incluir uma tradução desta Licença desde que você também in-
clua a versão original em Inglês desta Licença. No caso de discordância entre a tradução e a
16

versão original em Inglês desta Licença, a versão original em Inglês prevalecerá.
TÉRMINO
Você não pode copiar, modificar, sublicenciar, ou distribuir o Documento exceto como expres-
samente especificado sob esta Licença. Qualquer outra tentativa de copiar, modificar, sublicen-
ciar, ou distribuir o Documento é nula, e resultará automaticamente no término de seus direitos
sob esta Licença. Entretanto, terceiros que tenham recebido cópias, ou direitos de você sob esta
Licença não terão suas licenças terminadas, tanto quanto esses terceiros permaneçam em total
acordo com esta Licença.
REVISÕES FUTURAS DESTA LICENÇA
A Free Software Foundation pode publicar novas versões revisadas da Licença de Documen-
tação Livre GNU de tempos em tempos. Tais novas versões serão similares em espirito à versão
presente, mas podem diferir em detalhes ao abordarem novos porblemas e preocupações. Veja
http://www.gnu.org/copyleft/.
A cada versão da Licença é dado um número de versão distinto. Se o Documento especificar
que uma versão particular desta Licença "ou qualquer versão posterior"se aplica ao mesmo, você
tem a opção de seguir os termos e condições daquela versão específica, ou de qualquer versão
posterior que tenha sido publicada (não como rascunho) pela Free Software Foundation. Se o
Documento não especificar um número de Versão desta Licença, você pode escolher qualquer
versão já publicada (não como rascunho) pela Free Software Foundation.
ADENDO: Como usar esta Licença para seus documentos
Para usar esta Licença num documento que você escreveu, inclua uma cópia desta Licença
no documento e ponha as seguintes notas de copyright e licenças logo após a página de título:
Copyright (c) ANO SEU NOME.
É dada permissão para copiar, distribuir e/ou modificar este documento sob os termos da Licença
de Documentação Livre GNU, Versão 1.1 ou qualquer versão posterior publicada pela Free Soft-
ware Foundation; com as Seções Invariantes sendo LISTE SEUS TÍTULOS, com os Textos da
Capa da Frente sendo LISTE, e com os Textos da Quarta-Capa sendo LISTE. Uma cópia da li-
cença está inclusa na seção entitulada "Licença de Documentação Livre GNU".
Se você não tiver nenhuma Seção Invariante, escreva "sem Seções Invariantes"ao invés de
dizer quais são invariantes. Se você não tiver Textos de Capa da Frente, escreva "sem Textos de
Capa da Frente"ao invés de "com os Textos de Capa da Frente sendo LISTE"; o mesmo para os
Textos da Quarta Capa.
Se o seu documento contiver exemplos não triviais de código de programas, nós recomenda-
mos a publicação desses exemplos em paralelo sob a sua escolha de licença de software livre,
17

tal como a GNU General Public License, para permitir o seu uso em software livre.
18

Capítulo 1
O que é a Linguagem Ruby
A linguagem de programação Ruby, foi criada visando os interesses do programador. Tal
linguagem tem diversas funcionalidades que facilitam na hora da programação. Isso faz com
que o programador não tenha que se preocupar com coisas, que a própria linguagem é capaz
de fazer. Isso pode não parecer tão claro. Mas no decorrer do curso, você verá como é útil a
linguagem Ruby.
20

Capítulo 2
Plano de ensino
2.1 Objetivo
Qualiﬁcar técnicos e programadores na linguagem de programação Ruby
2.2 Público Alvo
Técnicos e Programadores que desejam trabalhar com Linguagem Ruby
2.3 Pré-requisitos
Os usuários deverão ser, necessariamente, indicados por empresas públicas e ter conheci-
mento básico acerca da lógica de programação.
2.4 Descrição
O curso de Linguagem Ruby será realizado na modalidade EAD e utilizará a plataforma Mo-
odle como ferramenta de aprendizagem. Ele é composto de um módulo de aprendizado que
consiste em introdução, instalação e início, um módulo de contatos com a linguagem e um mó-
dulo de conceitos ﬁnais e avaliação que será dado na terceira semana. O material didático estará
disponível on-line de acordo com as datas pré-estabelecidas no calendário. A versão utilizada
para o Ruby será a 1.8
2.5 Metodologia
O curso está dividido da seguinte maneira:
2.6 Cronograma
• Introdução, Instalação e Inicio;
21

• Conhecendo um pouco da linguagem, estruturas de controle e comentários do código e
Noções de POO;
• Classes, entradas e saídas.
As lições contêm o conteúdo principal. Elas poderão ser acessadas quantas vezes forem ne-
cessárias, desde que esteja dentro da semana programada. Ao final de uma lição, você receberá
uma nota de acordo com o seu desempenho. Responda com atenção às perguntas de cada li-
ção, pois elas serão consideradas na sua nota final. Caso sua nota numa determinada lição seja
menor do que 6.0, sugerimos que você faça novamente esta lição.
Ao final do curso será disponibilizada a avaliação referente ao curso. Tanto as notas das lições
quanto a da avaliação serão consideradas para a nota final. Todos os módulos ficarão visíveis
para que possam ser consultados durante a avaliação final.
Aconselhamos a leitura da "Ambientação do Moodle"para que você conheça a plataforma de En-
sino à Distância, evitando dificuldades advindas do "desconhecimento"sobre a mesma.
Os instrutores estarão à sua disposição ao longo de todo curso. Qualquer dúvida deverá ser
enviada ao fórum. Diariamente os monitores darão respostas e esclarecimentos.
2.7 Programa
O curso de Linguagem Ruby oferecerá o seguinte conteúdo:
• Introdução e Instalação;
• Uso das ferramentas mais comuns.
2.8 Avaliação
Toda a avaliação será feita on-line.
Aspectos a serem considerados na avaliação:
• Iniciativa e autonomia no processo de aprendizagem e de produção de conhecimento;
• Capacidade de pesquisa e abordagem criativa na solução dos problemas apresentados.
Instrumentos de avaliação:
• Participação ativa nas atividades programadas;
• Avaliação ao final do curso;
• O participante fará várias avaliações referente ao conteúdo do curso. Para a aprovação e
obtenção do certificado o participante deverá obter nota final maior ou igual a 6.0 de acordo
com a fórmula abaixo:
• Nota Final = ((ML x 7) + (AF x 3)) / 10 = Média aritmética das lições;
• AF = Avaliações.
2.9 Bibliografia
• Site official: http://www.ruby-lang.org
22

Capítulo 3
Introdução
Ruby é uma linguagem de programação com uma tipagem dinâmica, mas forte. Possui grande
semelhança com Perl e Python. Teve como criador o programador Yukihiro Matsumoto, também
conhecido como Matz, na internet. Ao criá-la, Matz estava com a seguinte idéia: Criar uma
linguagem mais orientada a objetos do que Python e mais poderosa que Perl. Foi projetada
tanto para uma codificação rápida quanto para uma programação em grande escala e possui um
suporte de orientação a objetos simples e prático, com uma sintaxe que facilita leitura e simplifica
a escrita do código. Matz acreditava que o programador deveria se divertir ao realizar determinada
tarefa, logo pensou justamente nisso para criar o Ruby. Vem sendo bastante utilizada pelo mundo
e com uma lista de discussão bastante ativa, conhecida como ruby-talk. Vem também sendo
erguida para uma linguagem de primeiro nível através do RubyOnRails. Diferente de Java e C++,
linguagens também orientadas a objetos, o tipo de objeto em Ruby só é conhecido em runtime.
Sua orientação a objetos é pura, ou seja, tudo é objeto, até mesmo os tipos mais básicos de
variáveis.
Um conceito fundamental na programação Ruby, como já foi mencionado é o conceito de
orientação a objeto (comumente conhecida como Programação Orientada a Objeto ou POO). É,
apesar disso, um conceito muito amplo que requer prática para que possa ser plenamente com-
preendido. Nesta lição, introduziremos as noções básicas de POO para melhor aproveitamento e
uso na linguagem Ruby.
3.1 Classes, Objetos e Métodos
Classe é um aglomerado de métodos, funções e procedimentos com os quais acessamos e
usamos os objetos, realizando tarefas específicas, e de variáveis, que definem o comportamento
de um objeto que poderá vir a existir se a classe for solicitada para tal. Um objeto é uma enti-
dade do mundo real que possui uma identidade. Podem ser entidades concretas ou conceituais.
Podemos citar como exemplos de objetos: uma conta corrente, clientes, agências, arquivos no
computador, bicicletas, lojas etc. Em termos de programação, pode-se definir objeto como o
resultado da ação construtora de uma classe.
Todo objeto é "fabricado"em uma classe, sendo por isso denominado instância da classe.
Além disso, possuem outras características: a estrutura de objetos de uma certa classe é descrita
por meio de atributos; objetos de uma mesma classe têm um mesmo comportamento que são
representados pelo conjunto de operações que podem ser executadas sobre eles. O método de
construção de objetos com a mesma "genética"da classe é chamado de método construtor.
23

3.2 Variaveis
Variáveis de classe: há situações em que se deseja que todos os objetos compartilhem a
mesma variável. O procedimento para realizar esse compartilhamento é a definição de variáveis
de classe;
Pacotes (Packages): conjunto organizado de classes e demais arquivos que estão relaciona-
dos através de um propósito comum ou atuam com dependências entre si. São muito úteis e
necessários na medida em que são usados para localizar o código da classe de forma eficiente.
3.3 Outro conceitos importantes
• Encapsulamento: imprescindível ao entendimento de POO e ao aprendizado da liguagem
Ruby, já que é indispensável para contribuir com a diminuição dos malefícios causados pela
interferência externa sobre os dados. É uma técnica que consiste em ocultar no objeto
algumas de suas variáveis (ou campos) e alguns de seus métodos. É importantíssimo na
medida em que deixa o programa robusto, impedindo o acesso a certas partes de seu
funcionamento;
• Herança: outro conceito importante na POO é o conceito de herança, que significa que toda
classe definida como uma subclasse de outra receberá automaticamente todo o conteúdo
da classe-mãe. Tomamos como exemplo uma classe ’Pessoa’, onde possui como propri-
edades: nome, endereço, telefone, cpf e etc. Incluímos a classe ’Pessoa’ em uma classe
’Funcionário’, dessa forma aproveitamos todas as propriedades de ’Pessoa’ e incluímos as
propriedades específicas de ’Funcionário’, como: data de admissão, cargo, salário e etc;
• Polimorfismo: um conceito mais difícil de ser entendido, porém não menos importante é
o conceito de polimorfismo. Essa dificuldade decorre da amplitude desse conceito e de
significados em POO. Suas variadas definições são:
• Overloading: designa um tipo de polimorfismo em que podemos utilizar um nome igual
para designar métodos diferentes que terão lista de parâmetros também diferentes. Isto
tanto em número de parâmetros quanto em tipo. Os objetos de uma classe-mãe podem ser
redefinidos por objetos das suas sub-classes. Variáveis podem assumir tipos diferentes ao
longo da execução;
• Visibilidade: através dos indicadores ’public’ e ’private’ algumas classes e métodos podem
ser visíveis ou não. Os métodos e propriedades públicas serão a interface do objeto com o
usuário;
• Abstração: em termos de desenvolvimento, abstração significa concentrar-se no que um
objeto é e faz antes de se decidir como ele será implementado. Significa representar as
características essenciais de um tipo de dado sem incluir o mecanismo que concretiza a
funcionalidade. A abstração é fundamental para conseguir uma boa modularização, que é
uma técnica que tem a estratégia de ’dividir para conquistar’, ou seja, resolver um grande
problema dividindo-o em vários problemas menores.
Pergunta: Variáveis de classe é o conjunto organizado de classes e demais arquivos que
estão relacionadas através de um propósito comum ou atuam com dependências entre si.
São muito úteis e necessárias na medida em que são usadas para localizar o código da
classe de forma eficiente.
24

Capítulo 4
Instalação e Início da Linguagem
4.1 Instalação
Para que você possa utilizar o Ruby, é necessário que você o tenha instalado na sua má-
quina. Existem algumas opções para se fazer isso. Uma delas é baixando pelo site oﬁcial
http://www.ruby-lang.org e fazer o download para a plataforma especíﬁca. No entanto, o Debian
possui uma ferramenta muito útil na instalação de determinados programas.
Vamos utilzar tal ferramenta para instalar o Ruby:
• 1 - Abra seu terminal;
• 2 - entre como usuário root;
• 3 - digite: apt-get install ruby
Espere a instalação e pronto, você poderá trabalhar com o ruby normalmente. Nesse caso,
teremos que utilizar um editor de texto (posso sugerir o gedit). Podemos ulilizar um programa
muito bom do Ruby para ir testando o código, o irb (interactive Ruby shell) e com ele não é
necessário o editor de texto. Esse programa será muito útil no início do curso. É bom que vocês
o tenham instalado no seu computador. É possível fazer isso da mesma forma que foi instalado o
Ruby:
• 1 - Abra seu terminal;
• 2 - entre como usuário root;
• 3 - digite: apt-get install irb.
Depois de ter feito tais comandos, o irb estará disponível para ser usado.
4.2 Início da Linguagem
Como vimos anteriormente, um programa muito útil para nos familiarizarmos com a lingua-
gem Ruby é o irb (interactive Ruby shell). Vamos conhecer um pouco mais dele. Basta digitar:
irb no terminal. Pronto! É só começar a programar! Após digitar irb aparecerá no terminal:
irb(main):001:0>
Entre parênteses encontra-se o nome do programa que está sendo rodado; em seguida, de-
pois do primeiro dois pontos, temos quantas linhas foram digitadas e em que linha estamos;
25

depois do segundo dois pontos, temos o nível de profundidade que estamos. Um exemplo de
como funciona o irb:
irb(main):001:0> puts "Apenas um teste"
Apenas um teste
=> nil
irb(main):002:0>
Digite isso e veriﬁque
Observação: O "puts"é um método de Kernel. Isso quer dizer que podemos utilizá-lo sem es-
peciﬁcar o método ao qual ele pertence. Esse método, nada mais faz do que imprimir o resultado
da expressão que foi passada para ele quebrando uma linha.
Um outro exemplo para demonstrar o nível de profundidade:
irb(main):001:0> a = 100
=> 100
irb(main):002:0> if a > 50
irb(main):003:1> puts "Numero maior que 50"
irb(main):004:1> else!
irb(main):005:1* puts "Numero menor que 50"
irb(main):006:1> end
Numero maior que 50
=> nil
irb(main):007:0>
Observe o nível de profundidade alterando conforme o condicional é processado. Tais funcio-
nalidades como "puts"e "if/else"serão abordadas com mais detalhes nas próximas lições.
Observação: É importante que você vá executando o código no seu terminal para que seja
melhor visualizado o que está sendo feito, principalemente na próxima lição onde estarão pre-
sente muitos exemplos. Interessante seria também, se você alterasse o código, isto é, depois de
entendido o que foi feito, tentar, você mesmo, fazer outro código com a função aprendida.
26

Capítulo 5
Conhecendo um pouco a linguagem
5.1 Variáveis
Como vocês devem se lembrar, foi dito na introdução que a linguagem Ruby é 100% orientada
a objetos, isto é, tudo em Ruby é objeto, no entanto, variáveis não são objetos e sim referências
a esses.
Em Ruby as variáveis são simples de serem utilizadas pois utilizam o "duck typing", a tipagem
dinâmica da linguagem. Utilizando uma tipagem estática, temos como exemplo:
irb(main):001:0> i = 10
=> 10
irb(main):002:0> i.class
=> Fixnum
irb(main):003:0> j = "alo"
=> "alo"
irb(main):004:0> j.class
=> String
irb(main):005:0>
Depois de declarada a variável i, foi pedido para mostrar o valor do atributo "class"da variável,
retornando Fixnum. Em seguida depois de atribuído o valor "alo"para a variável j, o comando
j.class foi pedido para que fosse mostrado o valor do atributo, retornando String. Isso prova que
tudo em Ruby é objeto.
Foi dito também na introdução que a linguagem Ruby tem uma tipagem forte, um exemplo
disso é:
irb(main):001:0> a = "teste"
=> "teste"
irb(main):002:0> b = 10
=> 10
irb(main):003:0> resultado = a+b
TypeError: can't convert Fixnum into String
from (irb):3:in `+'
from (irb):3
from :0
irb(main):004:0>
27

logo, não é uma boa idéia "misturar"os tipos.
Em Ruby, para declararmos uma variável no escopo privado é bastante simples, basta fazer:
irb(main):001:0> a = 2
=> 2
irb(main):002:0> puts a
2
=> nil
irb(main):003:0>
O sinal de igual é utilizado para atribuir um determinado valor para a variável.
Agora, para declarar um variável pública, deve-se fazer o seguinte:
irb(main):001:0> $i = 2
=> 2
irb(main):002:0>
Colocando o "$"antes da variável, faz com que a variável torne-se pública.
5.2 Tipos Básicos
A linguagem Ruby apresenta uma ferramenta essencial denominada BLOCOS DE CÓDIGO.
Isso, nada mais é do que "pedaços"de códigos que podem ser delimitados por: (chaves), quando
o bloco possui apenas uma linha ou começa com DO e termina com END, quando o bloco de có-
digo tiver mais de uma linha. Por convenção, as chaves são ultilizadas para códigos menores, ou
seja, que possuem apenas uma linha. Já o do...end é usado para códigos maiores. Um exemplo
para os tais blocos são:
Usando chaves
{puts "Apenas um teste"} (Utilizando as chaves para blocos menores)
Usando do..end
do
puts "Apenas um teste"
puts "Entendeu?" (Utilizando do..end para blocos maiores)
end
O trabalho com blocos de códigos funciona da seguinte maneira: um argumento é passado
para o bloco, onde passará por alguma condição. Mais para frente você verá a utilidade dos
blocos do código. Mas será mostrado aqui um exemplo:
irb(main):003:0> nome.sort_by{|a1| a1.length}
Passou-se um bloco como parâmetro para o método sort_by. Dentro do bloco, passamos o
argumento a1 para o bloco que retorna o tamanho de uma string. Tal comando é para ordenar
um array por ordem de tamanho das strings que compõem o array. Nesse momento pode haver
alguma confusão, já que não vimos strings nem muito menos arrays. Mais para frente as dúvidas
serão esclarecidas.
Na parte de números, as variáveis podem assumir valores inteiros (Fixnum/Bignum) ou de
pontos ﬂutuantes (Float). Eis aqui alguns exemplos de inteiro:
28

irb(main):001:0> a = 1
=> 1
irb(main):002:0> b = -30
=> -30
irb(main):003:0> c = 3000000
=> 3000000
Experimente fazer os comandos acima, e logo depois mostrar o tipo de cada variável (Lembra-
se ainda como faz? Caso não se lembre, é: puts a.class). Feito isso, atribua o valor
10_000_000_000 (como não podemos usar vírgulas ) para alguma variável e utilize o comando
para mostrar o tipo de cada variável. O que você percebeu? Que o tipo mudou para Bignum, ou
seja, a última variável, a qual você atribuiu esse imenso valor, não coube no Fixnum e foi alterado
automaticamente para Bignum. Tal artifício é característico da linguagem. Alguns exemplos de
pontos ﬂutuantes:
irb(main):008:0> x = 1.23
=> 1.23
irb(main):009:0> y = -32.43
=> -32.43
irb(main):010:0> x.class
=> Float
irb(main):011:0> y.class
=> Float
irb(main):012:0>
Exitem também em Ruby, as constantes, que são variáveis iniciadas com letras maiúsculas.
Isso pode causar alguma confusão mais para frente, quando tratarmos do assunto relacionado a
classes, já que, veremos que elas também são iniciadas com letras maiúsculas. Mas perceba a
praticidade:
irb(main):001:0> Fi = 1.61803
=> 1.61803
irb(main):002:0> Fi = 23
(irb):2: warning: already initialized constant Fi
=> 23
irb(main):003:0>
Como pode ser comprovado, foi declarada a variável Fi(?), que é o número áureo, no entanto,
quando tentou-se mudar o seu conteúdo, surgiu o alerta falando que a variável não poderia ser
alterada já que se trata de uma constante. Porém, na linguagem Ruby, é possível alterar o valor
de uma constante. Mas altera gerando um warning!
Como em todas as linguagens de programação, não podia faltar em Ruby os Booleanos, isto
é, valores true ou false que algumas variáveis podem assumir.
Podemos aproveitar e falar também do nil, valor nulo que pode ser atribuído a uma determi-
nada variável. Tanto nil quanto o false, são os únicos valores que podem indicar falso. No entanto,
eles podem pertencer a classes diferentes ou ter comportamentos diferentes.
Isso pode ser comprovado com o seguinte código:
irb(main):001:0> v = true
29

=> true
irb(main):002:0> puts v.class
TrueClass
=> nil
irb(main):003:0> f = false
=> false
irb(main):004:0> f.class
=> FalseClass
irb(main):005:0> n = nil
=> nil
irb(main):006:0> n.class
=> NilClass
irb(main):007:0>
Depois dos booleanos, um dos tipos mais comuns também nas linguagens de programação e,
logicamente, presente em Ruby são as Strings, que nada mais são do que um tipo que armazena
"palavras"ou um conjunto de palavras. Um exemplo:
irb(main):001:0> p1 = "Teste"
=> "Teste"
irb(main):002:0> p2 = "Teste2"
=> "Teste2"
irb(main):003:0> p3 = "Uma frase"
=> "Uma frase"
irb(main):004:0> p1.class
=> String
=> String
=> String
irb(main):007:0>
Como em outras linguagens, a manipulação de strings pode ser feita da seguinte forma:
usando [] (colchetes) com um índice no interior. Para visualizar isso, eis um exemplo:
irb(main):001:0> palavra = "animal"
=> "animal"
irb(main):002:0> palavra[0] = "b"
=> "b"
irb(main):003:0> puts palavra
bnimal
=> nil
irb(main):004:0>
Explicando o que foi feito acima: primeiro atribuímos para a variável "palavra"uma string; logo
depois alteramos o valor da primeira posição da string (no caso o índice zero) trocando o caractere
"a"pelo caractere "b"e imprimimos a nova string.
Para criarmos strings grandes, no caso um texto, podemos usar uma ferramenta denominada
heredoc, a qual funciona da seguinte forma:
30

irb(main):001:0> texto = <<INICIO
irb(main):002:0" Começa aqui o teste
irb(main):003:0" para mostrar
irb(main):004:0" como funciona o heredoc
irb(main):005:0" INICIO
=> "Come303247a aqui o testenpara mostrarncomo funciona o heredocn"
irb(main):006:0> puts texto
Começa aqui o teste
para mostrar
como funciona o heredoc
=> nil
irb(main):007:0>
Nesse exemplo, foi usado o "INICIO"depois do «, para delimitar o início e ﬁm da string. Ou
seja, você que determina a palavra que será usada para demarcar o texto ou a "string grande".
Faça um teste você mesmo, utilize qualquer palavra para a delimitação do texto.
Observação: foi utilizada a palavra delimitadora de string em caixa alta unicamente para me-
lhorar a visualização do código, isto é, para não causar confusão na hora de analisar o código
digitado.
Falemos agora sobre como ocorre a concatenação(união) de strings. Utiliza-se os seguintes
operadores: "+="ou «<"(sem as aspas). Como pode ter sido observado, essa sessão baseia-se
em exemplos para que se entenda melhor como funciona determinada função. Então aqui vão
mais dois exemplos:
O primeiro exemplo é para mostrar como funciona o operador «<":
irb(main):001:0> t1 = "Mudando de exemplo"
=> "Mudando de exemplo"
irb(main):002:0> t1 << ", diferente de 'teste'"
=> "Mudando de exemplo, diferente de 'teste'"
irb(main):003:0> puts t1
Mudando de exemplo, diferente de 'teste'
=> nil
irb(main):004:0>
O segundo exemplo é para mostrar como funciona o operador "+=":
irb(main):001:0> t1 = "Outro exemplo"
=> "Outro exemplo"
irb(main):002:0> t1 += ", diferente de 'teste'"
=> "Outro exemplo, diferente de 'teste'"
irb(main):003:0> puts t1
Outro exemplo, diferente de 'teste'
=> nil
irb(main):004:0>
Basicamente é isso que precisamos saber de string. Mais para frente, quando começarmos a
aprofundar o curso falando sobre orientação a objetos, serão mostradas algumas funções novas.
Existem também em Ruby os intervalos denominados Ranges. Eles são declarados da se-
guinte forma:
31

irb(main):001:0> i1 = 0..5
=> 0..5
irb(main):002:0> i2 = 0...5
=> 0...5
irb(main):003:0>
O intervalo i1 vai conter números de zero até cinco. Já, o intervalo i2 irá conter os números
de zero até 4. Isso ocorre devido a adição de mais um ponto, fazendo com que o intervalo seja
fechado em zero e aberto em 5, ou seja, inclui o zero e não inclui o cinco.
Vamos falar agora um pouco sobre os operadores do Ruby. Muitos deles são bastante conhe-
cidos por você.
- começando pelas quatro operações fundamentais da aritmética: +, - , / , * , respectivamente,
adição, subtração, divisão e multiplicação; - temos também os operadores: ** , % , que indi-
cam exponenciação e módulo (vimos esse operador no exemplo para criar 2 arrays sob algumas
condições); - temos os operadores de comparação: > ,< , >= , <= , respectivamente, maior, me-
nor, maior igual, menor igual; - comparador de igualdade: ==; - and e or que são utilizados nas
estruturas de controle (Veremos isso na próxima lição).
Os operadores serão melhor compreendidos no decorrer desta lição, visto que serão dados
exemplos.
Não poderia faltar nessa sessão os arrays, bastante conhecidos em várias linguagens de
programação. Eles podem conter vários tipos de objetos. Exemplo:
irb(main):001:0> v = [’mais’,’exemplos’,100] => ["mais", "exemplos", 100] irb(main):002:0> puts
v mais exemplos 100 => nil irb(main):003:0> puts v[2] 100 => nil irb(main):004:0>
Observe o uso de [] (colchetes) para atribuir os objetos ao array "v"e as vírgulas que separam
cada termo do array. Veja também como faz para mostrar o conteúdo utilizando índices.
Existe um atalho bastante útil quando trabalhamos com arrays com apenas strings, é o %w.
Esse atalho funciona da seguinte forma:
irb(main):001:0> v = %w(caneta lapis apontador regua)
=> ["caneta", "lapis", "apontador", "regua"]
irb(main):002:0>
Caso queira usar uma string "composta"(com mais de uma palavra) como no exemplo abaixo,
basta utilizar o caractere "¨(sem as aspas).
irb(main):001:0> v1 = %w(cachorro gato colhe tigre dente de sabre)
=> ["cachorro", "gato", "colhe", "tigre dente de sabre"]
irb(main):002:0>
Observação: Perceba que houve uma pequena diferença quando utilizamos o atalho %w.
Houve a utilização de parênteses ao invés de colchetes.
Vimos como montar um array a partir do nada. Agora, como faríamos para adicionar elemen-
tos a um array já existente? Basta utilizar o push ou o operador « (olha ele aí de novo, faz sentido
já que uma string é um vetor de caractere).
Mais um exemplo:
irb(main):001:0> v = %w(azul vermelho)
=> ["azul", "vermelho"]
irb(main):002:0> v.push "laranja"
32

=> ["azul", "vermelho", "laranja"]
irb(main):003:0> v.push "amarelo"
=> ["azul", "vermelho", "laranja", "amarelo"]
A partir daqui utilizou-se o operador «<"(sem aspas) aproveitando o mesmo array.
irb(main):004:0> v << "preto"
=> ["azul", "vermelho", "laranja", "amarelo", "preto"]
irb(main):005:0> v << "roxo"
=> ["azul", "vermelho", "laranja", "amarelo", "preto", "roxo"]
irb(main):006:0>
Observação: Lembram-se quando foi dado o exemplo dos blocos de código no início desta
lição? Então, a partir daqui talvez ﬁque mais claro o que foi dito.
Um mecanismo muito interessante em Ruby para a manipulação de arrays é o seguinte: dado
um determinado array, queremos criar um outro a partir de uma determinada condição depois de
tê-lo processado. Veja o exemplo abaixo:
irb(main):001:0> v1 = [10,11,12,13,14,15]
=> [10, 11, 12, 13, 14, 15]
irb(main):002:0> v2 = v1.find_all{|par| par%2 == 0}.map{|par| par*3}
=> [30, 36, 42]
irb(main):003:0>
Foi feito o seguinte: o método ﬁnd_all procura todos os elementos do array que são pares
(O operador % será tratado mais a frente), o método map cria um novo array somente com os
elementos que foram processados com o seu valor triplicado.
A ordenação de array pode ser feita utilizando o método sort. Ou seja:
irb(main):001:0> v = %w(arnaldo zeca bruno michele andrea)
=> ["arnaldo", "zeca", "bruno", "michele", "andrea"]
irb(main):002:0> v.sort
=> ["andrea", "arnaldo", "bruno", "michele", "zeca"]
irb(main):003:0>
Outra forma seria utilizando o sort_by. Ele ordena o array a partir de uma determinada propri-
edade do valor que está sendo avaliado. Veja:
Ordenação por ordem alfabética analisando a primeira letra da string.
irb(main):001:0> nome = ["zeca","amanda","beto","carla"]
=> ["zeca", "amanda", "beto", "carla"]
irb(main):002:0> nome.sort_by{|a1| a1[0]}
=> ["amanda", "beto", "carla", "zeca"]
A ordenação aqui foi por ordem crescente de tamanho da string utilizando o length.
irb(main):003:0> nome.sort_by{|a1| a1.length}
=> ["zeca", "beto", "carla", "amanda"]
irb(main):004:0>
33

Um outro método utilizado em arrays é o any? (Não se espantem, a interrogação faz parte!).
Tal método veriﬁca se o elemento de um array se encaixa na condição gerada por um determinado
bloco retornando true ou false. Exemplo:
irb(main):001:0> numero = [1,2,3,4,5]
=> [1, 2, 3, 4, 5]
irb(main):002:0> numero.any?{|teste| teste > 3}
=> true
irb(main):003:0> numero.any?{|teste| teste > 5}
=> false
irb(main):004:0>
Agora, para testar se todos os elementos do array se encaixam na condição de um determi-
nado bloco, utilizamos o método all?. Eis outro exemplo:
irb(main):001:0> numero = [101,230,300,1000]
=> [101, 230, 300, 1000]
irb(main):002:0> numero.all?{|teste2| teste2 > 100}
=> true
irb(main):003:0> numero.all?{|teste2| teste2 > 1000}
=> false
irb(main):004:0>
Veja agora uma ferramenta muito interessante. Trata-se da criação de dois arrays a partir de
um outro array baseado na condição de um determinado bloco de código. Tal método denomina-
se partition. Exemplo:
irb(main):001:0> vetor1 = [1,2,3,4,5,6,7,8,9,10]
=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
irb(main):002:0> par,impar = vetor1.partition{|ex| ex%2 == 0}
=> [[2, 4, 6, 8, 10], [1, 3, 5, 7, 9]]
irb(main):003:0> par
=> [2, 4, 6, 8, 10]
irb(main):004:0> impar
=> [1, 3, 5, 7, 9]
irb(main):005:0> puts par
2
4
6
8
10
=> nil
irb(main):006:0> puts impar
1
3
5
7
9
=> nil
irb(main):007:0>
34

Perceba o que foi feito no código acima:
• primeiro, foram atribuídos à variável vetor1 os números de 1 a 10, como foi feito em diversos
exemplos acima;
• depois dois novos arrays receberam novos elementos a partir da condição especificada pelo
bloco, que no caso, será escolher os elementos que são pares;
• mas esse método funciona fazendo com que o primeiro array receba os elementos da con-
dição e o segundo array recebe os elementos que não satisfazem à condição;
• depois foi pedido para mostrar os dois arrays com seus respectivos elementos, o que já foi
dito bem no início do curso como faz.
Depois de mostrado como são os arrays na linguagem Ruby, vamos falar um pouco de
Hashes. Aqui não haverá muito o que falar, pois, hashes são arrays com índices que você
mesmo define para seus elementos. Tais índices podem ser: strings, inteiros (Fixnum) ou até
mesmo símbolos (será tratado em seguida). Veja do que se trata os hashes pelos seguintes
exemplos:
Utilizando strings
irb(main):001:0> hashe = {"p"=>"primeiro elemento","s"=>"segundo elemento"}
=> {"p"=>"primeiro elemento", "s"=>"segundo elemento"}
irb(main):002:0> hashe["s"]
=> "segundo elemento"
Utilizando inteiros (Fixnum)
irb(main):003:0> hashe2 = {1=>"teste1",2=>"teste2"}
=> {1=>"teste1", 2=>"teste2"}
irb(main):004:0> hashe2[1]
=> "teste1"
irb(main):005:0>
Utilizando Símbolos
irb(main):005:0> hash3 = {:primeiro=>"elemento1", :segundo=>"elemento2"}
=> {:primeiro=>"elemento1", :segundo=>"elemento2"}
irb(main):006:0> hash3[:segundo]
=> "elemento2"
irb(main):007:0>
Deve ter ficado alguma dúvida quanto aos símbolos mencionados acima. Símbolos nada mais
são que pequenas strings que representam sempre o mesmo objeto. Podem representar nomes
ou Strings dentro do interpretador Ruby. São criados colocando “:“ dois pontos) na frente do
nome, como foi feito para definir os índices dos hashes acima:
• :primeiro;
• :segundo.
35

Veremos uma utilidade maior dos símbolos quando tratarmos de classes.
Como essa lição é baseada em uma forma de conhecer por alto a linguagem Ruby, vamos
falar sobre métodos de forma superﬁcial. Quando chegarmos na lição de classes, veremos então
a utilidade da linguagem Ruby , uma vez que, como já foi dito diversas vezes e não custa nada
falar de novo, ela é 100% orientada a objetos. Portanto Até lá veremos o que acontece de comum
entre as linguagens.
Para declaramos um método basta iniciá-lo com defnome do metodo...end (parecido com a
declaração de um bloco de código). Um exemplo para visualizar o que foi dito:
irb(main):001:0> def testando
irb(main):002:1> puts "veja o que acontece quando chamamos um metodo"
=> nil
irb(main):004:0> testando
veja o que acontece quando chamamos um metodo
=> nil
irb(main):005:0>
Os métodos também retornam valores que podem ser de 2 formas: com o return ou sem o
return, nesse caso, o valor retornado pelo método é a última expressão avaliada. Veja o exemplo:
Com o return:
irb(main):001:0> def divide(x1,x2)
irb(main):002:1> return x1/x2
=> nil
irb(main):004:0> divide(12,3)
=> 4
irb(main):005:0>
Sem o return:
irb(main):001:0> def divide(x1,x2)
irb(main):002:1> x1/x2
=> nil
irb(main):004:0> divide(36,6)
=> 6
irb(main):005:0>
Foi simples o que foi feito aqui: criamos um método chamado "divide"quem tem dois argumen-
tos. Dentro do método foi colocada a expressão. Feito isso, chamamos o método e passamos
dois valores para seus argumentos, fazendo com que retorne o resultado da expressão avaliada.
Os métodos podem retornar também mais de um resultado. Na verdade, é retornado apenas
um objeto, no entanto, dá a impressão que são vários. Exemplo:
irb(main):001:0> def multiplos[[no]]
irb(main):002:1> (1..4).map{|x|x*n}
36

=> nil
irb(main):004:0> multiplos(3)
=> [3, 6, 9, 12]
irb(main):005:0> a,b,c,d = multiplos(3)
=> [3, 6, 9, 12]
irb(main):006:0> puts "Os multiplos de 3 são: #{a},#{b},#{c},#{d}"
Os multiplos de 3 são: 3,6,9,12
=> nil
irb(main):007:0>
Entendendo o código: criamos um método que calcula os quatros primeiros múltiplos de um
certo número. Vemos isso pelo intervalo que foi imposto no método, no caso o 4.
No método map, criamos um array com a condição passada pelo bloco, no caso o x*n. Depois,
chamamos o método e passamos um valor para seu argumento. Logo após esses procedimentos,
pedimos a impressão dos múltiplos do número passado para o método, no caso, o 3. Com isso,
foi mostrado os quatro primeiros múltiplos de 3.
Ainda em métodos, uma das funcionalidades que podem ser utilizadas é o passagem de um
bloco como parâmetro para o método. Para isso, utilizamos o método yield. Veja como isso é
feito:
irb(main):001:0> def multiplica(a1,b1)
irb(main):002:1> yield(a1,b1)
=> nil
irb(main):004:0> multiplica(3,4){|x1,x2|x1*x2}
=> 12
irb(main):005:0>
Há também, uma maneira de testar se o bloco foi passado ao método. Para isso utilizamos o
block_given como mostrado abaixo:
irb(main):001:0> def multiplica(a1,b1)
irb(main):002:1> if block_given?
irb(main):003:2> yield(a1,b1)
irb(main):004:2> else
irb(main):005:2* puts " Bloco nao passado para o metodo!"
=> nil
irb(main):008:0> multiplica(2,7){|x1,x2| x1*x2}
=> 14
irb(main):009:0> multiplica(3,5){|x1,x2| x1*x2}
=> 15
irb(main):010:0> multiplica(3,5)
Bloco nao passado para o metodo!
=> nil
irb(main):011:0>
37

Observação: os parâmetros são enviados como cópia da referência de um objeto, portanto,
se alterarmos o objeto que foi passado como parâmetro, dentro do método, o objeto será alterado
fora do método também.
Existem diferentes tipos de métodos. São eles: métodos destrutivos e métodos predicados.
Os métodos destrutivos são aqueles que têm uma "!"(sem aspas) logo depois do nome. Isso
faz com que o conteúdo do próprio objeto seja alterado na sua posição de memória. Já, os
métodos predicados são aqueles que têm um "?"(sem aspas) logo após o nome. Esses méto-
dos retornam true ou false e são úteis para testar uma condição. Veja exemplos dos métodos
mencionados.
Um exemplo de método destrutivo:
irb(main):001:0> t = "Ola, apenas um teste"
=> "Ola, apenas um teste"
irb(main):002:0> t.object_id
=> -605661358
irb(main):003:0> def caps(t)
irb(main):004:1> t.upcase!
=> nil
irb(main):006:0> caps(t)
=> "OLA, APENAS UM TESTE"
irb(main):007:0> t.object_id
=> -605661358
irb(main):008:0>
Perceba que a posição de memória permanece a mesma.
Método predicado:
irb(main):001:0> teste = %w(hd monitor gabinete mouse)
=> ["hd", "monitor", "gabinete", "mouse"]
irb(main):002:0> teste.include? "hd"
=> true
irb(main):003:0> teste.include? "teclado"
=> false
irb(main):004:0>
O código consiste em dizer se uma certa palavra pertence ao array.
Depois do que foi dito, nada mais aceitável do que ver como funciona tudo em um mesmo
programa. Por exemplo, testaremos o escopo das variáveis dentro de um método:
irb(main):001:0> $t = "a"
=> "a"
irb(main):002:0> t = "b"
=> "b"
irb(main):003:0> def apenas_teste
irb(main):004:1> puts $t
irb(main):005:1> puts t
=> nil
38

irb(main):007:0> apenas_teste
a
NameError: undefined local variable or method `t' for main:Object
from (irb):5:in `apenas_teste'
from (irb):7
from :0
irb(main):008:0>
Perceba que atribuímos à variável pública (lembre-se que a variável é pública quando possui
o "$"(sem aspas) antes do nome) o caractere "a"e à varíavel privada o caractere "b". Criamos
o método e no seu interior, pedimos que fosse impresso na tela as duas variáveis. Logo após
chamamos o método. A primeira variável foi impressa, por ser pública. No entanto a segunda
variável não pode ser impressa. Isso ocorreu porque a segunda variável é privada, ou seja, não
pode ser acessada pelo método criado, ao contrário da variável pública.
Vamos ver agora um pouco de Ranges e blocos interagindo. As Ranges possuem um método
denominado each, que trabalha da seguinte forma: para cada valor da Range, o bloco tal é
executado. Veja o exemplo:
irb(main):001:0> r = 0..4
=> 0..4
irb(main):002:0> r.class
=> Range
irb(main):003:0> r.each{puts "Apenas outro teste"}
Apenas outro teste
Apenas outro teste
Apenas outro teste
Apenas outro teste
Apenas outro teste
=> 0..4
irb(main):004:0>
Perceba que o bloco que contém o "puts"foi executado cinco vezes, ou seja, o intervalo da
Range.
Vamos agora, passar vários argumentos para o bloco usando uma Hash. Exemplo:
irb(main):001:0> hs = {1=>"primeiro",2=>"segundo"}
=> {1=>"primeiro", 2=>"segundo"}
irb(main):002:0> hs.each{|i,j| puts "indice:"+i.to_s+" valor:"+j.to_s}
indice:1 valor:primeiro
indice:2 valor:segundo
=> {1=>"primeiro", 2=>"segundo"}
irb(main):003:0>
O mesmo vale para os arrays. Exemplo:
irb(main):001:0> vetor = %w(primeira posicao segunda posicao)
=> ["primeira posicao", "segunda posicao"]
irb(main):002:0> vetor.each{|i| puts "Veja a: "+i.to_s}
Veja a: primeira posicao
39

Veja a: segunda posicao
=> ["primeira posicao", "segunda posicao"]
irb(main):003:0>
Uma ferramenta interessante é a concatenação de métodos. Por exemplo, vamos concatenar
o sort e o each:
irb(main):001:0> vetor = %w(casa predio escritorio apartamento)
=> ["casa", "predio", "escritorio", "apartamento"]
irb(main):002:0> vetor.sort.each{|j| puts "Depois de ordenado: "+j.to_s}
Depois de ordenado: apartamento
Depois de ordenado: casa
Depois de ordenado: escritorio
Depois de ordenado: predio
=> ["apartamento", "casa", "escritorio", "predio"]
irb(main):003:0>
40

Capítulo 6
Estruturas de Controle e Comentários
no Código
As estruturas de controle, como o próprio nome diz, controlam as estruturas criadas. São
elas: as condicionais e os loops.
6.1 Condicionais
Vamos começar com as condicionais.
6.1.1 If/Else
Se você tem uma noção de programação, você deve estar habituado ao famoso if/else. Fun-
ciona da seguinte forma: if...end ou, if...else...end. Com os exemplos a visualização será melhor.
Ex1:
irb(main):001:0> texto = "palavra"
=> "palavra"
irb(main):002:0> if texto == "palavra"
irb(main):003:1> puts "O valor foi atribuído corretamente"
O valor foi atribuído corretamente
=> nil
irb(main):005:0>
Ex2:
irb(main):001:0> numero = 100
=> 100
irb(main):002:0> if numero > 10
irb(main):003:1> puts "O numero é maior que 10"
irb(main):005:1* puts "o numero é menor que 10"
41

O numero é maior que 10
=> nil
irb(main):007:0>
Existe também o elsif, é muito intuitivo, mas mesmo assim, vamos mostrar um exemplo:
irb(main):001:0> valor = 5
=> 5
irb(main):002:0> if valor > 5
irb(main):003:1> puts "Numero maior que cinco"
irb(main):004:1> elsif valor == 5
irb(main):005:1> puts "Numero igual a cinco"
irb(main):007:1* puts "Numero menos que cinco"
Numero igual a cinco
=> nil
irb(main):009:0>
6.1.2 Case
Uma condicional extremante útil é o case. Você primeiramente atribui um valor para uma
variável; depois o valor servirá como uma condicional para entrar em alguma das ações. Ele é
mais utilizado quando você programa primeiramente com um editor de texto, quando você pede
ao usuário que forneça um valor. A partir daí, você cria blocos com as condições possíveis que
o usuário possa digitar. Vamos mostrar apenas o básico, sem o editor de texo. Mais para frente
mostraremos programas que utilizam um editor de texto e é executado no terminal.
Exemplo de case:
irb(main):001:0> opcao = 3
=> 3
irb(main):002:0> case opcao
irb(main):003:1> when 0..10
irb(main):004:1> puts "A opcao está entre 0 e 10"
irb(main):005:1> when 10..20
irb(main):006:1> puts "A opcao esta entre 10 e 20"
irb(main):008:1* puts "Nao esta em nenhum dos intervalos"
A opcao está no entre 0 e 10
=> nil
irb(main):010:0>
Usamos um range (intervalo, está lembrado?) aqui para demonstrar a utilização do case.
Geralmente é feito sempre: case (variavel)...when...else...end.
42

6.2 Loops
Quando temos diversas atividades a serem digitadas como uma forma de repetição, podemos
utilizar um comando que "faz"essas repetições para você. São os chamados Loops.
6.2.1 While
Vamos começar falando do loop while. Primeiramente temos um determinado valor que con-
trolará o while, isto é, o número de repetições que o while fará. No interior do while, é colocado o
comando e um contador para que o loop termine. Veja o exemplo:
irb(main):001:0> contador = 0
=> 0
irb(main):002:0> while contador < 4
irb(main):003:1> puts contador
irb(main):004:1> contador += 1
0
1
2
3
=> nil
irb(main):006:0>
Observação: Você deve ter estranhado o comando "+=". Tal comando incrementa o valor da
variável. Analogamente, temos um comando decrementador que é: -="(Sem as aspas)
6.2.2 for
Um outro tipo de loop é o for. Veja o exemplo para ver como ele é chamado:
irb(main):001:0> for cont in (0..3)
irb(main):002:1> puts "teste"
teste
teste
teste
teste
=> 0..3
irb(main):004:0>
Veja que temos um contador novamente chamado "cont"e um intervalo a ser percorrido, no
caso uma range, como no comando while, existe para determinar o número de repetições preten-
didas. E no seu interior foi determinado o comando que será repetido, no caso, a impressão da
string "teste".
43

6.2.3 until
Uma variante do while é o until. Veja um exemplo:
irb(main):001:0> cont = 0
=> 0
irb(main):002:0> until cont == 5
irb(main):003:1> puts "executa"
irb(main):004:1> cont += 1
executa
executa
executa
executa
executa
=> nil
irb(main):006:0>
Podemos utilizar o begin junto com o while e until da seguinte forma:
Utilizando o while e until.
irb(main):001:0> cont1 = 0
=> 0
irb(main):002:0> begin
irb(main):003:1* puts cont1
irb(main):004:1> cont1 += 1
irb(main):005:1> end while cont1 < 5
0
1
2
3
4
=> nil
irb(main):007:1* puts cont1
irb(main):008:1> cont1 -= 1
irb(main):009:1> end until cont1 == 0
5
4
3
2
1
=> nil
irb(main):010:0>
Perceba que, como o loop encontra-se no ﬁnal, o último valor não é mostrado, no entanto,
o cont1 é alterado e repassado para a segunda função. Tanto é que no until o primeiro valor
impresso é o 5.
44

6.3 Comentando o Código
Para ﬁnalizar essa lição, vamos falar sobre comentários de código. Tais comentários, são
muito importantes, porque explica o que você está no seu código, facilitando a compreensão do
mesmo. Pode ser feito de duas formas:
• Utilizando "#"(sem aspas) para comentários com apenas uma linha (veja ex1);
• utilizando =begin...=end para comentários com mais linhas (veja ex2). Veja alguns exemplo:
Ex1:
irb(main):001:0> def veja_o_teste
irb(main):002:1> puts "veja como funciona um comentario" irb(main):003:1> end # O
comentario nao e executado
=> nil
irb(main):004:0> veja_o_teste
veja como funciona um comentario
=> nil
irb(main):005:0>
Ex2:
irb(main):001:0> def loops(cont)
irb(main):003:2* puts "Imprima isso"
irb(main):004:2> cont += 1
irb(main):005:2> end while cont < 3
=> nil
irb(main):007:0> loops(0)
Imprima isso
Imprima isso
Imprima isso
=> nil
irb(main):008:0> =begin
irb(main):009:0= veja como funciona
irb(main):010:0= um codigo de varias linhas
irb(main):011:0>= =end
irb(main):012:0>
45

Capítulo 7
Classes
Finalmente chegamos à etapa do curso que realmente interessa no Ruby, que a parte de
Orientação a objetos. Depois da breve noção de OO (Orientação a objetos) abordada na lição
anterior, iremos aprofundar bem esse tópico com essa lição.
Iremos utilizar agora também, o tão esperado editor de texto(sugerido no início do curso, o
gedit) e deixar um pouco de lado o irb. Lembram-se no início do curso, que foi pedido que se
instalasse o Ruby e posteriormente o irb a ﬁm de manipular as funcionalidades do Ruby? Então,
agora com o Ruby instalado, depois de escrito o código no editor de texto, rodaremos aquele no
terminal da seguinte forma: Depois de escrito o código, salve-o como ’nome do arquivo’.rb. Um
exemplo: digamos que você tenha criado um arquivo com nome de Cachorro. Você deverá salvar
como: Cachorro.rb.
Feito isso, você irá abrir o terminal e digitar: ruby Cachorro.rb
Para esta lição, vamos criar a classe Carro.rb no editor de texto:
class Carro
def initialize(marca,modelo,cor)
@marca = marca
@modelo = modelo
@cor = cor
end
end
corsa = Carro::new("GMC","Corsa","Vermelho")
puts corsa
7.1 Variáveis de Instância
Vamos agora analisar o que foi feito aqui. Você deve estar com muitas dúvidas, uma vez que
apareceram diversas coisas novas, tais como: initialize, @ e ::new. Vamos falar agora sobre as
variáveis de instância. e as novidades que apareceram no exemplo para construir uma classe:
• initialize é um método utilizado em Ruby como construtor de classes. O que está entre
parênteses são os parâmetros utilizados pelas variáveis de instância;
• O "@"é utilizado para deﬁnir variáveis de instância, como foi visto, basta colocar @<nome
da variável> ;
46

• new é um método de classe, por isso que foi chamado com "::".
Depois disso, criamos a variável corsa, com as respectivas características e pedimos para
mostrar seu conteúdo utilizando o puts. Aparecendo: #<Carro:0xb7d15954>. Apareceu isso, pois
foi pedido para mostrar um objeto. Para que apareça as características do carro, é preciso utilizar
o "to_s"para converter objetos em strings, como visto em lições anteriores. Para isso, criaremos
o método to_s. Veja um exemplo a seguir:
class Carro
@marca = marca
@modelo = modelo
@cor = cor
end
def to_s
"marca: #{@marca}, modelo: #{@modelo}, cor: #{@cor}"
end
end
corsa = Carro::new("Chevrolet","Corsa","Vermelho")
puts corsa
Mais uma novidade: o "#expressão". Ele funciona imprimindo a expressão que se encontra
no interior das chaves. Voltemos rapidamente ao irb:
irb(main):001:0> expressa = "Veja o exemplo"
=> "Veja o exemplo"
irb(main):002:0> puts "#{expressa}"
Veja o exemplo
=> nil
irb(main):003:0>
Veremos agora uma maneira de acessar as variáveis de instância. Logicamente, não pode-
mos utilizar o puts corsa.marca, pois "marca"é uma variável privada da classe. Ocorrerá um erro
de método, faça isso e veriﬁque. Para contornarmos esse erro, faremos o seguinte:
class Carro
@marca = marca
@modelo = modelo
@cor = cor
end
def to_s
end
47

def modelo #metodo para acessar a variavel de instancia
@modelo
end
def modelo=(novo_modelo) #metodo para alterar a variavel de instancia
@modelo = novo_modelo
end
corsa = Carro::new("Chevrolet","Corsa","Vermelho")
puts corsa
puts corsa.modelo
corsa.modelo = "GMC"
puts corsa.modelo
Explicando o código: criamos o método "modelo", para podermos acessar a variável privada
"modelo". Logo depois criamos o método "modelo=(novo_modelo)", para alterarmos a variável de
instância "modelo". Feito isso, pedimos para mostrar novamente a variável corsa, qual o modelo,
a alteração do modelo e ﬁnalmente pedindo para mostrar a variável alterada.
Mas como Ruby é o melhor amigo do programador, ele permite que você tenha acesso a
essas variáveis da seguinte forma:
class Carro
attr_reader :marca, :modelo, :cor
attr_writer :cor
@marca = marca
@modelo = modelo
@cor = cor
end
def to_s
end
def modelo #metodo para acessar a variavel de instancia
@modelo
end
def modelo=(novo_modelo) #metodo para alterar a variável de instância
@modelo = novo_modelo
end
O reader e writer tem como função acessar as variáveis da classe utilizando símbolos (lem-
bram que foi falado que símbolo seria melhor abordado) como referência.
Vale lembrar que, em Ruby, as classes nunca são fechadas, isto é, pode-se adicionar novos
métodos dinamicamente, como mostrado abaixo na classe Carro:
48

class Carro
def novo_metodo
puts "Novo metodo definido dinamicamente"
end
def
puts "Mais um metodo definido dinamicamente"
end
end
Com isso, os novos métodos poderão ser acessados normalmente pelas instâncias da classe
Carro. Isso pode ser útil para alterarmos as classes sem a necessidade de reescrevê-las.
Podemos também acessar constantes de classes facilmente. Veja como (utilizando uma
classe diferente):
class Const
Constante = 1234
end
puts Const::constante
7.2 Variáveis de Classe
São variáveis que estão no contexto das classes e não das instâncias. Existe somente uma
cópia delas por classe e são declaradas escrevendo @@ antes do nome escolhido e SEMPRE
tem que ser inicializadas antes de serem usadas. Veja um exemplo abordando tudo o que já foi
visto:
class Veiculo
@marca = marca
@modelo = modelo
@cor = cor
end
def to_s
"marca:#{@marca} modelo:#{@modelo} cor:#{@cor}"
end
end
class Fabricante
attr_reader :fabrica, :modelos, :quantidade_fabricada
49

@@numero_total_de_veiculos = 0
def initialize(nome,modelos)
@nome = nome
@modelos = modelos
@quantidade_fabricada = 0
end
def fabrica(modelo,cor)
if !@modelos.include? modelo
puts "Alerta! O Fabricante #{@nome} não fabrica o modelo #{modelo}"
return nil
end
puts "Fabricando um #{modelo} no fabricante #{@nome}"
@@numero_total_de_veiculos += 1
@quantidade_fabricada += 1
Veiculo::new(@nome,modelo,cor,@modelos[modelo])
end
def Fabricante.numero_total_de_veiculos
@@numero_total_de_veiculos
end
end
# Vamos criar agora as fabricantes
volks = Fabricante::new("Volkswagen",{"Parati"=>30,"Jetta"=>40,"Passat"=>10})
ford = Fabricante::new("Ford",{"Ranger"=>30,"EcoSport"=>20,"Focus"=>10})
# Vamos criar agora os veiculos da Volks (com um erro)
veiculos_volks = []
veiculos_volks.push(volks.fabrica("Parati",:vermelho))
veiculos_volks.push(volks.fabrica("Jetta",:verde))
veiculos_volks.push(volks.fabrica("Ranger",:preto))
puts "#{volks.nome} fabricou #{volks.quantidade_fabricada} automóveis até o momento"
veiculos_volks.each {|v| puts v unless v.nil?}
puts
#Vamos agora criar os veiculos da Ford
veiculos_ford = []
veiculos_ford.push(ford.fabrica("Ranger",:preto))
veiculos_ford.push(ford.fabrica("EcoSport",:amarelo))
veiculos_ford.push(ford.fabrica("Focus",:prata))
puts "#{ford.nome} fabricou #{ford.quantidade_fabricada} automóveis até o momento"
50

automoveis_ford.each {|v| puts v unless v.nil?}
puts
puts "Quantidade total de automóveis no mundo é: #{Montadora::
numero_total_de_veiculos}"
Quando criamos classes com alguma ligação entre elas, surge uma hierarquia entre elas. A
primeira classe é a chamada classe pai e as demais as classes ﬁlhas. Para executar os métodos
da classe pai, usamos o super, que funciona enviando todos os parâmetros recebidos no método
para a classe pai.
No entanto, há vezes que, por falta de atenção do programador, o número de argumentos
enviados para a classe pai é diferente do número de argumentos, com isso aparece o seguinte
erro: <ArgumentError> . Para contornar esse erro devemos fazer o seguinte: super(parâmetro1,
parâmetro2,...) para que a chamada seja de acordo com os parâmetros utilizados pela classe pai.
Veja alguns exemplos a seguir:
Ex1:
class Apenas_teste
def initialize (a1,a2)
@i1 = a1
@I2 = A2
end
def imprime
puts "primeiro argumento: #{@i1}, segundo argumento: #{@i2}"
end
end
class Apenas_outro_teste < Apenas_teste
def initialize(a1,a2)
super
end
end
e1 = Apenas_teste::new(a,b)
e2 = Apenas_outro_teste::new(c,d)
e1.imprime
e2.imprime
Isso vai mostrar na tela: primeiro argumento: a, segundo argumento: b primeiro argumento:
c, primeiro argumento: d
Ex2:
class Apenas_teste
@i1 = a1
@I2 = A2
51

end
def imprime
end
end
super
end
end
e2 = Apenas_outro_teste::new(d)
e1.imprime
e2.imprime
Aparecerá o seguinte erro: super.rb:12:in ?initialize?: wrong number of arguments (1 for 2)
(ArgumentError) from super.rb:12:in ?initialize? from super.rb:17:in ?new? from super.rb:17
Isso ocorreu devido ao número de parâmetros que foram passados para a classe pai. Para
contornar a situação devemos fazer:
class Apenas_teste
@i1 = a1
@I2 = A2
end
def imprime
end
end
super(0,a2)
end
end
e2 = Apenas_outro_teste::new(d)
e1.imprime
e2.imprime
52

Isso vai mostrar na tela: primeiro argumento: a, segundo argumento: b primeiro argumento:
0, primeiro argumento: d
Mostraremos aqui agora um pouco sobre herança. Como foi dito na lição anterior, herança
signiﬁca que toda classe deﬁnida como uma subclasse de outra receberá automaticamente todo
o conteúdo da classe pai. Com isso, voltando ao exemplo das montadoras, a classe veículo pode
criar tanto automóveis quanto caminhões. Portanto, basta criar uma classe pai com os atributos
e métodos em comum e depois criar diversas subclasses com as características da classe pai e
mais alguns métodos e atributos. Veja o exemplo a seguir:
class Veiculo
@marca = marca
@modelo = modelo
@cor = cor
end
def to_s
"marca:#{@marca} modelo:#{@modelo} cor:#{@cor}"
end
class Carro < Veiculo
def to_s #o to_s foi usado para retornar se será fabricado um carro ou um caminhão.
"Carro: "+super
end #veja que para criar uma classe a partir de outra, basta fazer classe_nova
< classe_velha
end
class Caminhonete < Veiculo
def to_s
"Caminhonete: "+Veiculo
end
end
end
class Fabricante
attr_reader :fabrica, :modelos, :quantidade_fabricada
@@numero_total_de_veiculos = 0
def initialize(nome,modelos)
@nome = nome
@modelos = modelos
@quantidade_fabricada = 0
end
def fabrica(modelo,cor)
53

if !@modelos.include? modelo
puts "Alerta! O Fabricante #{@nome} não fabrica o modelo #{modelo}"
return nil
end
puts "Fabricando um #{modelo} no fabricante #{@nome} "
@@numero_total_de_veiculos += 1
@quantidade_fabricada += 1
Veiculo::new(@nome,modelo,cor)
end
Carro::new(@nome,modelo,cor)
Caminhonete::new(@nome,modelo,cor)
def Fabricante.numero_total_de_veiculos
@@numero_total_de_veiculos
end
end
# Vamos criar agora as fabricantes
volks = Fabricante::new("Volkswagen",{"Parati"=>30,"Jetta"=>40,"Passat"=>10,
"17210C"=>275})
ford = Fabricante::new("Ford",{"Ranger"=>30,"EcoSport"=>20,"Focus"=>10,
"C-815"=>150})
# Vamos criar agora os veiculos da Volks (com um erro)
veiculos_volks = []
veiculos_volks.push(volks.fabrica("Parati",:vermelho))
veiculos_volks.push(volks.fabrica("Jetta",:verde))
veiculos_volks.push(volks.fabrica("Ranger",:preto))
veiculos_volks.push(volks.fabrica("17210C",:branco))
puts "#{volks.nome} fabricou #{volks.quantidade_fabricada} automóveis até o momento"
veiculos_volks.each {|v| puts v unless v.nil?}
puts
#Vamos agora criar os veiculos da Ford
veiculos_ford = []
veiculos_ford.push(ford.fabrica("Ranger",:preto))
veiculos_ford.push(ford.fabrica("EcoSport",:amarelo))
veiculos_ford.push(ford.fabrica("Focus",:prata))
veiculos_ford.push(ford.fabrica("C-815",:cinza))
puts "#{ford.nome} fabricou #{ford.quantidade_fabricada} automóveis até o momento"
54

automoveis_ford.each {|v| puts v unless v.nil?}
puts
puts "Quantidade total de automóveis no mundo é: #{Montadora::numero_total_de_
veiculos}"
Como foi falado no comentário do código, para criarmos uma classe nova, basta fazermos:
classe_velha < classe nova. De acordo com a herança a nova classe terá os atributos e os
métodos da classe pai.
Nos métodos temos presente também, os controles de acesso. São eles: os método públicos,
privados e protegidos. O tipo de acesso é especiﬁcado por símbolos.
Os métodos públicos podem ser acessados por qualquer método em qualquer objeto.
Ex:
class ApenasTeste
def diz_ola
"ola!"
end
def cumprimenta(diferente)
puts "Eu cumprimento:"+diz_ola
puts "A outra classe cumprimenta:"+diferente.diz_ola
end
public :diz_ola # Especificação por símbolos.
end
class ApenasTesteFilha < ApenasTeste
def metodo_ola
puts "Filha cumprimento:"+diz_ola
end
end
class ClasseDiferente
def cumprimenta(outra_forma)
puts "Classe diferente acessando:"+diferente.diz_ola
end
end
pub1 = ApenasTeste::new
pub2 = ApenasTeste::new
filha= ApenasTesteFilha::new
dif = ClasseDiferente::new
pub1.cumprimenta(pub2)
filha.metodo_ola
dif.cumprimente(pub1)
55

No "pub1.cumprimenta(pub)"A instância de pub1 chama o método diz_ola de pub2. Isso é
possível porque o método de pub2 é público e pode ser chamado por qualquer classe, que esteja
na hierarquia, no caso a classe ApenasTesteFilha.
Os métodos privados só podem ser chamados dentro do seu próprio objeto, no entanto, nunca
é possível que seu método seja acessado por outro objeto, mesmo que esse objeto seja uma sub-
classe da classe do primeiro objeto mencionado.
Ex.:
class Teste1
def diz_ola
"ola!"
end
puts "A outra classe cumprimenta:"+diferente.diz_ola
end
private :diz_ola
end
class Teste1Filha < Teste1
def metodo_oi
puts "Filha cumprimenta:"+diz_ola
end
end
def cumprimente(outra_forma)
puts "Classe diferente acessando:"+outra.diz_ola
end
end
pri1 = Teste1::new
pri2 = Teste1::new
filha= Teste1Filha::new
dif = ClasseDiferente::new
filha.metodo_ola
pri1.cumprimente(pri2) # pri1 nao consegue acessar pri2
dif.cumprimente(pri1) # estranha nao consegue acessar pri1
Se rodarmos esse código aparecerá o seguinte erro: TestePrivado.rb:7:in ?cumprimenta?:
private method ?diz_ola? called for #<Teste1:0xb7e573e0> (NoMethodError) from Teste1.rb:30
Esse erro ocorre porque, primeiramente chamamos o método da ﬁlha que aciona o método
herdado "diz_ola". A classe principal chama seu método "diz_ola", no entanto não consegue
acessar o método da outra classe mesmo que as duas pertençam ao mesmo objeto.
Os métodos protegidos podem ser acessados pelos seus descendentes.
56

Ex.:
class TesteProtect
def diz_ola
"ola!"
end
puts "A outra classe cumprimenta::"+diferente.diz_ola
end
protected :diz_ola
end
class TesteProtectFilha < TesteProtect
def metodo_oi
puts "Filha cumprimenta:"+diz_ola
end
end
puts "Classe diferente acessando:"+diferente.diz_ola
end
end
pro1 = TesteProtect::new
pro2 = TesteProtect::new
filha= TesteProtectFilha::new
dif = Classediferente::new
pro1.cumprimenta(pro2) # pro1 consegue acessar pro2
filha.metodo_oi
dif.cumprimente(pro1) # diferente nao consegue acessar pro1
Tais conceitos de métodos públicos e privados são exclusivos da linguagem Ruby, diferindo
das outras linguagens de programação.
57

Linguagem ruby

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (10)

Semelhante a Linguagem ruby

Semelhante a Linguagem ruby (20)

Mais de Tiago

Mais de Tiago (20)

Último

Último (20)

Linguagem ruby