Linguagem ruby

Linguagem RubyVersão 1.0.0

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 202.1 Objetivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202.2 Público Alvo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202.3 Pré-requisitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202.4 Descrição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202.5 Metodologia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202.6 Cronograma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202.7 Programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212.8 Avaliação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212.9 Bibliografia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

3 Introdução 223.1 Classes, Objetos e Métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223.2 Variaveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233.3 Outro conceitos importantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

4 Instalação e Início da Linguagem 244.1 Instalação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244.2 Início da Linguagem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

5 Conhecendo um pouco a linguagem 265.1 Variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265.2 Tipos Básicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

6 Estruturas de Controle e Comentários no Código 406.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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416.2 Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

6.2.1 While . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426.2.2 for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426.2.3 until . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

6.3 Comentando o Código . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

7 Classes 457.1 Variáveis de Instância . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457.2 Variáveis de Classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

8 Entradas e Saídas 578.1 Fluxos de Entradas e Saídas Simples . . . . . . . . . . . . . . . . . . . . . . . . . . 578.2 Arquivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

2

Parte I

Sobre essa Apostila

3


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çaGNU Free Documentation License, cujo teor integral encontra-se aqui reproduzido na seção demesmo nome, tendo inclusive uma versão traduzida (não oficial).

A revisão e alteração vem sendo realizada pelo CDTC ([email protected]) desde outubrode 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 ([email protected]).

O texto original faz parte do projeto Centro de Difusão de Tecnologia e Conhecimento quevêm sendo realizado pelo ITI (Instituto Nacional de Tecnologia da Informação) em conjunto comoutros parceiros institucionais, e com as universidades federais brasileiras que tem produzido eutilizado Software Livre apoiando inclusive a comunidade Free Software junto a outras entidadesno país.

Informações adicionais podem ser obtidas através do email [email protected], ou dahome 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 responsabilizamdireta 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 ([email protected]) .

Permission is granted to copy, distribute and/or modify this document under the termsof the GNU Free Documentation License, Version 1.1 or any later version published bythe 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 DocumentationLicense.

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 dodesenvolvimento 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 ede código fonte aberto, identificando e mobilizando grupos de formadores de opinião dentre osservidores públicos e agentes políticos da União Federal, estimulando e incentivando o mercadonacional a adotar novos modelos de negócio da tecnologia da informação e de novos negóciosde comunicação com base em software não-proprietário e de código fonte aberto, oferecendotreinamento 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 comoincentivadores 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 deprodutos 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ê comeceseu 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 oroteiro acima.

Licença

Copyright ©2006, Instituto Nacional de Tecnologia da Informação ([email protected]).

6


É dada permissão para copiar, distribuir e/ou modificar este documento sob os termosda Licença de Documentação Livre GNU, Versão 1.1 ou qualquer versão posteriorpúblicada pela Free Software Foundation; com o Capitulo Invariante SOBRE ESSAAPOSTILA. 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 seuscolegas 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ãoe a sua recuperação de materiais;

• 6. Vontade para realizar as atividades no tempo correto: anotar todas as suas obrigações erealizá-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, aprendizagense 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ãocontrola a sua dedicação, mas reflete 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çõesque 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 queinteresse ao grupo, favor postá-la aqui.Porém, se o que você deseja é resolver alguma dúvida ou discutir algum tópico específico docurso. É recomendado que você faça uso do Fórum de dúvidas gerais que lhe dá recursos maisefetivos para esta prática.

. O fórum de dúvidas gerais tem por objetivo disponibilizar um meio fácil, rápido e interativopara solucionar suas dúvidas e trocar experiências. As mensagens postadas nele são enviadasa todos participantes do curso. Assim, fica muito mais fácil obter respostas, já que todos podemajudar.Se você receber uma mensagem com algum tópico que saiba responder, não se preocupe com aformalizaçã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 podemser 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, porpessoas 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 dasferramentas 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 respectivosvalores e atitudes, incentiva mas é honesto, imparcial, amável, positivo, respeitador, aceita asidé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 tutorou 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 umreparo de um estudante: ’os comentários deixam-nos com uma sensação de crítica, deameaç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çãode 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 thedistribution terms for software that uses the GFDL–only the original English text of the GFDL doesthat. However, we hope that this translation will help Portuguese speakers understand the GFDLbetter.

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, masnão é permitido alterá-lo.

INTRODUÇÃO

O propósito desta Licença é deixar um manual, livro-texto ou outro documento escrito "livre"nosentido 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émpara o autor e editor uma forma de ter crédito por seu trabalho, sem ser considerado responsávelpelas modificações feitas por terceiros.

Esta Licença é um tipo de "copyleft"("direitos revertidos"), o que significa que derivações dodocumento 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 softwarelivre precisa de documentação livre: um programa livre deve ser acompanhado de manuais queprovenham as mesmas liberdades que o software possui. Mas esta Licença não está restrita amanuais de software; ela pode ser usada para qualquer trabalho em texto, independentementedo 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 pelodetentor 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 documentoou uma parte dele, quer copiada exatamente, quer com modificações e/ou traduzida em outralí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 doDocumento (ou assuntos relacionados) e não contém nada que poderia ser incluído diretamentenesse assunto geral (Por exemplo, se o Documento é em parte um livro texto de matemática, aSeçã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, comosendo 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 CapaFrontal 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, cujosconteúdos possam ser vistos e editados diretamente e sem mecanismos especiais com editoresde 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 deservir como entrada a formatadores de texto ou para tradução automática para uma variedadede formatos que sirvam de entrada para formatadores de texto. Uma cópia feita em um formatode 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 XMLusando uma DTD disponibilizada publicamente, e HTML simples, compatível com os padrões, eprojetado para ser modificado por pessoas. Formatos opacos incluem PostScript, PDF, formatosproprietá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 estejamdisponíveis para o público, e HTML gerado automaticamente por alguns editores de texto comfinalidade 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ãotenham 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ãocomercial, desde que esta Licença, as notas de copyright, e a nota de licença dizendo que estaLicenç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 decó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émpode 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 doDocumento obrigar Textos de Capa, você precisará incluir as cópias em capas que tragam, clarae legivelmente, todos esses Textos de Capa: Textos de Capa da Frente na capa da frente, eTextos da Quarta Capa na capa de trás. Ambas as capas também precisam identificar clara elegivelmente 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 adicionaroutros materiais às capas. Fazer cópias com modificações limitadas às capas, tanto quanto estaspreservem o título do documento e satisfaçam a essas condições, pode ser tratado como cópiaexata em outros aspectos.

Se os textos requeridos em qualquer das capas for muito volumoso para caber de formalegível, você deve colocar os primeiros (tantos quantos couberem de forma razoável) na capaverdadeira, 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ópiaOpaca, ou informar, em ou com, cada cópia Opaca a localização de uma cópia Transparentecompleta do Documento acessível publicamente em uma rede de computadores, à qual o públicousuário de redes tenha acesso a download gratuito e anônimo utilizando padrões públicos deprotocolos 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 assegurarque esta cópia Transparente vai permanecer acessível desta forma na localização especificadapor 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 deredistribuir 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çãoe modificação da Versão Modificada para quem quer que possua uma cópia da mesma. Alémdisso, 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 listadosna seção "Histórico do Documento"). Você pode usar o mesmo título de uma versão anterior seo 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 cincodos autores principais do Documento (todos os seus autores principais, se ele tiver menos quecinco);

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 àsoutras notas de copyright;

F. Incluir, imediatamente depois das notas de copyright, uma nota de licença dando ao públicoo direito de usar a Versão Modificada sob os termos desta Licença, na forma mostrada no tópicoabaixo;

G. Preservar nessa nota de licença as listas completas das Seções Invariantes e os Textos deCapa 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 dizendopelo menos o título, ano, novos autores e editor da Versão Modificada como dados na Página deTítulo. Se não houver uma sessão denominada "Histórico"no Documento, criar uma dizendo otítulo, ano, autores, e editor do Documento como dados em sua Página de Título, então adicionarum 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 umacó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 publicadopelo menos quatro anos antes do Documento, ou se o editor original da versão a que ela se refirader 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 emseus 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ãoModificada;

N. Não reentitular qualquer seção existente com o título "Endossos"ou com qualquer outrotítulo dado a uma Seção Invariante.

Se a Versão Modificada incluir novas seções iniciais ou apêndices que se qualifiquem comoSeções Secundárias e não contenham nenhum material copiado do Documento, você pode optarpor designar alguma ou todas aquelas seções como invariantes. Para fazer isso, adicione seustí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 - porexemplo, declarações de revisores ou de que o texto foi aprovado por uma organização como adefiniçã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 Textosde Capa na Versão Modificada. Somente uma passagem de Texto da Capa da Frente e uma deTexto 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 porvocê ou por acordo feito com alguma entidade para a qual você esteja agindo, você não podeadicionar um outro; mas você pode trocar o antigo, com permissão explícita do editor anterior queadicionou a passagem antiga.

O(s) autor(es) e editor(es) do Documento não dão permissão por esta Licença para que seusnomes sejam usados para publicidade ou para assegurar ou implicar endossamento de qualquerVersão Modificada.

COMBINANDO DOCUMENTOS

Você pode combinar o Documento com outros documentos publicados sob esta Licença, sobos 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 listetodas 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 InvariantesIdênticas com multiplas ocorrências podem ser substituídas por apenas uma cópia. Se houvermú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 editororigianl daquela seção, se for conhecido, ou um número que seja único. Faça o mesmo ajustenos 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 combinequaisquer seções entituladas "Agradecimentos", ou "Dedicatórias". Você precisa apagar todas asseções entituladas como "Endosso".

COLETÂNEAS DE DOCUMENTOS

Você pode fazer uma coletânea consitindo do Documento e outros documentos publicadossob esta Licença, e substituir as cópias individuais desta Licença nos vários documentos comuma única cópia incluida na coletânea, desde que você siga as regras desta Licença para cópiaexata de cada um dos Documentos em todos os outros aspectos.

Você pode extrair um único documento de tal coletânea, e distribuí-lo individualmente sobesta Licença, desde que você insira uma cópia desta Licença no documento extraído, e siga estaLicenç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 pelacompilação. Tal compilação é chamada um "agregado", e esta Licença não se aplica aos outrostrabalhos auto-contidos compilados junto com o Documento, só por conta de terem sido assimcompilados, 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 Capado 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çõesdo Documento sob os termos da seção 4. A substituição de Seções Invariantes por traduçõesrequer uma permissão especial dos detentores do copyright das mesmas, mas você pode incluirtraduções de algumas ou de todas as Seções Invariantes em adição às versões orignais dessasSeçõ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 direitossob esta Licença. Entretanto, terceiros que tenham recebido cópias, ou direitos de você sob estaLicença não terão suas licenças terminadas, tanto quanto esses terceiros permaneçam em totalacordo 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ãopresente, mas podem diferir em detalhes ao abordarem novos porblemas e preocupações. Vejahttp://www.gnu.org/copyleft/.

A cada versão da Licença é dado um número de versão distinto. Se o Documento especificarque 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ãoposterior que tenha sido publicada (não como rascunho) pela Free Software Foundation. Se oDocumento não especificar um número de Versão desta Licença, você pode escolher qualquerversã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çano 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çade 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 daCapa 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 dedizer quais são invariantes. Se você não tiver Textos de Capa da Frente, escreva "sem Textos deCapa da Frente"ao invés de "com os Textos de Capa da Frente sendo LISTE"; o mesmo para osTextos 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

Parte IV

Linguagem Ruby

19

Capítulo 1

O que é a Linguagem Ruby

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

20

Capítulo 2

Plano de ensino

2.1 Objetivo

Qualificar 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 queconsiste em introdução, instalação e início, um módulo de contatos com a linguagem e um mó-dulo de conceitos finais 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 utilizadapara 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 eNoçõ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 sejamenor 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çõesquanto a da avaliação serão consideradas para a nota final. Todos os módulos ficarão visíveispara 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á serenviada 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 eobtenção do certificado o participante deverá obter nota final maior ou igual a 6.0 de acordocom 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 grandesemelhança com Perl e Python. Teve como criador o programador Yukihiro Matsumoto, tambémconhecido como Matz, na internet. Ao criá-la, Matz estava com a seguinte idéia: Criar umalinguagem mais orientada a objetos do que Python e mais poderosa que Perl. Foi projetadatanto para uma codificação rápida quanto para uma programação em grande escala e possui umsuporte de orientação a objetos simples e prático, com uma sintaxe que facilita leitura e simplificaa escrita do código. Matz acreditava que o programador deveria se divertir ao realizar determinadatarefa, logo pensou justamente nisso para criar o Ruby. Vem sendo bastante utilizada pelo mundoe com uma lista de discussão bastante ativa, conhecida como ruby-talk. Vem também sendoerguida 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 devariáveis.

Um conceito fundamental na programação Ruby, como já foi mencionado é o conceito deorientaçã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 euso na linguagem Ruby.

3.1 Classes, Objetos e Métodos

Classe é um aglomerado de métodos, funções e procedimentos com os quais acessamos eusamos os objetos, realizando tarefas específicas, e de variáveis, que definem o comportamentode 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 nocomputador, bicicletas, lojas etc. Em termos de programação, pode-se definir objeto como oresultado 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 é descritapor meio de atributos; objetos de uma mesma classe têm um mesmo comportamento que sãorepresentados pelo conjunto de operações que podem ser executadas sobre eles. O método deconstruçã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 amesma variável. O procedimento para realizar esse compartilhamento é a definição de variáveisde 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 enecessá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 liguagemRuby, já que é indispensável para contribuir com a diminuição dos malefícios causados pelainterferência externa sobre os dados. É uma técnica que consiste em ocultar no objetoalgumas de suas variáveis (ou campos) e alguns de seus métodos. É importantíssimo namedida em que deixa o programa robusto, impedindo o acesso a certas partes de seufuncionamento;

• Herança: outro conceito importante na POO é o conceito de herança, que significa que todaclasse definida como uma subclasse de outra receberá automaticamente todo o conteúdoda 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 aspropriedades 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 designificados em POO. Suas variadas definições são:

• Overloading: designa um tipo de polimorfismo em que podemos utilizar um nome igualpara designar métodos diferentes que terão lista de parâmetros também diferentes. Istotanto em número de parâmetros quanto em tipo. Os objetos de uma classe-mãe podem serredefinidos por objetos das suas sub-classes. Variáveis podem assumir tipos diferentes aolongo da execução;

• Visibilidade: através dos indicadores ’public’ e ’private’ algumas classes e métodos podemser visíveis ou não. Os métodos e propriedades públicas serão a interface do objeto com ousuário;

• Abstração: em termos de desenvolvimento, abstração significa concentrar-se no que umobjeto é e faz antes de se decidir como ele será implementado. Significa representar ascaracterísticas essenciais de um tipo de dado sem incluir o mecanismo que concretiza afuncionalidade. 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 grandeproblema dividindo-o em vários problemas menores.

Pergunta: Variáveis de classe é o conjunto organizado de classes e demais arquivos queestã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 daclasse 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 oficialhttp://www.ruby-lang.org e fazer o download para a plataforma específica. No entanto, o Debianpossui 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 programamuito 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êso tenham instalado no seu computador. É possível fazer isso da mesma forma que foi instalado oRuby:

• 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 decomo funciona o irb:

irb(main):001:0> puts "Apenas um teste"Apenas um teste=> nilirb(main):002:0>

Digite isso e verifique

Observação: O "puts"é um método de Kernel. Isso quer dizer que podemos utilizá-lo sem es-pecificar o método ao qual ele pertence. Esse método, nada mais faz do que imprimir o resultadoda 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=> 100irb(main):002:0> if a > 50irb(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> endNumero maior que 50=> nilirb(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 sejamelhor 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 deentendido 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% orientadaa objetos, isto é, tudo em Ruby é objeto, no entanto, variáveis não são objetos e sim referênciasa esses.

Em Ruby as variáveis são simples de serem utilizadas pois utilizam o "duck typing", a tipagemdinâmica da linguagem. Utilizando uma tipagem estática, temos como exemplo:

irb(main):001:0> i = 10=> 10irb(main):002:0> i.class=> Fixnumirb(main):003:0> j = "alo"=> "alo"irb(main):004:0> j.class=> Stringirb(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 comandoj.class foi pedido para que fosse mostrado o valor do atributo, retornando String. Isso prova quetudo em Ruby é objeto.

Foi dito também na introdução que a linguagem Ruby tem uma tipagem forte, um exemplodisso é:

irb(main):001:0> a = "teste"=> "teste"irb(main):002:0> b = 10=> 10irb(main):003:0> resultado = a+bTypeError: can't convert Fixnum into Stringfrom (irb):3:in `+'from (irb):3from :0irb(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=> 2irb(main):002:0> puts a2=> nilirb(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=> 2irb(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), quandoo 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, ouseja, que possuem apenas uma linha. Já o do...end é usado para códigos maiores. Um exemplopara os tais blocos são:

Usando chaves

{puts "Apenas um teste"} (Utilizando as chaves para blocos menores)

Usando do..end

doputs "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 é passadopara o bloco, onde passará por alguma condição. Mais para frente você verá a utilidade dosblocos 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 oargumento a1 para o bloco que retorna o tamanho de uma string. Tal comando é para ordenarum array por ordem de tamanho das strings que compõem o array. Nesse momento pode haveralguma confusão, já que não vimos strings nem muito menos arrays. Mais para frente as dúvidasserão esclarecidas.

Na parte de números, as variáveis podem assumir valores inteiros (Fixnum/Bignum) ou depontos flutuantes (Float). Eis aqui alguns exemplos de inteiro:

28


irb(main):001:0> a = 1=> 1irb(main):002:0> b = -30=> -30irb(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 valor10_000_000_000 (como não podemos usar vírgulas ) para alguma variável e utilize o comandopara mostrar o tipo de cada variável. O que você percebeu? Que o tipo mudou para Bignum, ouseja, a última variável, a qual você atribuiu esse imenso valor, não coube no Fixnum e foi alteradoautomaticamente para Bignum. Tal artifício é característico da linguagem. Alguns exemplos depontos flutuantes:

irb(main):008:0> x = 1.23=> 1.23irb(main):009:0> y = -32.43=> -32.43irb(main):010:0> x.class=> Floatirb(main):011:0> y.class=> Floatirb(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 aclasses, já que, veremos que elas também são iniciadas com letras maiúsculas. Mas perceba apraticidade:

irb(main):001:0> Fi = 1.61803=> 1.61803irb(main):002:0> Fi = 23(irb):2: warning: already initialized constant Fi=> 23irb(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 seralterada já que se trata de uma constante. Porém, na linguagem Ruby, é possível alterar o valorde 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


=> trueirb(main):002:0> puts v.classTrueClass=> nilirb(main):003:0> f = false=> falseirb(main):004:0> f.class=> FalseClassirb(main):005:0> n = nil=> nilirb(main):006:0> n.class=> NilClassirb(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=> Stringirb(main):005:0> p2.class=> Stringirb(main):006:0> p3.class=> Stringirb(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 palavrabnimal=> nilirb(main):004:0>

Explicando o que foi feito acima: primeiro atribuímos para a variável "palavra"uma string; logodepois 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 denominadaheredoc, a qual funciona da seguinte forma:

30


irb(main):001:0> texto = <<INICIOirb(main):002:0" Começa aqui o testeirb(main):003:0" para mostrarirb(main):004:0" como funciona o heredocirb(main):005:0" INICIO=> "Come\303\247a aqui o teste\npara mostrar\ncomo funciona o heredoc\n"irb(main):006:0> puts textoComeça aqui o testepara mostrarcomo funciona o heredoc=> nilirb(main):007:0>

Nesse exemplo, foi usado o "INICIO"depois do «, para delimitar o início e fim da string. Ouseja, 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ódigodigitado.

Falemos agora sobre como ocorre a concatenação(união) de strings. Utiliza-se os seguintesoperadores: "+="ou «<"(sem as aspas). Como pode ter sido observado, essa sessão baseia-seem exemplos para que se entenda melhor como funciona determinada função. Então aqui vãomais 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 t1Mudando de exemplo, diferente de 'teste'=> nilirb(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 t1Outro exemplo, diferente de 'teste'=> nilirb(main):004:0>

Basicamente é isso que precisamos saber de string. Mais para frente, quando começarmos aaprofundar 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..5irb(main):002:0> i2 = 0...5=> 0...5irb(main):003:0>

O intervalo i1 vai conter números de zero até cinco. Já, o intervalo i2 irá conter os númerosde zero até 4. Isso ocorre devido a adição de mais um ponto, fazendo com que o intervalo sejafechado 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 algumascondiçõ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 nasestruturas de controle (Veremos isso na próxima lição).

Os operadores serão melhor compreendidos no decorrer desta lição, visto que serão dadosexemplos.

Não poderia faltar nessa sessão os arrays, bastante conhecidos em várias linguagens deprogramaçã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> putsv 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 separamcada 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 sentidojá 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 destalição? Então, a partir daqui talvez fique mais claro o que foi dito.

Um mecanismo muito interessante em Ruby para a manipulação de arrays é o seguinte: dadoum determinado array, queremos criar um outro a partir de uma determinada condição depois detê-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 find_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 oselementos 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 verifica se o elemento de um array se encaixa na condição gerada por um determinadobloco 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}=> trueirb(main):003:0> numero.any?{|teste| teste > 5}=> falseirb(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}=> trueirb(main):003:0> numero.all?{|teste2| teste2 > 1000}=> falseirb(main):004:0>

Veja agora uma ferramenta muito interessante. Trata-se da criação de dois arrays a partir deum 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 par246810=> nilirb(main):006:0> puts impar13579=> nilirb(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 diversosexemplos acima;

• depois dois novos arrays receberam novos elementos a partir da condição especificada pelobloco, 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á foidito bem no início do curso como faz.

Depois de mostrado como são os arrays na linguagem Ruby, vamos falar um pouco deHashes. 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 seguintesexemplos:

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 maissão que pequenas strings que representam sempre o mesmo objeto. Podem representar nomesou Strings dentro do interpretador Ruby. São criados colocando “:“ dois pontos) na frente donome, 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 superficial. Quando chegarmos na lição de classes, veremos entãoa utilidade da linguagem Ruby , uma vez que, como já foi dito diversas vezes e não custa nadafalar de novo, ela é 100% orientada a objetos. Portanto Até lá veremos o que acontece de comumentre as linguagens.

Para declaramos um método basta iniciá-lo com defnome do metodo...end (parecido com adeclaração de um bloco de código). Um exemplo para visualizar o que foi dito:

irb(main):001:0> def testandoirb(main):002:1> puts "veja o que acontece quando chamamos um metodo"irb(main):003:1> end=> nilirb(main):004:0> testandoveja o que acontece quando chamamos um metodo=> nilirb(main):005:0>

Os métodos também retornam valores que podem ser de 2 formas: com o return ou sem oreturn, 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/x2irb(main):003:1> end=> nilirb(main):004:0> divide(12,3)=> 4irb(main):005:0>

Sem o return:

irb(main):001:0> def divide(x1,x2)irb(main):002:1> x1/x2irb(main):003:1> end=> nilirb(main):004:0> divide(36,6)=> 6irb(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 passamosdois 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 apenasum 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}irb(main):003:1> end

36


=> nilirb(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=> nilirb(main):007:0>

Entendendo o código: criamos um método que calcula os quatros primeiros múltiplos de umcerto 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 umbloco 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)irb(main):003:1> end=> nilirb(main):004:0> multiplica(3,4){|x1,x2|x1*x2}=> 12irb(main):005:0>

Há também, uma maneira de testar se o bloco foi passado ao método. Para isso utilizamos oblock_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> elseirb(main):005:2* puts " Bloco nao passado para o metodo!"irb(main):006:2> endirb(main):007:1> end=> nilirb(main):008:0> multiplica(2,7){|x1,x2| x1*x2}=> 14irb(main):009:0> multiplica(3,5){|x1,x2| x1*x2}=> 15irb(main):010:0> multiplica(3,5)Bloco nao passado para o metodo!=> nilirb(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á alteradofora 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á, osmé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étodosmencionados.

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=> -605661358irb(main):003:0> def caps(t)irb(main):004:1> t.upcase!irb(main):005:1> end=> nilirb(main):006:0> caps(t)=> "OLA, APENAS UM TESTE"irb(main):007:0> t.object_id=> -605661358irb(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"=> trueirb(main):003:0> teste.include? "teclado"=> falseirb(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_testeirb(main):004:1> puts \$tirb(main):005:1> puts tirb(main):006:1> end=> nil

38


irb(main):007:0> apenas_testeaNameError: undefined local variable or method `t' for main:Objectfrom (irb):5:in `apenas_teste'from (irb):7from :0irb(main):008:0>

Perceba que atribuímos à variável pública (lembre-se que a variável é pública quando possuio "$"(sem aspas) antes do nome) o caractere "a"e à varíavel privada o caractere "b". Criamoso método e no seu interior, pedimos que fosse impresso na tela as duas variáveis. Logo apóschamamos o método. A primeira variável foi impressa, por ser pública. No entanto a segundavariável não pode ser impressa. Isso ocorreu porque a segunda variável é privada, ou seja, nãopode 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étododenominado 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..4irb(main):002:0> r.class=> Rangeirb(main):003:0> r.each{puts "Apenas outro teste"}Apenas outro testeApenas outro testeApenas outro testeApenas outro testeApenas outro teste=> 0..4irb(main):004:0>

Perceba que o bloco que contém o "puts"foi executado cinco vezes, ou seja, o intervalo daRange.

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:primeiroindice: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 concatenaro 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: apartamentoDepois de ordenado: casaDepois de ordenado: escritorioDepois de ordenado: predio=> ["apartamento", "casa", "escritorio", "predio"]irb(main):003:0>

40

Capítulo 6

Estruturas de Controle e Comentáriosno Código

As estruturas de controle, como o próprio nome diz, controlam as estruturas criadas. Sãoelas: 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"irb(main):004:1> endO valor foi atribuído corretamente=> nilirb(main):005:0>

Ex2:

irb(main):001:0> numero = 100=> 100irb(main):002:0> if numero > 10irb(main):003:1> puts "O numero é maior que 10"irb(main):004:1> elseirb(main):005:1* puts "o numero é menor que 10"irb(main):006:1> end

41


O numero é maior que 10=> nilirb(main):007:0>

Existe também o elsif, é muito intuitivo, mas mesmo assim, vamos mostrar um exemplo:

irb(main):001:0> valor = 5=> 5irb(main):002:0> if valor > 5irb(main):003:1> puts "Numero maior que cinco"irb(main):004:1> elsif valor == 5irb(main):005:1> puts "Numero igual a cinco"irb(main):006:1> elseirb(main):007:1* puts "Numero menos que cinco"irb(main):008:1> endNumero igual a cinco=> nilirb(main):009:0>

6.1.2 Case

Uma condicional extremante útil é o case. Você primeiramente atribui um valor para umavariá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ê pedeao usuário que forneça um valor. A partir daí, você cria blocos com as condições possíveis queo usuário possa digitar. Vamos mostrar apenas o básico, sem o editor de texo. Mais para frentemostraremos programas que utilizam um editor de texto e é executado no terminal.

Exemplo de case:

irb(main):001:0> opcao = 3=> 3irb(main):002:0> case opcaoirb(main):003:1> when 0..10irb(main):004:1> puts "A opcao está entre 0 e 10"irb(main):005:1> when 10..20irb(main):006:1> puts "A opcao esta entre 10 e 20"irb(main):007:1> elseirb(main):008:1* puts "Nao esta em nenhum dos intervalos"irb(main):009:1> endA opcao está no entre 0 e 10=> nilirb(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, podemosutilizar 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 ocomando e um contador para que o loop termine. Veja o exemplo:

irb(main):001:0> contador = 0=> 0irb(main):002:0> while contador < 4irb(main):003:1> puts contadorirb(main):004:1> contador += 1irb(main):005:1> end0123=> nilirb(main):006:0>

Observação: Você deve ter estranhado o comando "+=". Tal comando incrementa o valor davariá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"irb(main):003:1> endtestetestetesteteste=> 0..3irb(main):004:0>

Veja que temos um contador novamente chamado "cont"e um intervalo a ser percorrido, nocaso 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 dastring "teste".

43


6.2.3 until

Uma variante do while é o until. Veja um exemplo:

irb(main):001:0> cont = 0=> 0irb(main):002:0> until cont == 5irb(main):003:1> puts "executa"irb(main):004:1> cont += 1irb(main):005:1> endexecutaexecutaexecutaexecutaexecuta=> nilirb(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=> 0irb(main):002:0> beginirb(main):003:1* puts cont1irb(main):004:1> cont1 += 1irb(main):005:1> end while cont1 < 501234=> nilirb(main):006:0> beginirb(main):007:1* puts cont1irb(main):008:1> cont1 -= 1irb(main):009:1> end until cont1 == 054321=> nilirb(main):010:0>

Perceba que, como o loop encontra-se no final, o último valor não é mostrado, no entanto,o cont1 é alterado e repassado para a segunda função. Tanto é que no until o primeiro valorimpresso é o 5.

44


6.3 Comentando o Código

Para finalizar essa lição, vamos falar sobre comentários de código. Tais comentários, sãomuito importantes, porque explica o que você está no seu código, facilitando a compreensão domesmo. 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_testeirb(main):002:1> puts "veja como funciona um comentario" irb(main):003:1> end # Ocomentario nao e executado=> nilirb(main):004:0> veja_o_testeveja como funciona um comentario=> nilirb(main):005:0>

Ex2:

irb(main):001:0> def loops(cont)irb(main):002:1> beginirb(main):003:2* puts "Imprima isso"irb(main):004:2> cont += 1irb(main):005:2> end while cont < 3irb(main):006:1> end=> nilirb(main):007:0> loops(0)Imprima issoImprima issoImprima isso=> nilirb(main):008:0> =beginirb(main):009:0= veja como funcionairb(main):010:0= um codigo de varias linhasirb(main):011:0>= =endirb(main):012:0>

45

Capítulo 7

Classes

Finalmente chegamos à etapa do curso que realmente interessa no Ruby, que a parte deOrientação a objetos. Depois da breve noção de OO (Orientação a objetos) abordada na liçãoanterior, 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, ogedit) e deixar um pouco de lado o irb. Lembram-se no início do curso, que foi pedido que seinstalasse o Ruby e posteriormente o irb a fim 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 noterminal da seguinte forma: Depois de escrito o código, salve-o como ’nome do arquivo’.rb. Umexemplo: digamos que você tenha criado um arquivo com nome de Cachorro. Você deverá salvarcomo: Cachorro.rb.

Feito isso, você irá abrir o terminal e digitar: ruby Cachorro.rbPara esta lição, vamos criar a classe Carro.rb no editor de texto:

class Carrodef initialize(marca,modelo,cor)@marca = marca@modelo = modelo@cor = cor

endend

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 queapareceram diversas coisas novas, tais como: initialize, @ e ::new. Vamos falar agora sobre asvariá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á entreparênteses são os parâmetros utilizados pelas variáveis de instância;

• O "@"é utilizado para definir variáveis de instância, como foi visto, basta colocar @<nomeda 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 paramostrar seu conteúdo utilizando o puts. Aparecendo: #<Carro:0xb7d15954>. Apareceu isso, poisfoi pedido para mostrar um objeto. Para que apareça as características do carro, é preciso utilizaro "to_s"para converter objetos em strings, como visto em lições anteriores. Para isso, criaremoso método to_s. Veja um exemplo a seguir:

class Carrodef initialize(marca,modelo,cor)@marca = marca@modelo = modelo@cor = cor

end

def to_s"marca: #{@marca}, modelo: #{@modelo}, cor: #{@cor}"

endend

corsa = Carro::new("Chevrolet","Corsa","Vermelho")puts corsa

Mais uma novidade: o "#expressão". Ele funciona imprimindo a expressão que se encontrano 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=> nilirb(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 errode método, faça isso e verifique. Para contornarmos esse erro, faremos o seguinte:

class Carro

def initialize(marca,modelo,cor)@marca = marca@modelo = modelo@cor = cor

end


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 corsaputs corsa.modelocorsa.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 deinstância "modelo". Feito isso, pedimos para mostrar novamente a variável corsa, qual o modelo,a alteração do modelo e finalmente pedindo para mostrar a variável alterada.

Mas como Ruby é o melhor amigo do programador, ele permite que você tenha acesso aessas variáveis da seguinte forma:

class Carro

attr_reader :marca, :modelo, :corattr_writer :cor


end


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 novosmétodos dinamicamente, como mostrado abaixo na classe Carro:

48


class Carro

def novo_metodoputs "Novo metodo definido dinamicamente"

end

defputs "Mais um metodo definido dinamicamente"

endend

Com isso, os novos métodos poderão ser acessados normalmente pelas instâncias da classeCarro. 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 umaclasse diferente):

class ConstConstante = 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 umacópia delas por classe e são declaradas escrevendo @@ antes do nome escolhido e SEMPREtem que ser inicializadas antes de serem usadas. Veja um exemplo abordando tudo o que já foivisto:

class Veiculo

attr_reader :marca, :modelo, :cor


end

def to_s"marca:#{@marca} modelo:#{@modelo} cor:#{@cor}"

endend

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 [email protected]? modeloputs "Alerta! O Fabricante #{@nome} não fabrica o modelo #{modelo}"return nil

endputs "Fabricando um #{modelo} no fabricante #{@nome}"@@numero_total_de_veiculos += 1@quantidade_fabricada += 1Veiculo::new(@nome,modelo,cor,@modelos[modelo])

end

def Fabricante.numero_total_de_veiculos@@numero_total_de_veiculos

endend

# 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. Aprimeira classe é a chamada classe pai e as demais as classes filhas. Para executar os métodosda classe pai, usamos o super, que funciona enviando todos os parâmetros recebidos no métodopara a classe pai.

No entanto, há vezes que, por falta de atenção do programador, o número de argumentosenviados para a classe pai é diferente do número de argumentos, com isso aparece o seguinteerro: <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_testedef initialize (a1,a2)@i1 = a1@I2 = A2

end

def imprimeputs "primeiro argumento: #{@i1}, segundo argumento: #{@i2}"

end

end

class Apenas_outro_teste < Apenas_testedef initialize(a1,a2)super

endende1 = Apenas_teste::new(a,b)e2 = Apenas_outro_teste::new(c,d)

e1.imprimee2.imprime

Isso vai mostrar na tela: primeiro argumento: a, segundo argumento: b primeiro argumento:c, primeiro argumento: d

Ex2:


51


end


end

end

class Apenas_outro_teste < Apenas_testedef initialize(a1,a2)super

endend

e1 = Apenas_teste::new(a,b)e2 = Apenas_outro_teste::new(d)


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. Paracontornar a situação devemos fazer:


end


end

end

class Apenas_outro_teste < Apenas_testedef initialize(a1,a2)super(0,a2)

endend

e1 = Apenas_teste::new(a,b)e2 = Apenas_outro_teste::new(d)


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çasignifica que toda classe definida como uma subclasse de outra receberá automaticamente todoo conteúdo da classe pai. Com isso, voltando ao exemplo das montadoras, a classe veículo podecriar tanto automóveis quanto caminhões. Portanto, basta criar uma classe pai com os atributose métodos em comum e depois criar diversas subclasses com as características da classe pai emais alguns métodos e atributos. Veja o exemplo a seguir:

class Veiculoattr_reader :marca, :modelo, :cor


end

def to_s"marca:#{@marca} modelo:#{@modelo} cor:#{@cor}"

end

class Carro < Veiculodef to_s #o to_s foi usado para retornar se será fabricado um carro ou um caminhão."Carro: "+superend #veja que para criar uma classe a partir de outra, basta fazer classe_nova

< classe_velhaend

class Caminhonete < Veiculodef to_s"Caminhonete: "+Veiculoend

endend

class Fabricanteattr_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 [email protected]? modeloputs "Alerta! O Fabricante #{@nome} não fabrica o modelo #{modelo}"return nil

endputs "Fabricando um #{modelo} no fabricante #{@nome} "@@numero_total_de_veiculos += 1@quantidade_fabricada += 1Veiculo::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

endend

# 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 osmé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 é especificado por símbolos.

Os métodos públicos podem ser acessados por qualquer método em qualquer objeto.

Ex:

class ApenasTestedef diz_ola"ola!"

end

def cumprimenta(diferente)puts "Eu cumprimento:"+diz_olaputs "A outra classe cumprimenta:"+diferente.diz_ola

endpublic :diz_ola # Especificação por símbolos.

end

class ApenasTesteFilha < ApenasTestedef metodo_olaputs "Filha cumprimento:"+diz_ola

endend

class ClasseDiferentedef cumprimenta(outra_forma)puts "Classe diferente acessando:"+diferente.diz_ola

endend

pub1 = ApenasTeste::newpub2 = ApenasTeste::newfilha= ApenasTesteFilha::newdif = ClasseDiferente::newpub1.cumprimenta(pub2)filha.metodo_oladif.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 estejana 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 Teste1def diz_ola"ola!"

end

def cumprimenta(diferente)puts "Eu cumprimento:"+diz_olaputs "A outra classe cumprimenta:"+diferente.diz_ola

endprivate :diz_ola

end

class Teste1Filha < Teste1def metodo_oiputs "Filha cumprimenta:"+diz_ola

endend

class ClasseDiferentedef cumprimente(outra_forma)puts "Classe diferente acessando:"+outra.diz_ola

endend

pri1 = Teste1::newpri2 = Teste1::newfilha= Teste1Filha::newdif = ClasseDiferente::newfilha.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 filha que aciona o métodoherdado "diz_ola". A classe principal chama seu método "diz_ola", no entanto não consegueacessar 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 TesteProtectdef diz_ola"ola!"

end

def cumprimenta(diferente)puts "Eu cumprimento:"+diz_olaputs "A outra classe cumprimenta::"+diferente.diz_ola

endprotected :diz_ola

end

class TesteProtectFilha < TesteProtectdef metodo_oiputs "Filha cumprimenta:"+diz_ola

endend

class ClasseDiferentedef cumprimenta(diferente)puts "Classe diferente acessando:"+diferente.diz_ola

endend

pro1 = TesteProtect::newpro2 = TesteProtect::newfilha= TesteProtectFilha::newdif = Classediferente::newpro1.cumprimenta(pro2) # pro1 consegue acessar pro2filha.metodo_oidif.cumprimente(pro1) # diferente nao consegue acessar pro1

Tais conceitos de métodos públicos e privados são exclusivos da linguagem Ruby, diferindodas outras linguagens de programação.

57

Capítulo 8

Entradas e Saídas

8.1 Fluxos de Entradas e Saídas Simples

Como em todas as linguagens de programação, existe, também em Ruby, os fluxos de entradae saídas. E podem ser fluxos simples e fluxos complexos.

Os fluxos simples de saída são: puts, print. O primeiro foi muito utilizado nas lições anteriores.E como foi visto, é utilizado para imprimir e quebrar uma linha. Já o print apenas imprime emantém na mesma linha.

Já um fluxo de entrada simples é o gets. Veja o exemplo desses fluxos de entrada e saída nocódigo abaixo feito no editor de texto:

beginputsputsputs " CODIGO DE ENTRADA E SAÍDA"print "--------------------------"putsputsputsputs "Insira o nome do usuário: "nome = gets # foi digitado aqui fulano de talputsputsputs "O nome do usuário é: #{nome}"putsputs "Pressione 'Enter' para sair"gets

end

Será impresso isso no terminal:

CODIGO DE ENTRADA E SAÍDA————————————————–

Insira o nome do usuário: Monitor

58


O nome do usuário é: fulano de tal

Pressione ’Enter’ para sair

Perceba que o código tem diversos "puts"para ir pulando a linha, isso foi feito para visualizarmelhor o código. Isso vai do gosto do programador. É feito para melhorar o contato entre oprograma e o usuário, para que não fique confuso depois de interpretado o código.

Veja que utilizamos o gets. No primeiro momento em que ele foi utilizado, este tem comofinalidade atribuir à variável "nome"o que o usuário digita no teclado depois de pressionada a tecla"enter". No segundo momento, ele foi utilizado para que o programa encerre somente quando ousuário pressionar "enter".

8.2 Arquivos

Já os fluxos de entrada e saída são mais complexos, podemos citar os arquivos. A linguagemRuby trabalha muito bem com arquivo texto. Vamos ver um código que abordará de forma geraltudo que precisamos saber sobre arquivos.

No editor de Texto (sugiro novamente o gedit), vamos começar com o corpo principal do nossoproblema: criar uma agenda. Posteriormente faremos algumas "brincadeiras"para melhorar ocontato entre o usuário e o programa. Na primeira linha digitaremos:

exemplo_texto = File.new("Teste.txt","w")

O que foi feito aqui: atribuímos à variável "Exemplo_texto"todas a informação fornecidas antesde gravar no arquivo texto. Ela receberá o objeto "File"(manuseia o arquivo) junto com o atributo"new"(cria um novo arquivo). Mandamos os parâmetros entre parênteses para o atributo "new"o<nome do texto> que será gravado e a opção de gravação "w"(vem de write).

Agora faremos o seguinte: falar o que queremos escrever no arquivo texto. Pode ser feito devárias formas. Vamos falar de duas delas:

exemplo_texto.write "Escreve no arquivo"

OU

exemplo_texto.puts "Escreve no arquivo"

O primeiro modo é utilizando o método "write"depois da variável. Esse método só pode serutilizado quando iniciamos a variável com "File.new(...)". Após o metódo está o que será escritono arquivo.

O segundo modo é utilizando o método "puts". Ele funciona semelhantemente ao primeirométodo (write), diferindo na hora da escrita. O "puts"coloca uma informação em cada linha e owrite coloca tudo na mesma linha.

Depois de escrever o que queríamos, utilizamos o método "close"para fecharmos o arquivoda seguinte forma:

exemplo_texto.close

Juntando tudo já temos o seguinte:

59


exemplo_texto = File.new("Teste.txt","w")exemplo_texto.puts "Escreve no arquivo"exemplo_texto.close

Caso não se lembrem mais, temos que salvar esse código como <nome do arquivo>.rb, nocaso podemos salvar como: ApenasTeste.rb.

Rodem no terminal digitando: ruby ApenasTeste.rbO arquivo criado vai para a mesma pasta que você salvou o código. Faça isso e veja se o

arquivo foi criado e qual o seu conteúdo.Como nosso intuito aqui é de criar uma agenda, e como já vimos como funciona o gets,

utilizaremos ele aqui. Vamos fazer o seguinte:

print " Insira o nome do contato: "nome = getsprint " Insira o numero do telefone: "telefone = getsagend = File.new("Agenda.txt","w")agend.print "#{nome}"agend.print "#{telefone}"agend.close

Explicando o código: Primeiramente utilizamos o print para mostrar na tela o que o usuáriodeve fazer, com isso o cursor do terminal fica na frente da frase e não pula uma linha comoaconteceria se utilizássemos o puts. Depois atribuímos à variável nome o que o usuário escreveu.Logo depois criamos a variável agend com as devidas especificações para salvar nela o que serádesejado. Depois, gravamos no arquivo os conteúdos das variáveis finalizando com o fechamentodo arquivo.

Vamos agora ver como lemos um arquivo já criado pela gente.Com o irb aberto digite: File.readlines("Agenda.txt").O readlines lê o arquivo e faz com que seja mostrado o que está gravado no arquivo (depen-

derá do que você tenha escrito).O arquivo que eu criei teve a seguinte saída:

irb(main):001:0> File.readlines("Agenda.txt")=> ["joao\n", "45545454\n"]irb(main):002:0>

Útil seria se armazenássemos o que tem dentro do arquivo em uma variável para que sejamelhor compreendido:

irb(main):001:0> File.readlines("Agenda.txt")=> ["joao\n", "45545454\n"]irb(main):002:0> text = File.readlines("Agenda.txt")=> ["joao\n", "45545454\n"]irb(main):003:0> puts textjoao45545454=> nilirb(main):004:0>

60

Linguagem ruby

Education

Transcript of Linguagem ruby