Baixar para ler offline
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
=> true
irb(main):002:0> puts v.class
TrueClass
=> nil
irb(main):003:0> f = false
=> false
irb(main):004:0> f.class
=> FalseClass
irb(main):005:0> n = nil
=> nil
irb(main):006:0> n.class
=> NilClass
irb(main):007:0>
Depois dos booleanos, um dos tipos mais comuns também nas linguagens de programação e,
logicamente, presente em Ruby são as Strings, que nada mais são do que um tipo que armazena
"palavras"ou um conjunto de palavras. Um exemplo:
irb(main):001:0> p1 = "Teste"
=> "Teste"
irb(main):002:0> p2 = "Teste2"
=> "Teste2"
irb(main):003:0> p3 = "Uma frase"
=> "Uma frase"
irb(main):004:0> p1.class
=> String
irb(main):005:0> p2.class
=> String
irb(main):006:0> p3.class
=> String
irb(main):007:0>
Como em outras linguagens, a manipulação de strings pode ser feita da seguinte forma:
usando [] (colchetes) com um índice no interior. Para visualizar isso, eis um exemplo:
irb(main):001:0> palavra = "animal"
=> "animal"
irb(main):002:0> palavra[0] = "b"
=> "b"
irb(main):003:0> puts palavra
bnimal
=> nil
irb(main):004:0>
Explicando o que foi feito acima: primeiro atribuímos para a variável "palavra"uma string; logo
depois alteramos o valor da primeira posição da string (no caso o índice zero) trocando o caractere
"a"pelo caractere "b"e imprimimos a nova string.
Para criarmos strings grandes, no caso um texto, podemos usar uma ferramenta denominada
heredoc, a qual funciona da seguinte forma:
30](https://image.slidesharecdn.com/linguagemruby-160921151439/85/Linguagem-ruby-31-320.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
irb(main):001:0> i1 = 0..5
=> 0..5
irb(main):002:0> i2 = 0...5
=> 0...5
irb(main):003:0>
O intervalo i1 vai conter números de zero até cinco. Já, o intervalo i2 irá conter os números
de zero até 4. Isso ocorre devido a adição de mais um ponto, fazendo com que o intervalo seja
fechado em zero e aberto em 5, ou seja, inclui o zero e não inclui o cinco.
Vamos falar agora um pouco sobre os operadores do Ruby. Muitos deles são bastante conhe-
cidos por você.
- começando pelas quatro operações fundamentais da aritmética: +, - , / , * , respectivamente,
adição, subtração, divisão e multiplicação; - temos também os operadores: ** , % , que indi-
cam exponenciação e módulo (vimos esse operador no exemplo para criar 2 arrays sob algumas
condições); - temos os operadores de comparação: > ,< , >= , <= , respectivamente, maior, me-
nor, maior igual, menor igual; - comparador de igualdade: ==; - and e or que são utilizados nas
estruturas de controle (Veremos isso na próxima lição).
Os operadores serão melhor compreendidos no decorrer desta lição, visto que serão dados
exemplos.
Não poderia faltar nessa sessão os arrays, bastante conhecidos em várias linguagens de
programação. Eles podem conter vários tipos de objetos. Exemplo:
irb(main):001:0> v = [’mais’,’exemplos’,100] => ["mais", "exemplos", 100] irb(main):002:0> puts
v mais exemplos 100 => nil irb(main):003:0> puts v[2] 100 => nil irb(main):004:0>
Observe o uso de [] (colchetes) para atribuir os objetos ao array "v"e as vírgulas que separam
cada termo do array. Veja também como faz para mostrar o conteúdo utilizando índices.
Existe um atalho bastante útil quando trabalhamos com arrays com apenas strings, é o %w.
Esse atalho funciona da seguinte forma:
irb(main):001:0> v = %w(caneta lapis apontador regua)
=> ["caneta", "lapis", "apontador", "regua"]
irb(main):002:0>
Caso queira usar uma string "composta"(com mais de uma palavra) como no exemplo abaixo,
basta utilizar o caractere "¨(sem as aspas).
irb(main):001:0> v1 = %w(cachorro gato colhe tigre dente de sabre)
=> ["cachorro", "gato", "colhe", "tigre dente de sabre"]
irb(main):002:0>
Observação: Perceba que houve uma pequena diferença quando utilizamos o atalho %w.
Houve a utilização de parênteses ao invés de colchetes.
Vimos como montar um array a partir do nada. Agora, como faríamos para adicionar elemen-
tos a um array já existente? Basta utilizar o push ou o operador « (olha ele aí de novo, faz sentido
já que uma string é um vetor de caractere).
Mais um exemplo:
irb(main):001:0> v = %w(azul vermelho)
=> ["azul", "vermelho"]
irb(main):002:0> v.push "laranja"
32](https://image.slidesharecdn.com/linguagemruby-160921151439/85/Linguagem-ruby-33-320.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
=> ["azul", "vermelho", "laranja"]
irb(main):003:0> v.push "amarelo"
=> ["azul", "vermelho", "laranja", "amarelo"]
A partir daqui utilizou-se o operador «<"(sem aspas) aproveitando o mesmo array.
irb(main):004:0> v << "preto"
=> ["azul", "vermelho", "laranja", "amarelo", "preto"]
irb(main):005:0> v << "roxo"
=> ["azul", "vermelho", "laranja", "amarelo", "preto", "roxo"]
irb(main):006:0>
Observação: Lembram-se quando foi dado o exemplo dos blocos de código no início desta
lição? Então, a partir daqui talvez fique mais claro o que foi dito.
Um mecanismo muito interessante em Ruby para a manipulação de arrays é o seguinte: dado
um determinado array, queremos criar um outro a partir de uma determinada condição depois de
tê-lo processado. Veja o exemplo abaixo:
irb(main):001:0> v1 = [10,11,12,13,14,15]
=> [10, 11, 12, 13, 14, 15]
irb(main):002:0> v2 = v1.find_all{|par| par%2 == 0}.map{|par| par*3}
=> [30, 36, 42]
irb(main):003:0>
Foi feito o seguinte: o método 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 os
elementos que foram processados com o seu valor triplicado.
A ordenação de array pode ser feita utilizando o método sort. Ou seja:
irb(main):001:0> v = %w(arnaldo zeca bruno michele andrea)
=> ["arnaldo", "zeca", "bruno", "michele", "andrea"]
irb(main):002:0> v.sort
=> ["andrea", "arnaldo", "bruno", "michele", "zeca"]
irb(main):003:0>
Outra forma seria utilizando o sort_by. Ele ordena o array a partir de uma determinada propri-
edade do valor que está sendo avaliado. Veja:
Ordenação por ordem alfabética analisando a primeira letra da string.
irb(main):001:0> nome = ["zeca","amanda","beto","carla"]
=> ["zeca", "amanda", "beto", "carla"]
irb(main):002:0> nome.sort_by{|a1| a1[0]}
=> ["amanda", "beto", "carla", "zeca"]
A ordenação aqui foi por ordem crescente de tamanho da string utilizando o length.
irb(main):003:0> nome.sort_by{|a1| a1.length}
=> ["zeca", "beto", "carla", "amanda"]
irb(main):004:0>
33](https://image.slidesharecdn.com/linguagemruby-160921151439/85/Linguagem-ruby-34-320.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
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 determinado
bloco retornando true ou false. Exemplo:
irb(main):001:0> numero = [1,2,3,4,5]
=> [1, 2, 3, 4, 5]
irb(main):002:0> numero.any?{|teste| teste > 3}
=> true
irb(main):003:0> numero.any?{|teste| teste > 5}
=> false
irb(main):004:0>
Agora, para testar se todos os elementos do array se encaixam na condição de um determi-
nado bloco, utilizamos o método all?. Eis outro exemplo:
irb(main):001:0> numero = [101,230,300,1000]
=> [101, 230, 300, 1000]
irb(main):002:0> numero.all?{|teste2| teste2 > 100}
=> true
irb(main):003:0> numero.all?{|teste2| teste2 > 1000}
=> false
irb(main):004:0>
Veja agora uma ferramenta muito interessante. Trata-se da criação de dois arrays a partir de
um outro array baseado na condição de um determinado bloco de código. Tal método denomina-
se partition. Exemplo:
irb(main):001:0> vetor1 = [1,2,3,4,5,6,7,8,9,10]
=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
irb(main):002:0> par,impar = vetor1.partition{|ex| ex%2 == 0}
=> [[2, 4, 6, 8, 10], [1, 3, 5, 7, 9]]
irb(main):003:0> par
=> [2, 4, 6, 8, 10]
irb(main):004:0> impar
=> [1, 3, 5, 7, 9]
irb(main):005:0> puts par
2
4
6
8
10
=> nil
irb(main):006:0> puts impar
1
3
5
7
9
=> nil
irb(main):007:0>
34](https://image.slidesharecdn.com/linguagemruby-160921151439/85/Linguagem-ruby-35-320.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
Perceba o que foi feito no código acima:
• primeiro, foram atribuídos à variável vetor1 os números de 1 a 10, como foi feito em diversos
exemplos acima;
• depois dois novos arrays receberam novos elementos a partir da condição especificada pelo
bloco, que no caso, será escolher os elementos que são pares;
• mas esse método funciona fazendo com que o primeiro array receba os elementos da con-
dição e o segundo array recebe os elementos que não satisfazem à condição;
• depois foi pedido para mostrar os dois arrays com seus respectivos elementos, o que já foi
dito bem no início do curso como faz.
Depois de mostrado como são os arrays na linguagem Ruby, vamos falar um pouco de
Hashes. Aqui não haverá muito o que falar, pois, hashes são arrays com índices que você
mesmo define para seus elementos. Tais índices podem ser: strings, inteiros (Fixnum) ou até
mesmo símbolos (será tratado em seguida). Veja do que se trata os hashes pelos seguintes
exemplos:
Utilizando strings
irb(main):001:0> hashe = {"p"=>"primeiro elemento","s"=>"segundo elemento"}
=> {"p"=>"primeiro elemento", "s"=>"segundo elemento"}
irb(main):002:0> hashe["s"]
=> "segundo elemento"
Utilizando inteiros (Fixnum)
irb(main):003:0> hashe2 = {1=>"teste1",2=>"teste2"}
=> {1=>"teste1", 2=>"teste2"}
irb(main):004:0> hashe2[1]
=> "teste1"
irb(main):005:0>
Utilizando Símbolos
irb(main):005:0> hash3 = {:primeiro=>"elemento1", :segundo=>"elemento2"}
=> {:primeiro=>"elemento1", :segundo=>"elemento2"}
irb(main):006:0> hash3[:segundo]
=> "elemento2"
irb(main):007:0>
Deve ter ficado alguma dúvida quanto aos símbolos mencionados acima. Símbolos nada mais
são que pequenas strings que representam sempre o mesmo objeto. Podem representar nomes
ou Strings dentro do interpretador Ruby. São criados colocando “:“ dois pontos) na frente do
nome, como foi feito para definir os índices dos hashes acima:
• :primeiro;
• :segundo.
35](https://image.slidesharecdn.com/linguagemruby-160921151439/85/Linguagem-ruby-36-320.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
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ão
a utilidade da linguagem Ruby , uma vez que, como já foi dito diversas vezes e não custa nada
falar de novo, ela é 100% orientada a objetos. Portanto Até lá veremos o que acontece de comum
entre as linguagens.
Para declaramos um método basta iniciá-lo com defnome do metodo...end (parecido com a
declaração de um bloco de código). Um exemplo para visualizar o que foi dito:
irb(main):001:0> def testando
irb(main):002:1> puts "veja o que acontece quando chamamos um metodo"
irb(main):003:1> end
=> nil
irb(main):004:0> testando
veja o que acontece quando chamamos um metodo
=> nil
irb(main):005:0>
Os métodos também retornam valores que podem ser de 2 formas: com o return ou sem o
return, nesse caso, o valor retornado pelo método é a última expressão avaliada. Veja o exemplo:
Com o return:
irb(main):001:0> def divide(x1,x2)
irb(main):002:1> return x1/x2
irb(main):003:1> end
=> nil
irb(main):004:0> divide(12,3)
=> 4
irb(main):005:0>
Sem o return:
irb(main):001:0> def divide(x1,x2)
irb(main):002:1> x1/x2
irb(main):003:1> end
=> nil
irb(main):004:0> divide(36,6)
=> 6
irb(main):005:0>
Foi simples o que foi feito aqui: criamos um método chamado "divide"quem tem dois argumen-
tos. Dentro do método foi colocada a expressão. Feito isso, chamamos o método e passamos
dois valores para seus argumentos, fazendo com que retorne o resultado da expressão avaliada.
Os métodos podem retornar também mais de um resultado. Na verdade, é retornado apenas
um objeto, no entanto, dá a impressão que são vários. Exemplo:
irb(main):001:0> def multiplos[[no]]
irb(main):002:1> (1..4).map{|x|x*n}
irb(main):003:1> end
36](https://image.slidesharecdn.com/linguagemruby-160921151439/85/Linguagem-ruby-37-320.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
=> nil
irb(main):004:0> multiplos(3)
=> [3, 6, 9, 12]
irb(main):005:0> a,b,c,d = multiplos(3)
=> [3, 6, 9, 12]
irb(main):006:0> puts "Os multiplos de 3 são: #{a},#{b},#{c},#{d}"
Os multiplos de 3 são: 3,6,9,12
=> nil
irb(main):007:0>
Entendendo o código: criamos um método que calcula os quatros primeiros múltiplos de um
certo número. Vemos isso pelo intervalo que foi imposto no método, no caso o 4.
No método map, criamos um array com a condição passada pelo bloco, no caso o x*n. Depois,
chamamos o método e passamos um valor para seu argumento. Logo após esses procedimentos,
pedimos a impressão dos múltiplos do número passado para o método, no caso, o 3. Com isso,
foi mostrado os quatro primeiros múltiplos de 3.
Ainda em métodos, uma das funcionalidades que podem ser utilizadas é o passagem de um
bloco como parâmetro para o método. Para isso, utilizamos o método yield. Veja como isso é
feito:
irb(main):001:0> def multiplica(a1,b1)
irb(main):002:1> yield(a1,b1)
irb(main):003:1> end
=> nil
irb(main):004:0> multiplica(3,4){|x1,x2|x1*x2}
=> 12
irb(main):005:0>
Há também, uma maneira de testar se o bloco foi passado ao método. Para isso utilizamos o
block_given como mostrado abaixo:
irb(main):001:0> def multiplica(a1,b1)
irb(main):002:1> if block_given?
irb(main):003:2> yield(a1,b1)
irb(main):004:2> else
irb(main):005:2* puts " Bloco nao passado para o metodo!"
irb(main):006:2> end
irb(main):007:1> end
=> nil
irb(main):008:0> multiplica(2,7){|x1,x2| x1*x2}
=> 14
irb(main):009:0> multiplica(3,5){|x1,x2| x1*x2}
=> 15
irb(main):010:0> multiplica(3,5)
Bloco nao passado para o metodo!
=> nil
irb(main):011:0>
37](https://image.slidesharecdn.com/linguagemruby-160921151439/85/Linguagem-ruby-38-320.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
Observação: os parâmetros são enviados como cópia da referência de um objeto, portanto,
se alterarmos o objeto que foi passado como parâmetro, dentro do método, o objeto será alterado
fora do método também.
Existem diferentes tipos de métodos. São eles: métodos destrutivos e métodos predicados.
Os métodos destrutivos são aqueles que têm uma "!"(sem aspas) logo depois do nome. Isso
faz com que o conteúdo do próprio objeto seja alterado na sua posição de memória. Já, os
métodos predicados são aqueles que têm um "?"(sem aspas) logo após o nome. Esses méto-
dos retornam true ou false e são úteis para testar uma condição. Veja exemplos dos métodos
mencionados.
Um exemplo de método destrutivo:
irb(main):001:0> t = "Ola, apenas um teste"
=> "Ola, apenas um teste"
irb(main):002:0> t.object_id
=> -605661358
irb(main):003:0> def caps(t)
irb(main):004:1> t.upcase!
irb(main):005:1> end
=> nil
irb(main):006:0> caps(t)
=> "OLA, APENAS UM TESTE"
irb(main):007:0> t.object_id
=> -605661358
irb(main):008:0>
Perceba que a posição de memória permanece a mesma.
Método predicado:
irb(main):001:0> teste = %w(hd monitor gabinete mouse)
=> ["hd", "monitor", "gabinete", "mouse"]
irb(main):002:0> teste.include? "hd"
=> true
irb(main):003:0> teste.include? "teclado"
=> false
irb(main):004:0>
O código consiste em dizer se uma certa palavra pertence ao array.
Depois do que foi dito, nada mais aceitável do que ver como funciona tudo em um mesmo
programa. Por exemplo, testaremos o escopo das variáveis dentro de um método:
irb(main):001:0> $t = "a"
=> "a"
irb(main):002:0> t = "b"
=> "b"
irb(main):003:0> def apenas_teste
irb(main):004:1> puts $t
irb(main):005:1> puts t
irb(main):006:1> end
=> nil
38](https://image.slidesharecdn.com/linguagemruby-160921151439/85/Linguagem-ruby-39-320.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
irb(main):007:0> apenas_teste
a
NameError: undefined local variable or method `t' for main:Object
from (irb):5:in `apenas_teste'
from (irb):7
from :0
irb(main):008:0>
Perceba que atribuímos à variável pública (lembre-se que a variável é pública quando possui
o "$"(sem aspas) antes do nome) o caractere "a"e à varíavel privada o caractere "b". Criamos
o método e no seu interior, pedimos que fosse impresso na tela as duas variáveis. Logo após
chamamos o método. A primeira variável foi impressa, por ser pública. No entanto a segunda
variável não pode ser impressa. Isso ocorreu porque a segunda variável é privada, ou seja, não
pode ser acessada pelo método criado, ao contrário da variável pública.
Vamos ver agora um pouco de Ranges e blocos interagindo. As Ranges possuem um método
denominado each, que trabalha da seguinte forma: para cada valor da Range, o bloco tal é
executado. Veja o exemplo:
irb(main):001:0> r = 0..4
=> 0..4
irb(main):002:0> r.class
=> Range
irb(main):003:0> r.each{puts "Apenas outro teste"}
Apenas outro teste
Apenas outro teste
Apenas outro teste
Apenas outro teste
Apenas outro teste
=> 0..4
irb(main):004:0>
Perceba que o bloco que contém o "puts"foi executado cinco vezes, ou seja, o intervalo da
Range.
Vamos agora, passar vários argumentos para o bloco usando uma Hash. Exemplo:
irb(main):001:0> hs = {1=>"primeiro",2=>"segundo"}
=> {1=>"primeiro", 2=>"segundo"}
irb(main):002:0> hs.each{|i,j| puts "indice:"+i.to_s+" valor:"+j.to_s}
indice:1 valor:primeiro
indice:2 valor:segundo
=> {1=>"primeiro", 2=>"segundo"}
irb(main):003:0>
O mesmo vale para os arrays. Exemplo:
irb(main):001:0> vetor = %w(primeira posicao segunda posicao)
=> ["primeira posicao", "segunda posicao"]
irb(main):002:0> vetor.each{|i| puts "Veja a: "+i.to_s}
Veja a: primeira posicao
39](https://image.slidesharecdn.com/linguagemruby-160921151439/85/Linguagem-ruby-40-320.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
Veja a: segunda posicao
=> ["primeira posicao", "segunda posicao"]
irb(main):003:0>
Uma ferramenta interessante é a concatenação de métodos. Por exemplo, vamos concatenar
o sort e o each:
irb(main):001:0> vetor = %w(casa predio escritorio apartamento)
=> ["casa", "predio", "escritorio", "apartamento"]
irb(main):002:0> vetor.sort.each{|j| puts "Depois de ordenado: "+j.to_s}
Depois de ordenado: apartamento
Depois de ordenado: casa
Depois de ordenado: escritorio
Depois de ordenado: predio
=> ["apartamento", "casa", "escritorio", "predio"]
irb(main):003:0>
40](https://image.slidesharecdn.com/linguagemruby-160921151439/85/Linguagem-ruby-41-320.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
@@numero_total_de_veiculos = 0
def initialize(nome,modelos)
@nome = nome
@modelos = modelos
@quantidade_fabricada = 0
end
def fabrica(modelo,cor)
if !@modelos.include? modelo
puts "Alerta! O Fabricante #{@nome} não fabrica o modelo #{modelo}"
return nil
end
puts "Fabricando um #{modelo} no fabricante #{@nome}"
@@numero_total_de_veiculos += 1
@quantidade_fabricada += 1
Veiculo::new(@nome,modelo,cor,@modelos[modelo])
end
def Fabricante.numero_total_de_veiculos
@@numero_total_de_veiculos
end
end
# Vamos criar agora as fabricantes
volks = Fabricante::new("Volkswagen",{"Parati"=>30,"Jetta"=>40,"Passat"=>10})
ford = Fabricante::new("Ford",{"Ranger"=>30,"EcoSport"=>20,"Focus"=>10})
# Vamos criar agora os veiculos da Volks (com um erro)
veiculos_volks = []
veiculos_volks.push(volks.fabrica("Parati",:vermelho))
veiculos_volks.push(volks.fabrica("Jetta",:verde))
veiculos_volks.push(volks.fabrica("Ranger",:preto))
puts "#{volks.nome} fabricou #{volks.quantidade_fabricada} automóveis até o momento"
veiculos_volks.each {|v| puts v unless v.nil?}
puts
#Vamos agora criar os veiculos da Ford
veiculos_ford = []
veiculos_ford.push(ford.fabrica("Ranger",:preto))
veiculos_ford.push(ford.fabrica("EcoSport",:amarelo))
veiculos_ford.push(ford.fabrica("Focus",:prata))
puts "#{ford.nome} fabricou #{ford.quantidade_fabricada} automóveis até o momento"
50](https://image.slidesharecdn.com/linguagemruby-160921151439/85/Linguagem-ruby-51-320.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
if !@modelos.include? modelo
puts "Alerta! O Fabricante #{@nome} não fabrica o modelo #{modelo}"
return nil
end
puts "Fabricando um #{modelo} no fabricante #{@nome} "
@@numero_total_de_veiculos += 1
@quantidade_fabricada += 1
Veiculo::new(@nome,modelo,cor)
end
Carro::new(@nome,modelo,cor)
Caminhonete::new(@nome,modelo,cor)
def Fabricante.numero_total_de_veiculos
@@numero_total_de_veiculos
end
end
# Vamos criar agora as fabricantes
volks = Fabricante::new("Volkswagen",{"Parati"=>30,"Jetta"=>40,"Passat"=>10,
"17210C"=>275})
ford = Fabricante::new("Ford",{"Ranger"=>30,"EcoSport"=>20,"Focus"=>10,
"C-815"=>150})
# Vamos criar agora os veiculos da Volks (com um erro)
veiculos_volks = []
veiculos_volks.push(volks.fabrica("Parati",:vermelho))
veiculos_volks.push(volks.fabrica("Jetta",:verde))
veiculos_volks.push(volks.fabrica("Ranger",:preto))
veiculos_volks.push(volks.fabrica("17210C",:branco))
puts "#{volks.nome} fabricou #{volks.quantidade_fabricada} automóveis até o momento"
veiculos_volks.each {|v| puts v unless v.nil?}
puts
#Vamos agora criar os veiculos da Ford
veiculos_ford = []
veiculos_ford.push(ford.fabrica("Ranger",:preto))
veiculos_ford.push(ford.fabrica("EcoSport",:amarelo))
veiculos_ford.push(ford.fabrica("Focus",:prata))
veiculos_ford.push(ford.fabrica("C-815",:cinza))
puts "#{ford.nome} fabricou #{ford.quantidade_fabricada} automóveis até o momento"
54](https://image.slidesharecdn.com/linguagemruby-160921151439/85/Linguagem-ruby-55-320.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
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, no
caso podemos salvar como: ApenasTeste.rb.
Rodem no terminal digitando: ruby ApenasTeste.rb
O 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 = gets
print " Insira o numero do telefone: "
telefone = gets
agend = 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ário
deve fazer, com isso o cursor do terminal fica na frente da frase e não pula uma linha como
aconteceria 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 fechamento
do 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")
=> ["joaon", "45545454n"]
irb(main):002:0>
Útil seria se armazenássemos o que tem dentro do arquivo em uma variável para que seja
melhor compreendido:
irb(main):001:0> File.readlines("Agenda.txt")
=> ["joaon", "45545454n"]
irb(main):002:0> text = File.readlines("Agenda.txt")
=> ["joaon", "45545454n"]
irb(main):003:0> puts text
joao
45545454
=> nil
irb(main):004:0>
60](https://image.slidesharecdn.com/linguagemruby-160921151439/85/Linguagem-ruby-61-320.jpg)
Mais conteúdo relacionado
Linguagem ruby
- 1.
- 2. Sumário I Sobre essaApostila 2 II Informações Básicas 4 III GNU Free Documentation License 9 IV Linguagem Ruby 18 1 O que é a Linguagem Ruby 19 2 Plano de ensino 20 2.1 Objetivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 2.2 Público Alvo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 2.3 Pré-requisitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 2.4 Descrição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 2.5 Metodologia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 2.6 Cronograma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 2.7 Programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 2.8 Avaliação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 2.9 Bibliografia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 3 Introdução 22 3.1 Classes, Objetos e Métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 3.2 Variaveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 3.3 Outro conceitos importantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 4 Instalação e Início da Linguagem 24 4.1 Instalação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 4.2 Início da Linguagem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 5 Conhecendo um pouco a linguagem 26 5.1 Variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 5.2 Tipos Básicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 6 Estruturas de Controle e Comentários no Código 40 6.1 Condicionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 6.1.1 If/Else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 1
- 3. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 6.1.2 Case . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 6.2 Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 6.2.1 While . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 6.2.2 for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 6.2.3 until . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 6.3 Comentando o Código . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 7 Classes 45 7.1 Variáveis de Instância . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 7.2 Variáveis de Classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 8 Entradas e Saídas 57 8.1 Fluxos de Entradas e Saídas Simples . . . . . . . . . . . . . . . . . . . . . . . . . . 57 8.2 Arquivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 2
- 4. Parte I Sobre essaApostila 3
- 5. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF Conteúdo O conteúdo dessa apostila é fruto da compilação de diversos materiais livres publicados na in- ternet, disponíveis em diversos sites ou originalmente produzido no CDTC (http://www.cdtc.org.br.) O formato original deste material bem como sua atualização está disponível dentro da licença GNU Free Documentation License, cujo teor integral encontra-se aqui reproduzido na seção de mesmo nome, tendo inclusive uma versão traduzida (não oficial). A revisão e alteração vem sendo realizada pelo CDTC (suporte@cdtc.org.br) desde outubro de 2006. Críticas e sugestões construtivas serão bem-vindas a qualquer hora. Autores A autoria deste é de responsabilidade de Diego de Aquino Soares (diego@cdtc.org.br). O texto original faz parte do projeto Centro de Difusão de Tecnologia e Conhecimento que vêm sendo realizado pelo ITI (Instituto Nacional de Tecnologia da Informação) em conjunto com outros parceiros institucionais, e com as universidades federais brasileiras que tem produzido e utilizado Software Livre apoiando inclusive a comunidade Free Software junto a outras entidades no país. Informações adicionais podem ser obtidas através do email ouvidoria@cdtc.org.br, ou da home page da entidade, através da URL http://www.cdtc.org.br. Garantias O material contido nesta apostila é isento de garantias e o seu uso é de inteira responsabi- lidade do usuário/leitor. Os autores, bem como o ITI e seus parceiros, não se responsabilizam direta ou indiretamente por qualquer prejuízo oriundo da utilização do material aqui contido. Licença Copyright ©2006, Instituto Nacional de Tecnologia da Informação (cdtc@iti.gov.br) . Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with the Invariant Chapter being SOBRE ESSA APOS- TILA. A copy of the license is included in the section entitled GNU Free Documentation License. 4
- 6.
- 7. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF Sobre o CDTC Objetivo Geral O Projeto CDTC visa a promoção e o desenvolvimento de ações que incentivem a dissemina- ção de soluções que utilizem padrões abertos e não proprietários de tecnologia, em proveito do desenvolvimento social, cultural, político, tecnológico e econômico da sociedade brasileira. Objetivo Específico Auxiliar o Governo Federal na implantação do plano nacional de software não-proprietário e de código fonte aberto, identificando e mobilizando grupos de formadores de opinião dentre os servidores públicos e agentes políticos da União Federal, estimulando e incentivando o mercado nacional a adotar novos modelos de negócio da tecnologia da informação e de novos negócios de comunicação com base em software não-proprietário e de código fonte aberto, oferecendo treinamento específico para técnicos, profissionais de suporte e funcionários públicos usuários, criando grupos de funcionários públicos que irão treinar outros funcionários públicos e atuar como incentivadores e defensores dos produtos de software não proprietários e código fonte aberto, ofe- recendo conteúdo técnico on-line para serviços de suporte, ferramentas para desenvolvimento de produtos de software não proprietários e do seu código fonte livre, articulando redes de terceiros (dentro e fora do governo) fornecedoras de educação, pesquisa, desenvolvimento e teste de pro- dutos de software livre. Guia do aluno Neste guia, você terá reunidas uma série de informações importantes para que você comece seu curso. São elas: • Licenças para cópia de material disponível; • Os 10 mandamentos do aluno de Educação a Distância; • Como participar dos foruns e da wikipédia; • Primeiros passos. É muito importante que você entre em contato com TODAS estas informações, seguindo o roteiro acima. Licença Copyright ©2006, Instituto Nacional de Tecnologia da Informação (cdtc@iti.gov.br). 6
- 8. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF É dada permissão para copiar, distribuir e/ou modificar este documento sob os termos da Licença de Documentação Livre GNU, Versão 1.1 ou qualquer versão posterior públicada pela Free Software Foundation; com o Capitulo Invariante SOBRE ESSA APOSTILA. Uma cópia da licença está inclusa na seção entitulada "Licença de Docu- mentação Livre GNU". Os 10 mandamentos do aluno de educação online • 1. Acesso à Internet: ter endereço eletrônico, um provedor e um equipamento adequado é pré-requisito para a participação nos cursos a distância; • 2. Habilidade e disposição para operar programas: ter conhecimentos básicos de Informá- tica é necessário para poder executar as tarefas; • 3. Vontade para aprender colaborativamente: interagir, ser participativo no ensino a distân- cia conta muitos pontos, pois irá colaborar para o processo ensino-aprendizagem pessoal, dos colegas e dos professores; • 4. Comportamentos compatíveis com a etiqueta: mostrar-se interessado em conhecer seus colegas de turma respeitando-os e se fazendo ser respeitado pelos mesmos; • 5. Organização pessoal: planejar e organizar tudo é fundamental para facilitar a sua revisão e a sua recuperação de materiais; • 6. Vontade para realizar as atividades no tempo correto: anotar todas as suas obrigações e realizá-las em tempo real; • 7. Curiosidade e abertura para inovações: aceitar novas idéias e inovar sempre; • 8. Flexibilidade e adaptação: requisitos necessário à mudança tecnológica, aprendizagens e descobertas; • 9. Objetividade em sua comunicação: comunicar-se de forma clara, breve e transparente é ponto - chave na comunicação pela Internet; • 10. Responsabilidade: ser responsável por seu próprio aprendizado. O ambiente virtual não controla a sua dedicação, mas 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ções que sejam pertinentes ao curso (avisos, notícias). As mensagens postadas nele são enviadas a 7
- 9. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF todos participantes. Assim, se o monitor ou algum outro participante tiver uma informação que interesse ao grupo, favor postá-la aqui. Porém, se o que você deseja é resolver alguma dúvida ou discutir algum tópico específico do curso. É recomendado que você faça uso do Fórum de dúvidas gerais que lhe dá recursos mais efetivos para esta prática. . O fórum de dúvidas gerais tem por objetivo disponibilizar um meio fácil, rápido e interativo para solucionar suas dúvidas e trocar experiências. As mensagens postadas nele são enviadas a todos participantes do curso. Assim, fica muito mais fácil obter respostas, já que todos podem ajudar. Se você receber uma mensagem com algum tópico que saiba responder, não se preocupe com a formalização ou a gramática. Responda! E não se esqueça de que antes de abrir um novo tópico é recomendável ver se a sua pergunta já foi feita por outro participante. A segunda forma se dá pelas Wikis: . Uma wiki é uma página web que pode ser editada colaborativamente, ou seja, qualquer par- ticipante pode inserir, editar, apagar textos. As versões antigas vão sendo arquivadas e podem ser recuperadas a qualquer momento que um dos participantes o desejar. Assim, ela oferece um ótimo suporte a processos de aprendizagem colaborativa. A maior wiki na web é o site "Wikipé- dia", uma experiência grandiosa de construção de uma enciclopédia de forma colaborativa, por pessoas de todas as partes do mundo. Acesse-a em português pelos links: • Página principal da Wiki - http://pt.wikipedia.org/wiki/ Agradecemos antecipadamente a sua colaboração com a aprendizagem do grupo! Primeiros Passos Para uma melhor aprendizagem é recomendável que você siga os seguintes passos: • Ler o Plano de Ensino e entender a que seu curso se dispõe a ensinar; • Ler a Ambientação do Moodle para aprender a navegar neste ambiente e se utilizar das ferramentas básicas do mesmo; • Entrar nas lições seguindo a seqüência descrita no Plano de Ensino; • Qualquer dúvida, reporte ao Fórum de Dúvidas Gerais. Perfil do Tutor Segue-se uma descrição do tutor ideal, baseada no feedback de alunos e de tutores. O tutor ideal é um modelo de excelência: é consistente, justo e profissional nos respectivos valores e atitudes, incentiva mas é honesto, imparcial, amável, positivo, respeitador, aceita as idéias dos estudantes, é paciente, pessoal, tolerante, apreciativo, compreensivo e pronto a ajudar. 8
- 10. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF A classificação por um tutor desta natureza proporciona o melhor feedback possível, é crucial, e, para a maior parte dos alunos, constitui o ponto central do processo de aprendizagem.’ Este tutor ou instrutor: • fornece explicações claras acerca do que ele espera e do estilo de classificação que irá utilizar; • gosta que lhe façam perguntas adicionais; • identifica as nossas falhas, mas corrige-as amavelmente’, diz um estudante, ’e explica por- que motivo a classificação foi ou não foi atribuída’; • tece comentários completos e construtivos, mas de forma agradável (em contraste com um reparo de um estudante: ’os comentários deixam-nos com uma sensação de crítica, de ameaça e de nervossismo’) • dá uma ajuda complementar para encorajar um estudante em dificuldade; • esclarece pontos que não foram entendidos, ou corretamente aprendidos anteriormente; • ajuda o estudante a alcançar os seus objetivos; • é flexível quando necessário; • mostra um interesse genuíno em motivar os alunos (mesmo os principiantes e, por isso, talvez numa fase menos interessante para o tutor); • escreve todas as correções de forma legível e com um nível de pormenorização adequado; • acima de tudo, devolve os trabalhos rapidamente; 9
- 11. Parte III GNU FreeDocumentation License 10
- 12. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF (Traduzido pelo João S. O. Bueno através do CIPSGA em 2001) Esta é uma tradução não oficial da Licença de Documentação Livre GNU em Português Brasi- leiro. Ela não é publicada pela Free Software Foundation, e não se aplica legalmente a distribuição de textos que usem a GFDL - apenas o texto original em Inglês da GNU FDL faz isso. Entretanto, nós esperamos que esta tradução ajude falantes de português a entenderem melhor a GFDL. This is an unofficial translation of the GNU General Documentation License into Brazilian Por- tuguese. It was not published by the Free Software Foundation, and does not legally state the distribution terms for software that uses the GFDL–only the original English text of the GFDL does that. However, we hope that this translation will help Portuguese speakers understand the GFDL better. Licença de Documentação Livre GNU Versão 1.1, Março de 2000 Copyright (C) 2000 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA É permitido a qualquer um copiar e distribuir cópias exatas deste documento de licença, mas não é permitido alterá-lo. INTRODUÇÃO O propósito desta Licença é deixar um manual, livro-texto ou outro documento escrito "livre"no sentido de liberdade: assegurar a qualquer um a efetiva liberdade de copiá-lo ou redistribui-lo, com ou sem modificações, comercialmente ou não. Secundariamente, esta Licença mantém para o autor e editor uma forma de ter crédito por seu trabalho, sem ser considerado responsável pelas modificações feitas por terceiros. Esta Licença é um tipo de "copyleft"("direitos revertidos"), o que significa que derivações do documento precisam ser livres no mesmo sentido. Ela complementa a GNU Licença Pública Ge- ral (GNU GPL), que é um copyleft para software livre. Nós fizemos esta Licença para que seja usada em manuais de software livre, por que software livre precisa de documentação livre: um programa livre deve ser acompanhado de manuais que provenham as mesmas liberdades que o software possui. Mas esta Licença não está restrita a manuais de software; ela pode ser usada para qualquer trabalho em texto, independentemente do assunto ou se ele é publicado como um livro impresso. Nós recomendamos esta Licença prin- cipalmente para trabalhos cujo propósito seja de introdução ou referência. APLICABILIDADE E DEFINIÇÕES Esta Licença se aplica a qualquer manual ou outro texto que contenha uma nota colocada pelo detentor dos direitos autorais dizendo que ele pode ser distribuído sob os termos desta Licença. O "Documento"abaixo se refere a qualquer manual ou texto. Qualquer pessoa do público é um 11
- 13. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF licenciado e é referida como "você". Uma "Versão Modificada"do Documento se refere a qualquer trabalho contendo o documento ou uma parte dele, quer copiada exatamente, quer com modificações e/ou traduzida em outra língua. Uma "Seção Secundária"é um apêndice ou uma seção inicial do Documento que trata ex- clusivamente da relação dos editores ou dos autores do Documento com o assunto geral do Documento (ou assuntos relacionados) e não contém nada que poderia ser incluído diretamente nesse assunto geral (Por exemplo, se o Documento é em parte um livro texto de matemática, a Seção Secundária pode não explicar nada de matemática). Essa relação poderia ser uma questão de ligação histórica com o assunto, ou matérias relaci- onadas, ou de posições legais, comerciais, filosóficas, éticas ou políticas relacionadas ao mesmo. As "Seções Invariantes"são certas Seções Secundárias cujos títulos são designados, como sendo de Seções Invariantes, na nota que diz que o Documento é publicado sob esta Licença. Os "Textos de Capa"são certos trechos curtos de texto que são listados, como Textos de Capa Frontal ou Textos da Quarta Capa, na nota que diz que o texto é publicado sob esta Licença. Uma cópia "Transparente"do Documento significa uma cópia que pode ser lida automatica- mente, representada num formato cuja especificação esteja disponível ao público geral, cujos conteúdos possam ser vistos e editados diretamente e sem mecanismos especiais com editores de texto genéricos ou (para imagens compostas de pixels) programas de pintura genéricos ou (para desenhos) por algum editor de desenhos grandemente difundido, e que seja passível de servir como entrada a formatadores de texto ou para tradução automática para uma variedade de formatos que sirvam de entrada para formatadores de texto. Uma cópia feita em um formato de arquivo outrossim Transparente cuja constituição tenha sido projetada para atrapalhar ou de- sencorajar modificações subsequentes pelos leitores não é Transparente. Uma cópia que não é "Transparente"é chamada de "Opaca". Exemplos de formatos que podem ser usados para cópias Transparentes incluem ASCII sim- ples sem marcações, formato de entrada do Texinfo, formato de entrada do LaTex, SGML ou XML usando uma DTD disponibilizada publicamente, e HTML simples, compatível com os padrões, e projetado para ser modificado por pessoas. Formatos opacos incluem PostScript, PDF, formatos proprietários que podem ser lidos e editados apenas com processadores de texto proprietários, SGML ou XML para os quais a DTD e/ou ferramentas de processamento e edição não estejam disponíveis para o público, e HTML gerado automaticamente por alguns editores de texto com finalidade apenas de saída. A "Página do Título"significa, para um livro impresso, a página do título propriamente dita, mais quaisquer páginas subsequentes quantas forem necessárias para conter, de forma legível, o material que esta Licença requer que apareça na página do título. Para trabalhos que não tenham uma página do título, "Página do Título"significa o texto próximo da aparição mais proe- minente do título do trabalho, precedendo o início do corpo do texto. 12
- 14. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF FAZENDO CÓPIAS EXATAS Você pode copiar e distribuir o Documento em qualquer meio, de forma comercial ou não comercial, desde que esta Licença, as notas de copyright, e a nota de licença dizendo que esta Licença se aplica ao documento estejam reproduzidas em todas as cópias, e que você não acres- cente nenhuma outra condição, quaisquer que sejam, às desta Licença. Você não pode usar medidas técnicas para obstruir ou controlar a leitura ou confecção de cópias subsequentes das cópias que você fizer ou distribuir. Entretanto, você pode aceitar com- pensação em troca de cópias. Se você distribuir uma quantidade grande o suficiente de cópias, você também precisa respeitar as condições da seção 3. Você também pode emprestar cópias, sob as mesmas condições colocadas acima, e também pode exibir cópias publicamente. FAZENDO CÓPIAS EM QUANTIDADE Se você publicar cópias do Documento em número maior que 100, e a nota de licença do Documento obrigar Textos de Capa, você precisará incluir as cópias em capas que tragam, clara e legivelmente, todos esses Textos de Capa: Textos de Capa da Frente na capa da frente, e Textos da Quarta Capa na capa de trás. Ambas as capas também precisam identificar clara e legivelmente você como o editor dessas cópias. A capa da frente precisa apresentar o título com- pleto com todas as palavras do título igualmente proeminentes e visíveis. Você pode adicionar outros materiais às capas. Fazer cópias com modificações limitadas às capas, tanto quanto estas preservem o título do documento e satisfaçam a essas condições, pode ser tratado como cópia exata em outros aspectos. Se os textos requeridos em qualquer das capas for muito volumoso para caber de forma legível, você deve colocar os primeiros (tantos quantos couberem de forma razoável) na capa verdadeira, e continuar os outros nas páginas adjacentes. Se você publicar ou distribuir cópias Opacas do Documento em número maior que 100, você precisa ou incluir uma cópia Transparente que possa ser lida automaticamente com cada cópia Opaca, ou informar, em ou com, cada cópia Opaca a localização de uma cópia Transparente completa do Documento acessível publicamente em uma rede de computadores, à qual o público usuário de redes tenha acesso a download gratuito e anônimo utilizando padrões públicos de protocolos de rede. Se você utilizar o segundo método, você precisará tomar cuidados razoavel- mente prudentes, quando iniciar a distribuição de cópias Opacas em quantidade, para assegurar que esta cópia Transparente vai permanecer acessível desta forma na localização especificada por pelo menos um ano depois da última vez em que você distribuir uma cópia Opaca (direta- mente ou através de seus agentes ou distribuidores) daquela edição para o público. É pedido, mas não é obrigatório, que você contate os autores do Documento bem antes de redistribuir qualquer grande número de cópias, para lhes dar uma oportunidade de prover você com uma versão atualizada do Documento. 13
- 15. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF MODIFICAÇÕES Você pode copiar e distribuir uma Versão Modificada do Documento sob as condições das se- ções 2 e 3 acima, desde que você publique a Versão Modificada estritamente sob esta Licença, com a Versão Modificada tomando o papel do Documento, de forma a licenciar a distribuição e modificação da Versão Modificada para quem quer que possua uma cópia da mesma. Além disso, você precisa fazer o seguinte na versão modificada: A. Usar na Página de Título (e nas capas, se houver alguma) um título distinto daquele do Do- cumento, e daqueles de versões anteriores (que deveriam, se houvesse algum, estarem listados na seção "Histórico do Documento"). Você pode usar o mesmo título de uma versão anterior se o editor original daquela versão lhe der permissão; B. Listar na Página de Título, como autores, uma ou mais das pessoas ou entidades responsá- veis pela autoria das modificações na Versão Modificada, conjuntamente com pelo menos cinco dos autores principais do Documento (todos os seus autores principais, se ele tiver menos que cinco); C. Colocar na Página de Título o nome do editor da Versão Modificada, como o editor; D. Preservar todas as notas de copyright do Documento; E. Adicionar uma nota de copyright apropriada para suas próprias modificações adjacente às outras notas de copyright; F. Incluir, imediatamente depois das notas de copyright, uma nota de licença dando ao público o direito de usar a Versão Modificada sob os termos desta Licença, na forma mostrada no tópico abaixo; G. Preservar nessa nota de licença as listas completas das Seções Invariantes e os Textos de Capa requeridos dados na nota de licença do Documento; H. Incluir uma cópia inalterada desta Licença; I. Preservar a seção entitulada "Histórico", e seu título, e adicionar à mesma um item dizendo pelo menos o título, ano, novos autores e editor da Versão Modificada como dados na Página de Título. Se não houver uma sessão denominada "Histórico"no Documento, criar uma dizendo o título, ano, autores, e editor do Documento como dados em sua Página de Título, então adicionar um item descrevendo a Versão Modificada, tal como descrito na sentença anterior; J. Preservar o endereço de rede, se algum, dado no Documento para acesso público a uma cópia Transparente do Documento, e da mesma forma, as localizações de rede dadas no Docu- mento para as versões anteriores em que ele foi baseado. Elas podem ser colocadas na seção "Histórico". Você pode omitir uma localização na rede para um trabalho que tenha sido publicado pelo menos quatro anos antes do Documento, ou se o editor original da versão a que ela se refira der sua permissão; K. Em qualquer seção entitulada "Agradecimentos"ou "Dedicatórias", preservar o título da 14
- 16. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF seção e preservar a seção em toda substância e fim de cada um dos agradecimentos de contri- buidores e/ou dedicatórias dados; L. Preservar todas as Seções Invariantes do Documento, inalteradas em seus textos ou em seus títulos. Números de seção ou equivalentes não são considerados parte dos títulos da seção; M. Apagar qualquer seção entitulada "Endossos". Tal sessão não pode ser incluída na Versão Modificada; N. Não reentitular qualquer seção existente com o título "Endossos"ou com qualquer outro título dado a uma Seção Invariante. Se a Versão Modificada incluir novas seções iniciais ou apêndices que se qualifiquem como Seções Secundárias e não contenham nenhum material copiado do Documento, você pode optar por designar alguma ou todas aquelas seções como invariantes. Para fazer isso, adicione seus títulos à lista de Seções Invariantes na nota de licença da Versão Modificada. Esses títulos preci- sam ser diferentes de qualquer outro título de seção. Você pode adicionar uma seção entitulada "Endossos", desde que ela não contenha qual- quer coisa além de endossos da sua Versão Modificada por várias pessoas ou entidades - por exemplo, declarações de revisores ou de que o texto foi aprovado por uma organização como a definição oficial de um padrão. Você pode adicionar uma passagem de até cinco palavras como um Texto de Capa da Frente , e uma passagem de até 25 palavras como um Texto de Quarta Capa, ao final da lista de Textos de Capa na Versão Modificada. Somente uma passagem de Texto da Capa da Frente e uma de Texto da Quarta Capa podem ser adicionados por (ou por acordos feitos por) qualquer entidade. Se o Documento já incluir um texto de capa para a mesma capa, adicionado previamente por você ou por acordo feito com alguma entidade para a qual você esteja agindo, você não pode adicionar um outro; mas você pode trocar o antigo, com permissão explícita do editor anterior que adicionou a passagem antiga. O(s) autor(es) e editor(es) do Documento não dão permissão por esta Licença para que seus nomes sejam usados para publicidade ou para assegurar ou implicar endossamento de qualquer Versão Modificada. COMBINANDO DOCUMENTOS Você pode combinar o Documento com outros documentos publicados sob esta Licença, sob os termos definidos na seção 4 acima para versões modificadas, desde que você inclua na com- binação todas as Seções Invariantes de todos os documentos originais, sem modificações, e liste todas elas como Seções Invariantes de seu trabalho combinado em sua nota de licença. O trabalho combinado precisa conter apenas uma cópia desta Licença, e Seções Invariantes Idênticas com multiplas ocorrências podem ser substituídas por apenas uma cópia. Se houver múltiplas Seções Invariantes com o mesmo nome mas com conteúdos distintos, faça o título de 15
- 17. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF cada seção único adicionando ao final do mesmo, em parênteses, o nome do autor ou editor origianl daquela seção, se for conhecido, ou um número que seja único. Faça o mesmo ajuste nos títulos de seção na lista de Seções Invariantes nota de licença do trabalho combinado. Na combinação, você precisa combinar quaisquer seções entituladas "Histórico"dos diver- sos documentos originais, formando uma seção entitulada "Histórico"; da mesma forma combine quaisquer seções entituladas "Agradecimentos", ou "Dedicatórias". Você precisa apagar todas as seções entituladas como "Endosso". COLETÂNEAS DE DOCUMENTOS Você pode fazer uma coletânea consitindo do Documento e outros documentos publicados sob esta Licença, e substituir as cópias individuais desta Licença nos vários documentos com uma única cópia incluida na coletânea, desde que você siga as regras desta Licença para cópia exata de cada um dos Documentos em todos os outros aspectos. Você pode extrair um único documento de tal coletânea, e distribuí-lo individualmente sob esta Licença, desde que você insira uma cópia desta Licença no documento extraído, e siga esta Licença em todos os outros aspectos relacionados à cópia exata daquele documento. AGREGAÇÃO COM TRABALHOS INDEPENDENTES Uma compilação do Documento ou derivados dele com outros trabalhos ou documentos se- parados e independentes, em um volume ou mídia de distribuição, não conta como uma Ver- são Modificada do Documento, desde que nenhum copyright de compilação seja reclamado pela compilação. Tal compilação é chamada um "agregado", e esta Licença não se aplica aos outros trabalhos auto-contidos compilados junto com o Documento, só por conta de terem sido assim compilados, e eles não são trabalhos derivados do Documento. Se o requerido para o Texto de Capa na seção 3 for aplicável a essas cópias do Documento, então, se o Documento constituir menos de um quarto de todo o agregado, os Textos de Capa do Documento podem ser colocados em capas adjacentes ao Documento dentro do agregado. Senão eles precisarão aparecer nas capas de todo o agregado. TRADUÇÃO Tradução é considerada como um tipo de modificação, então você pode distribuir traduções do Documento sob os termos da seção 4. A substituição de Seções Invariantes por traduções requer uma permissão especial dos detentores do copyright das mesmas, mas você pode incluir traduções de algumas ou de todas as Seções Invariantes em adição às versões orignais dessas Seções Invariantes. Você pode incluir uma tradução desta Licença desde que você também in- clua a versão original em Inglês desta Licença. No caso de discordância entre a tradução e a 16
- 18. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF versão original em Inglês desta Licença, a versão original em Inglês prevalecerá. TÉRMINO Você não pode copiar, modificar, sublicenciar, ou distribuir o Documento exceto como expres- samente especificado sob esta Licença. Qualquer outra tentativa de copiar, modificar, sublicen- ciar, ou distribuir o Documento é nula, e resultará automaticamente no término de seus direitos sob esta Licença. Entretanto, terceiros que tenham recebido cópias, ou direitos de você sob esta Licença não terão suas licenças terminadas, tanto quanto esses terceiros permaneçam em total acordo com esta Licença. REVISÕES FUTURAS DESTA LICENÇA A Free Software Foundation pode publicar novas versões revisadas da Licença de Documen- tação Livre GNU de tempos em tempos. Tais novas versões serão similares em espirito à versão presente, mas podem diferir em detalhes ao abordarem novos porblemas e preocupações. Veja http://www.gnu.org/copyleft/. A cada versão da Licença é dado um número de versão distinto. Se o Documento especificar que uma versão particular desta Licença "ou qualquer versão posterior"se aplica ao mesmo, você tem a opção de seguir os termos e condições daquela versão específica, ou de qualquer versão posterior que tenha sido publicada (não como rascunho) pela Free Software Foundation. Se o Documento não especificar um número de Versão desta Licença, você pode escolher qualquer versão já publicada (não como rascunho) pela Free Software Foundation. ADENDO: Como usar esta Licença para seus documentos Para usar esta Licença num documento que você escreveu, inclua uma cópia desta Licença no documento e ponha as seguintes notas de copyright e licenças logo após a página de título: Copyright (c) ANO SEU NOME. É dada permissão para copiar, distribuir e/ou modificar este documento sob os termos da Licença de Documentação Livre GNU, Versão 1.1 ou qualquer versão posterior publicada pela Free Soft- ware Foundation; com as Seções Invariantes sendo LISTE SEUS TÍTULOS, com os Textos da Capa da Frente sendo LISTE, e com os Textos da Quarta-Capa sendo LISTE. Uma cópia da li- cença está inclusa na seção entitulada "Licença de Documentação Livre GNU". Se você não tiver nenhuma Seção Invariante, escreva "sem Seções Invariantes"ao invés de dizer quais são invariantes. Se você não tiver Textos de Capa da Frente, escreva "sem Textos de Capa da Frente"ao invés de "com os Textos de Capa da Frente sendo LISTE"; o mesmo para os Textos da Quarta Capa. Se o seu documento contiver exemplos não triviais de código de programas, nós recomenda- mos a publicação desses exemplos em paralelo sob a sua escolha de licença de software livre, 17
- 19. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF tal como a GNU General Public License, para permitir o seu uso em software livre. 18
- 20.
- 21. Capítulo 1 O queé a Linguagem Ruby A linguagem de programação Ruby, foi criada visando os interesses do programador. Tal linguagem tem diversas funcionalidades que facilitam na hora da programação. Isso faz com que o programador não tenha que se preocupar com coisas, que a própria linguagem é capaz de fazer. Isso pode não parecer tão claro. Mas no decorrer do curso, você verá como é útil a linguagem Ruby. 20
- 22. Capítulo 2 Plano deensino 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 que consiste 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 utilizada para o Ruby será a 1.8 2.5 Metodologia O curso está dividido da seguinte maneira: 2.6 Cronograma • Introdução, Instalação e Inicio; 21
- 23. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF • Conhecendo um pouco da linguagem, estruturas de controle e comentários do código e Noções de POO; • Classes, entradas e saídas. As lições contêm o conteúdo principal. Elas poderão ser acessadas quantas vezes forem ne- cessárias, desde que esteja dentro da semana programada. Ao final de uma lição, você receberá uma nota de acordo com o seu desempenho. Responda com atenção às perguntas de cada li- ção, pois elas serão consideradas na sua nota final. Caso sua nota numa determinada lição seja menor do que 6.0, sugerimos que você faça novamente esta lição. Ao final do curso será disponibilizada a avaliação referente ao curso. Tanto as notas das lições quanto a da avaliação serão consideradas para a nota final. Todos os módulos ficarão visíveis para que possam ser consultados durante a avaliação final. Aconselhamos a leitura da "Ambientação do Moodle"para que você conheça a plataforma de En- sino à Distância, evitando dificuldades advindas do "desconhecimento"sobre a mesma. Os instrutores estarão à sua disposição ao longo de todo curso. Qualquer dúvida deverá ser enviada ao fórum. Diariamente os monitores darão respostas e esclarecimentos. 2.7 Programa O curso de Linguagem Ruby oferecerá o seguinte conteúdo: • Introdução e Instalação; • Uso das ferramentas mais comuns. 2.8 Avaliação Toda a avaliação será feita on-line. Aspectos a serem considerados na avaliação: • Iniciativa e autonomia no processo de aprendizagem e de produção de conhecimento; • Capacidade de pesquisa e abordagem criativa na solução dos problemas apresentados. Instrumentos de avaliação: • Participação ativa nas atividades programadas; • Avaliação ao final do curso; • O participante fará várias avaliações referente ao conteúdo do curso. Para a aprovação e obtenção do certificado o participante deverá obter nota final maior ou igual a 6.0 de acordo com a fórmula abaixo: • Nota Final = ((ML x 7) + (AF x 3)) / 10 = Média aritmética das lições; • AF = Avaliações. 2.9 Bibliografia • Site official: http://www.ruby-lang.org 22
- 24. Capítulo 3 Introdução Ruby éuma linguagem de programação com uma tipagem dinâmica, mas forte. Possui grande semelhança com Perl e Python. Teve como criador o programador Yukihiro Matsumoto, também conhecido como Matz, na internet. Ao criá-la, Matz estava com a seguinte idéia: Criar uma linguagem mais orientada a objetos do que Python e mais poderosa que Perl. Foi projetada tanto para uma codificação rápida quanto para uma programação em grande escala e possui um suporte de orientação a objetos simples e prático, com uma sintaxe que facilita leitura e simplifica a escrita do código. Matz acreditava que o programador deveria se divertir ao realizar determinada tarefa, logo pensou justamente nisso para criar o Ruby. Vem sendo bastante utilizada pelo mundo e com uma lista de discussão bastante ativa, conhecida como ruby-talk. Vem também sendo erguida para uma linguagem de primeiro nível através do RubyOnRails. Diferente de Java e C++, linguagens também orientadas a objetos, o tipo de objeto em Ruby só é conhecido em runtime. Sua orientação a objetos é pura, ou seja, tudo é objeto, até mesmo os tipos mais básicos de variáveis. Um conceito fundamental na programação Ruby, como já foi mencionado é o conceito de orientação a objeto (comumente conhecida como Programação Orientada a Objeto ou POO). É, apesar disso, um conceito muito amplo que requer prática para que possa ser plenamente com- preendido. Nesta lição, introduziremos as noções básicas de POO para melhor aproveitamento e uso na linguagem Ruby. 3.1 Classes, Objetos e Métodos Classe é um aglomerado de métodos, funções e procedimentos com os quais acessamos e usamos os objetos, realizando tarefas específicas, e de variáveis, que definem o comportamento de um objeto que poderá vir a existir se a classe for solicitada para tal. Um objeto é uma enti- dade do mundo real que possui uma identidade. Podem ser entidades concretas ou conceituais. Podemos citar como exemplos de objetos: uma conta corrente, clientes, agências, arquivos no computador, bicicletas, lojas etc. Em termos de programação, pode-se definir objeto como o resultado da ação construtora de uma classe. Todo objeto é "fabricado"em uma classe, sendo por isso denominado instância da classe. Além disso, possuem outras características: a estrutura de objetos de uma certa classe é descrita por meio de atributos; objetos de uma mesma classe têm um mesmo comportamento que são representados pelo conjunto de operações que podem ser executadas sobre eles. O método de construção de objetos com a mesma "genética"da classe é chamado de método construtor. 23
- 25. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 3.2 Variaveis Variáveis de classe: há situações em que se deseja que todos os objetos compartilhem a mesma variável. O procedimento para realizar esse compartilhamento é a definição de variáveis de classe; Pacotes (Packages): conjunto organizado de classes e demais arquivos que estão relaciona- dos através de um propósito comum ou atuam com dependências entre si. São muito úteis e necessários na medida em que são usados para localizar o código da classe de forma eficiente. 3.3 Outro conceitos importantes • Encapsulamento: imprescindível ao entendimento de POO e ao aprendizado da liguagem Ruby, já que é indispensável para contribuir com a diminuição dos malefícios causados pela interferência externa sobre os dados. É uma técnica que consiste em ocultar no objeto algumas de suas variáveis (ou campos) e alguns de seus métodos. É importantíssimo na medida em que deixa o programa robusto, impedindo o acesso a certas partes de seu funcionamento; • Herança: outro conceito importante na POO é o conceito de herança, que significa que toda classe definida como uma subclasse de outra receberá automaticamente todo o conteúdo da classe-mãe. Tomamos como exemplo uma classe ’Pessoa’, onde possui como propri- edades: nome, endereço, telefone, cpf e etc. Incluímos a classe ’Pessoa’ em uma classe ’Funcionário’, dessa forma aproveitamos todas as propriedades de ’Pessoa’ e incluímos as propriedades específicas de ’Funcionário’, como: data de admissão, cargo, salário e etc; • Polimorfismo: um conceito mais difícil de ser entendido, porém não menos importante é o conceito de polimorfismo. Essa dificuldade decorre da amplitude desse conceito e de significados em POO. Suas variadas definições são: • Overloading: designa um tipo de polimorfismo em que podemos utilizar um nome igual para designar métodos diferentes que terão lista de parâmetros também diferentes. Isto tanto em número de parâmetros quanto em tipo. Os objetos de uma classe-mãe podem ser redefinidos por objetos das suas sub-classes. Variáveis podem assumir tipos diferentes ao longo da execução; • Visibilidade: através dos indicadores ’public’ e ’private’ algumas classes e métodos podem ser visíveis ou não. Os métodos e propriedades públicas serão a interface do objeto com o usuário; • Abstração: em termos de desenvolvimento, abstração significa concentrar-se no que um objeto é e faz antes de se decidir como ele será implementado. Significa representar as características essenciais de um tipo de dado sem incluir o mecanismo que concretiza a funcionalidade. A abstração é fundamental para conseguir uma boa modularização, que é uma técnica que tem a estratégia de ’dividir para conquistar’, ou seja, resolver um grande problema dividindo-o em vários problemas menores. Pergunta: Variáveis de classe é o conjunto organizado de classes e demais arquivos que estão relacionadas através de um propósito comum ou atuam com dependências entre si. São muito úteis e necessárias na medida em que são usadas para localizar o código da classe de forma eficiente. 24
- 26. Capítulo 4 Instalação eIní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 oficial http://www.ruby-lang.org e fazer o download para a plataforma específica. No entanto, o Debian possui uma ferramenta muito útil na instalação de determinados programas. Vamos utilzar tal ferramenta para instalar o Ruby: • 1 - Abra seu terminal; • 2 - entre como usuário root; • 3 - digite: apt-get install ruby Espere a instalação e pronto, você poderá trabalhar com o ruby normalmente. Nesse caso, teremos que utilizar um editor de texto (posso sugerir o gedit). Podemos ulilizar um programa muito bom do Ruby para ir testando o código, o irb (interactive Ruby shell) e com ele não é necessário o editor de texto. Esse programa será muito útil no início do curso. É bom que vocês o tenham instalado no seu computador. É possível fazer isso da mesma forma que foi instalado o Ruby: • 1 - Abra seu terminal; • 2 - entre como usuário root; • 3 - digite: apt-get install irb. Depois de ter feito tais comandos, o irb estará disponível para ser usado. 4.2 Início da Linguagem Como vimos anteriormente, um programa muito útil para nos familiarizarmos com a lingua- gem Ruby é o irb (interactive Ruby shell). Vamos conhecer um pouco mais dele. Basta digitar: irb no terminal. Pronto! É só começar a programar! Após digitar irb aparecerá no terminal: irb(main):001:0> Entre parênteses encontra-se o nome do programa que está sendo rodado; em seguida, de- pois do primeiro dois pontos, temos quantas linhas foram digitadas e em que linha estamos; 25
- 27. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF depois do segundo dois pontos, temos o nível de profundidade que estamos. Um exemplo de como funciona o irb: irb(main):001:0> puts "Apenas um teste" Apenas um teste => nil irb(main):002:0> Digite isso e 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 resultado da expressão que foi passada para ele quebrando uma linha. Um outro exemplo para demonstrar o nível de profundidade: irb(main):001:0> a = 100 => 100 irb(main):002:0> if a > 50 irb(main):003:1> puts "Numero maior que 50" irb(main):004:1> else! irb(main):005:1* puts "Numero menor que 50" irb(main):006:1> end Numero maior que 50 => nil irb(main):007:0> Observe o nível de profundidade alterando conforme o condicional é processado. Tais funcio- nalidades como "puts"e "if/else"serão abordadas com mais detalhes nas próximas lições. Observação: É importante que você vá executando o código no seu terminal para que seja melhor visualizado o que está sendo feito, principalemente na próxima lição onde estarão pre- sente muitos exemplos. Interessante seria também, se você alterasse o código, isto é, depois de entendido o que foi feito, tentar, você mesmo, fazer outro código com a função aprendida. 26
- 28. Capítulo 5 Conhecendo umpouco a linguagem 5.1 Variáveis Como vocês devem se lembrar, foi dito na introdução que a linguagem Ruby é 100% orientada a objetos, isto é, tudo em Ruby é objeto, no entanto, variáveis não são objetos e sim referências a esses. Em Ruby as variáveis são simples de serem utilizadas pois utilizam o "duck typing", a tipagem dinâmica da linguagem. Utilizando uma tipagem estática, temos como exemplo: irb(main):001:0> i = 10 => 10 irb(main):002:0> i.class => Fixnum irb(main):003:0> j = "alo" => "alo" irb(main):004:0> j.class => String irb(main):005:0> Depois de declarada a variável i, foi pedido para mostrar o valor do atributo "class"da variável, retornando Fixnum. Em seguida depois de atribuído o valor "alo"para a variável j, o comando j.class foi pedido para que fosse mostrado o valor do atributo, retornando String. Isso prova que tudo em Ruby é objeto. Foi dito também na introdução que a linguagem Ruby tem uma tipagem forte, um exemplo disso é: irb(main):001:0> a = "teste" => "teste" irb(main):002:0> b = 10 => 10 irb(main):003:0> resultado = a+b TypeError: can't convert Fixnum into String from (irb):3:in `+' from (irb):3 from :0 irb(main):004:0> 27
- 29. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF logo, não é uma boa idéia "misturar"os tipos. Em Ruby, para declararmos uma variável no escopo privado é bastante simples, basta fazer: irb(main):001:0> a = 2 => 2 irb(main):002:0> puts a 2 => nil irb(main):003:0> O sinal de igual é utilizado para atribuir um determinado valor para a variável. Agora, para declarar um variável pública, deve-se fazer o seguinte: irb(main):001:0> $i = 2 => 2 irb(main):002:0> Colocando o "$"antes da variável, faz com que a variável torne-se pública. 5.2 Tipos Básicos A linguagem Ruby apresenta uma ferramenta essencial denominada BLOCOS DE CÓDIGO. Isso, nada mais é do que "pedaços"de códigos que podem ser delimitados por: (chaves), quando o bloco possui apenas uma linha ou começa com DO e termina com END, quando o bloco de có- digo tiver mais de uma linha. Por convenção, as chaves são ultilizadas para códigos menores, ou seja, que possuem apenas uma linha. Já o do...end é usado para códigos maiores. Um exemplo para os tais blocos são: Usando chaves {puts "Apenas um teste"} (Utilizando as chaves para blocos menores) Usando do..end do puts "Apenas um teste" puts "Entendeu?" (Utilizando do..end para blocos maiores) end O trabalho com blocos de códigos funciona da seguinte maneira: um argumento é passado para o bloco, onde passará por alguma condição. Mais para frente você verá a utilidade dos blocos do código. Mas será mostrado aqui um exemplo: irb(main):003:0> nome.sort_by{|a1| a1.length} Passou-se um bloco como parâmetro para o método sort_by. Dentro do bloco, passamos o argumento a1 para o bloco que retorna o tamanho de uma string. Tal comando é para ordenar um array por ordem de tamanho das strings que compõem o array. Nesse momento pode haver alguma confusão, já que não vimos strings nem muito menos arrays. Mais para frente as dúvidas serão esclarecidas. Na parte de números, as variáveis podem assumir valores inteiros (Fixnum/Bignum) ou de pontos flutuantes (Float). Eis aqui alguns exemplos de inteiro: 28
- 30. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF irb(main):001:0> a = 1 => 1 irb(main):002:0> b = -30 => -30 irb(main):003:0> c = 3000000 => 3000000 Experimente fazer os comandos acima, e logo depois mostrar o tipo de cada variável (Lembra- se ainda como faz? Caso não se lembre, é: puts a.class). Feito isso, atribua o valor 10_000_000_000 (como não podemos usar vírgulas ) para alguma variável e utilize o comando para mostrar o tipo de cada variável. O que você percebeu? Que o tipo mudou para Bignum, ou seja, a última variável, a qual você atribuiu esse imenso valor, não coube no Fixnum e foi alterado automaticamente para Bignum. Tal artifício é característico da linguagem. Alguns exemplos de pontos flutuantes: irb(main):008:0> x = 1.23 => 1.23 irb(main):009:0> y = -32.43 => -32.43 irb(main):010:0> x.class => Float irb(main):011:0> y.class => Float irb(main):012:0> Exitem também em Ruby, as constantes, que são variáveis iniciadas com letras maiúsculas. Isso pode causar alguma confusão mais para frente, quando tratarmos do assunto relacionado a classes, já que, veremos que elas também são iniciadas com letras maiúsculas. Mas perceba a praticidade: irb(main):001:0> Fi = 1.61803 => 1.61803 irb(main):002:0> Fi = 23 (irb):2: warning: already initialized constant Fi => 23 irb(main):003:0> Como pode ser comprovado, foi declarada a variável Fi(?), que é o número áureo, no entanto, quando tentou-se mudar o seu conteúdo, surgiu o alerta falando que a variável não poderia ser alterada já que se trata de uma constante. Porém, na linguagem Ruby, é possível alterar o valor de uma constante. Mas altera gerando um warning! Como em todas as linguagens de programação, não podia faltar em Ruby os Booleanos, isto é, valores true ou false que algumas variáveis podem assumir. Podemos aproveitar e falar também do nil, valor nulo que pode ser atribuído a uma determi- nada variável. Tanto nil quanto o false, são os únicos valores que podem indicar falso. No entanto, eles podem pertencer a classes diferentes ou ter comportamentos diferentes. Isso pode ser comprovado com o seguinte código: irb(main):001:0> v = true 29
- 31. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF => true irb(main):002:0> puts v.class TrueClass => nil irb(main):003:0> f = false => false irb(main):004:0> f.class => FalseClass irb(main):005:0> n = nil => nil irb(main):006:0> n.class => NilClass irb(main):007:0> Depois dos booleanos, um dos tipos mais comuns também nas linguagens de programação e, logicamente, presente em Ruby são as Strings, que nada mais são do que um tipo que armazena "palavras"ou um conjunto de palavras. Um exemplo: irb(main):001:0> p1 = "Teste" => "Teste" irb(main):002:0> p2 = "Teste2" => "Teste2" irb(main):003:0> p3 = "Uma frase" => "Uma frase" irb(main):004:0> p1.class => String irb(main):005:0> p2.class => String irb(main):006:0> p3.class => String irb(main):007:0> Como em outras linguagens, a manipulação de strings pode ser feita da seguinte forma: usando [] (colchetes) com um índice no interior. Para visualizar isso, eis um exemplo: irb(main):001:0> palavra = "animal" => "animal" irb(main):002:0> palavra[0] = "b" => "b" irb(main):003:0> puts palavra bnimal => nil irb(main):004:0> Explicando o que foi feito acima: primeiro atribuímos para a variável "palavra"uma string; logo depois alteramos o valor da primeira posição da string (no caso o índice zero) trocando o caractere "a"pelo caractere "b"e imprimimos a nova string. Para criarmos strings grandes, no caso um texto, podemos usar uma ferramenta denominada heredoc, a qual funciona da seguinte forma: 30
- 32. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF irb(main):001:0> texto = <<INICIO irb(main):002:0" Começa aqui o teste irb(main):003:0" para mostrar irb(main):004:0" como funciona o heredoc irb(main):005:0" INICIO => "Come303247a aqui o testenpara mostrarncomo funciona o heredocn" irb(main):006:0> puts texto Começa aqui o teste para mostrar como funciona o heredoc => nil irb(main):007:0> Nesse exemplo, foi usado o "INICIO"depois do «, para delimitar o início e fim da string. Ou seja, você que determina a palavra que será usada para demarcar o texto ou a "string grande". Faça um teste você mesmo, utilize qualquer palavra para a delimitação do texto. Observação: foi utilizada a palavra delimitadora de string em caixa alta unicamente para me- lhorar a visualização do código, isto é, para não causar confusão na hora de analisar o código digitado. Falemos agora sobre como ocorre a concatenação(união) de strings. Utiliza-se os seguintes operadores: "+="ou «<"(sem as aspas). Como pode ter sido observado, essa sessão baseia-se em exemplos para que se entenda melhor como funciona determinada função. Então aqui vão mais dois exemplos: O primeiro exemplo é para mostrar como funciona o operador «<": irb(main):001:0> t1 = "Mudando de exemplo" => "Mudando de exemplo" irb(main):002:0> t1 << ", diferente de 'teste'" => "Mudando de exemplo, diferente de 'teste'" irb(main):003:0> puts t1 Mudando de exemplo, diferente de 'teste' => nil irb(main):004:0> O segundo exemplo é para mostrar como funciona o operador "+=": irb(main):001:0> t1 = "Outro exemplo" => "Outro exemplo" irb(main):002:0> t1 += ", diferente de 'teste'" => "Outro exemplo, diferente de 'teste'" irb(main):003:0> puts t1 Outro exemplo, diferente de 'teste' => nil irb(main):004:0> Basicamente é isso que precisamos saber de string. Mais para frente, quando começarmos a aprofundar o curso falando sobre orientação a objetos, serão mostradas algumas funções novas. Existem também em Ruby os intervalos denominados Ranges. Eles são declarados da se- guinte forma: 31
- 33. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF irb(main):001:0> i1 = 0..5 => 0..5 irb(main):002:0> i2 = 0...5 => 0...5 irb(main):003:0> O intervalo i1 vai conter números de zero até cinco. Já, o intervalo i2 irá conter os números de zero até 4. Isso ocorre devido a adição de mais um ponto, fazendo com que o intervalo seja fechado em zero e aberto em 5, ou seja, inclui o zero e não inclui o cinco. Vamos falar agora um pouco sobre os operadores do Ruby. Muitos deles são bastante conhe- cidos por você. - começando pelas quatro operações fundamentais da aritmética: +, - , / , * , respectivamente, adição, subtração, divisão e multiplicação; - temos também os operadores: ** , % , que indi- cam exponenciação e módulo (vimos esse operador no exemplo para criar 2 arrays sob algumas condições); - temos os operadores de comparação: > ,< , >= , <= , respectivamente, maior, me- nor, maior igual, menor igual; - comparador de igualdade: ==; - and e or que são utilizados nas estruturas de controle (Veremos isso na próxima lição). Os operadores serão melhor compreendidos no decorrer desta lição, visto que serão dados exemplos. Não poderia faltar nessa sessão os arrays, bastante conhecidos em várias linguagens de programação. Eles podem conter vários tipos de objetos. Exemplo: irb(main):001:0> v = [’mais’,’exemplos’,100] => ["mais", "exemplos", 100] irb(main):002:0> puts v mais exemplos 100 => nil irb(main):003:0> puts v[2] 100 => nil irb(main):004:0> Observe o uso de [] (colchetes) para atribuir os objetos ao array "v"e as vírgulas que separam cada termo do array. Veja também como faz para mostrar o conteúdo utilizando índices. Existe um atalho bastante útil quando trabalhamos com arrays com apenas strings, é o %w. Esse atalho funciona da seguinte forma: irb(main):001:0> v = %w(caneta lapis apontador regua) => ["caneta", "lapis", "apontador", "regua"] irb(main):002:0> Caso queira usar uma string "composta"(com mais de uma palavra) como no exemplo abaixo, basta utilizar o caractere "¨(sem as aspas). irb(main):001:0> v1 = %w(cachorro gato colhe tigre dente de sabre) => ["cachorro", "gato", "colhe", "tigre dente de sabre"] irb(main):002:0> Observação: Perceba que houve uma pequena diferença quando utilizamos o atalho %w. Houve a utilização de parênteses ao invés de colchetes. Vimos como montar um array a partir do nada. Agora, como faríamos para adicionar elemen- tos a um array já existente? Basta utilizar o push ou o operador « (olha ele aí de novo, faz sentido já que uma string é um vetor de caractere). Mais um exemplo: irb(main):001:0> v = %w(azul vermelho) => ["azul", "vermelho"] irb(main):002:0> v.push "laranja" 32
- 34. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF => ["azul", "vermelho", "laranja"] irb(main):003:0> v.push "amarelo" => ["azul", "vermelho", "laranja", "amarelo"] A partir daqui utilizou-se o operador «<"(sem aspas) aproveitando o mesmo array. irb(main):004:0> v << "preto" => ["azul", "vermelho", "laranja", "amarelo", "preto"] irb(main):005:0> v << "roxo" => ["azul", "vermelho", "laranja", "amarelo", "preto", "roxo"] irb(main):006:0> Observação: Lembram-se quando foi dado o exemplo dos blocos de código no início desta lição? Então, a partir daqui talvez fique mais claro o que foi dito. Um mecanismo muito interessante em Ruby para a manipulação de arrays é o seguinte: dado um determinado array, queremos criar um outro a partir de uma determinada condição depois de tê-lo processado. Veja o exemplo abaixo: irb(main):001:0> v1 = [10,11,12,13,14,15] => [10, 11, 12, 13, 14, 15] irb(main):002:0> v2 = v1.find_all{|par| par%2 == 0}.map{|par| par*3} => [30, 36, 42] irb(main):003:0> Foi feito o seguinte: o método 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 os elementos que foram processados com o seu valor triplicado. A ordenação de array pode ser feita utilizando o método sort. Ou seja: irb(main):001:0> v = %w(arnaldo zeca bruno michele andrea) => ["arnaldo", "zeca", "bruno", "michele", "andrea"] irb(main):002:0> v.sort => ["andrea", "arnaldo", "bruno", "michele", "zeca"] irb(main):003:0> Outra forma seria utilizando o sort_by. Ele ordena o array a partir de uma determinada propri- edade do valor que está sendo avaliado. Veja: Ordenação por ordem alfabética analisando a primeira letra da string. irb(main):001:0> nome = ["zeca","amanda","beto","carla"] => ["zeca", "amanda", "beto", "carla"] irb(main):002:0> nome.sort_by{|a1| a1[0]} => ["amanda", "beto", "carla", "zeca"] A ordenação aqui foi por ordem crescente de tamanho da string utilizando o length. irb(main):003:0> nome.sort_by{|a1| a1.length} => ["zeca", "beto", "carla", "amanda"] irb(main):004:0> 33
- 35. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 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 determinado bloco retornando true ou false. Exemplo: irb(main):001:0> numero = [1,2,3,4,5] => [1, 2, 3, 4, 5] irb(main):002:0> numero.any?{|teste| teste > 3} => true irb(main):003:0> numero.any?{|teste| teste > 5} => false irb(main):004:0> Agora, para testar se todos os elementos do array se encaixam na condição de um determi- nado bloco, utilizamos o método all?. Eis outro exemplo: irb(main):001:0> numero = [101,230,300,1000] => [101, 230, 300, 1000] irb(main):002:0> numero.all?{|teste2| teste2 > 100} => true irb(main):003:0> numero.all?{|teste2| teste2 > 1000} => false irb(main):004:0> Veja agora uma ferramenta muito interessante. Trata-se da criação de dois arrays a partir de um outro array baseado na condição de um determinado bloco de código. Tal método denomina- se partition. Exemplo: irb(main):001:0> vetor1 = [1,2,3,4,5,6,7,8,9,10] => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] irb(main):002:0> par,impar = vetor1.partition{|ex| ex%2 == 0} => [[2, 4, 6, 8, 10], [1, 3, 5, 7, 9]] irb(main):003:0> par => [2, 4, 6, 8, 10] irb(main):004:0> impar => [1, 3, 5, 7, 9] irb(main):005:0> puts par 2 4 6 8 10 => nil irb(main):006:0> puts impar 1 3 5 7 9 => nil irb(main):007:0> 34
- 36. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF Perceba o que foi feito no código acima: • primeiro, foram atribuídos à variável vetor1 os números de 1 a 10, como foi feito em diversos exemplos acima; • depois dois novos arrays receberam novos elementos a partir da condição especificada pelo bloco, que no caso, será escolher os elementos que são pares; • mas esse método funciona fazendo com que o primeiro array receba os elementos da con- dição e o segundo array recebe os elementos que não satisfazem à condição; • depois foi pedido para mostrar os dois arrays com seus respectivos elementos, o que já foi dito bem no início do curso como faz. Depois de mostrado como são os arrays na linguagem Ruby, vamos falar um pouco de Hashes. Aqui não haverá muito o que falar, pois, hashes são arrays com índices que você mesmo define para seus elementos. Tais índices podem ser: strings, inteiros (Fixnum) ou até mesmo símbolos (será tratado em seguida). Veja do que se trata os hashes pelos seguintes exemplos: Utilizando strings irb(main):001:0> hashe = {"p"=>"primeiro elemento","s"=>"segundo elemento"} => {"p"=>"primeiro elemento", "s"=>"segundo elemento"} irb(main):002:0> hashe["s"] => "segundo elemento" Utilizando inteiros (Fixnum) irb(main):003:0> hashe2 = {1=>"teste1",2=>"teste2"} => {1=>"teste1", 2=>"teste2"} irb(main):004:0> hashe2[1] => "teste1" irb(main):005:0> Utilizando Símbolos irb(main):005:0> hash3 = {:primeiro=>"elemento1", :segundo=>"elemento2"} => {:primeiro=>"elemento1", :segundo=>"elemento2"} irb(main):006:0> hash3[:segundo] => "elemento2" irb(main):007:0> Deve ter ficado alguma dúvida quanto aos símbolos mencionados acima. Símbolos nada mais são que pequenas strings que representam sempre o mesmo objeto. Podem representar nomes ou Strings dentro do interpretador Ruby. São criados colocando “:“ dois pontos) na frente do nome, como foi feito para definir os índices dos hashes acima: • :primeiro; • :segundo. 35
- 37. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 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ão a utilidade da linguagem Ruby , uma vez que, como já foi dito diversas vezes e não custa nada falar de novo, ela é 100% orientada a objetos. Portanto Até lá veremos o que acontece de comum entre as linguagens. Para declaramos um método basta iniciá-lo com defnome do metodo...end (parecido com a declaração de um bloco de código). Um exemplo para visualizar o que foi dito: irb(main):001:0> def testando irb(main):002:1> puts "veja o que acontece quando chamamos um metodo" irb(main):003:1> end => nil irb(main):004:0> testando veja o que acontece quando chamamos um metodo => nil irb(main):005:0> Os métodos também retornam valores que podem ser de 2 formas: com o return ou sem o return, nesse caso, o valor retornado pelo método é a última expressão avaliada. Veja o exemplo: Com o return: irb(main):001:0> def divide(x1,x2) irb(main):002:1> return x1/x2 irb(main):003:1> end => nil irb(main):004:0> divide(12,3) => 4 irb(main):005:0> Sem o return: irb(main):001:0> def divide(x1,x2) irb(main):002:1> x1/x2 irb(main):003:1> end => nil irb(main):004:0> divide(36,6) => 6 irb(main):005:0> Foi simples o que foi feito aqui: criamos um método chamado "divide"quem tem dois argumen- tos. Dentro do método foi colocada a expressão. Feito isso, chamamos o método e passamos dois valores para seus argumentos, fazendo com que retorne o resultado da expressão avaliada. Os métodos podem retornar também mais de um resultado. Na verdade, é retornado apenas um objeto, no entanto, dá a impressão que são vários. Exemplo: irb(main):001:0> def multiplos[[no]] irb(main):002:1> (1..4).map{|x|x*n} irb(main):003:1> end 36
- 38. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF => nil irb(main):004:0> multiplos(3) => [3, 6, 9, 12] irb(main):005:0> a,b,c,d = multiplos(3) => [3, 6, 9, 12] irb(main):006:0> puts "Os multiplos de 3 são: #{a},#{b},#{c},#{d}" Os multiplos de 3 são: 3,6,9,12 => nil irb(main):007:0> Entendendo o código: criamos um método que calcula os quatros primeiros múltiplos de um certo número. Vemos isso pelo intervalo que foi imposto no método, no caso o 4. No método map, criamos um array com a condição passada pelo bloco, no caso o x*n. Depois, chamamos o método e passamos um valor para seu argumento. Logo após esses procedimentos, pedimos a impressão dos múltiplos do número passado para o método, no caso, o 3. Com isso, foi mostrado os quatro primeiros múltiplos de 3. Ainda em métodos, uma das funcionalidades que podem ser utilizadas é o passagem de um bloco como parâmetro para o método. Para isso, utilizamos o método yield. Veja como isso é feito: irb(main):001:0> def multiplica(a1,b1) irb(main):002:1> yield(a1,b1) irb(main):003:1> end => nil irb(main):004:0> multiplica(3,4){|x1,x2|x1*x2} => 12 irb(main):005:0> Há também, uma maneira de testar se o bloco foi passado ao método. Para isso utilizamos o block_given como mostrado abaixo: irb(main):001:0> def multiplica(a1,b1) irb(main):002:1> if block_given? irb(main):003:2> yield(a1,b1) irb(main):004:2> else irb(main):005:2* puts " Bloco nao passado para o metodo!" irb(main):006:2> end irb(main):007:1> end => nil irb(main):008:0> multiplica(2,7){|x1,x2| x1*x2} => 14 irb(main):009:0> multiplica(3,5){|x1,x2| x1*x2} => 15 irb(main):010:0> multiplica(3,5) Bloco nao passado para o metodo! => nil irb(main):011:0> 37
- 39. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF Observação: os parâmetros são enviados como cópia da referência de um objeto, portanto, se alterarmos o objeto que foi passado como parâmetro, dentro do método, o objeto será alterado fora do método também. Existem diferentes tipos de métodos. São eles: métodos destrutivos e métodos predicados. Os métodos destrutivos são aqueles que têm uma "!"(sem aspas) logo depois do nome. Isso faz com que o conteúdo do próprio objeto seja alterado na sua posição de memória. Já, os métodos predicados são aqueles que têm um "?"(sem aspas) logo após o nome. Esses méto- dos retornam true ou false e são úteis para testar uma condição. Veja exemplos dos métodos mencionados. Um exemplo de método destrutivo: irb(main):001:0> t = "Ola, apenas um teste" => "Ola, apenas um teste" irb(main):002:0> t.object_id => -605661358 irb(main):003:0> def caps(t) irb(main):004:1> t.upcase! irb(main):005:1> end => nil irb(main):006:0> caps(t) => "OLA, APENAS UM TESTE" irb(main):007:0> t.object_id => -605661358 irb(main):008:0> Perceba que a posição de memória permanece a mesma. Método predicado: irb(main):001:0> teste = %w(hd monitor gabinete mouse) => ["hd", "monitor", "gabinete", "mouse"] irb(main):002:0> teste.include? "hd" => true irb(main):003:0> teste.include? "teclado" => false irb(main):004:0> O código consiste em dizer se uma certa palavra pertence ao array. Depois do que foi dito, nada mais aceitável do que ver como funciona tudo em um mesmo programa. Por exemplo, testaremos o escopo das variáveis dentro de um método: irb(main):001:0> $t = "a" => "a" irb(main):002:0> t = "b" => "b" irb(main):003:0> def apenas_teste irb(main):004:1> puts $t irb(main):005:1> puts t irb(main):006:1> end => nil 38
- 40. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF irb(main):007:0> apenas_teste a NameError: undefined local variable or method `t' for main:Object from (irb):5:in `apenas_teste' from (irb):7 from :0 irb(main):008:0> Perceba que atribuímos à variável pública (lembre-se que a variável é pública quando possui o "$"(sem aspas) antes do nome) o caractere "a"e à varíavel privada o caractere "b". Criamos o método e no seu interior, pedimos que fosse impresso na tela as duas variáveis. Logo após chamamos o método. A primeira variável foi impressa, por ser pública. No entanto a segunda variável não pode ser impressa. Isso ocorreu porque a segunda variável é privada, ou seja, não pode ser acessada pelo método criado, ao contrário da variável pública. Vamos ver agora um pouco de Ranges e blocos interagindo. As Ranges possuem um método denominado each, que trabalha da seguinte forma: para cada valor da Range, o bloco tal é executado. Veja o exemplo: irb(main):001:0> r = 0..4 => 0..4 irb(main):002:0> r.class => Range irb(main):003:0> r.each{puts "Apenas outro teste"} Apenas outro teste Apenas outro teste Apenas outro teste Apenas outro teste Apenas outro teste => 0..4 irb(main):004:0> Perceba que o bloco que contém o "puts"foi executado cinco vezes, ou seja, o intervalo da Range. Vamos agora, passar vários argumentos para o bloco usando uma Hash. Exemplo: irb(main):001:0> hs = {1=>"primeiro",2=>"segundo"} => {1=>"primeiro", 2=>"segundo"} irb(main):002:0> hs.each{|i,j| puts "indice:"+i.to_s+" valor:"+j.to_s} indice:1 valor:primeiro indice:2 valor:segundo => {1=>"primeiro", 2=>"segundo"} irb(main):003:0> O mesmo vale para os arrays. Exemplo: irb(main):001:0> vetor = %w(primeira posicao segunda posicao) => ["primeira posicao", "segunda posicao"] irb(main):002:0> vetor.each{|i| puts "Veja a: "+i.to_s} Veja a: primeira posicao 39
- 41. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF Veja a: segunda posicao => ["primeira posicao", "segunda posicao"] irb(main):003:0> Uma ferramenta interessante é a concatenação de métodos. Por exemplo, vamos concatenar o sort e o each: irb(main):001:0> vetor = %w(casa predio escritorio apartamento) => ["casa", "predio", "escritorio", "apartamento"] irb(main):002:0> vetor.sort.each{|j| puts "Depois de ordenado: "+j.to_s} Depois de ordenado: apartamento Depois de ordenado: casa Depois de ordenado: escritorio Depois de ordenado: predio => ["apartamento", "casa", "escritorio", "predio"] irb(main):003:0> 40
- 42. Capítulo 6 Estruturas deControle e Comentários no Código As estruturas de controle, como o próprio nome diz, controlam as estruturas criadas. São elas: as condicionais e os loops. 6.1 Condicionais Vamos começar com as condicionais. 6.1.1 If/Else Se você tem uma noção de programação, você deve estar habituado ao famoso if/else. Fun- ciona da seguinte forma: if...end ou, if...else...end. Com os exemplos a visualização será melhor. Ex1: irb(main):001:0> texto = "palavra" => "palavra" irb(main):002:0> if texto == "palavra" irb(main):003:1> puts "O valor foi atribuído corretamente" irb(main):004:1> end O valor foi atribuído corretamente => nil irb(main):005:0> Ex2: irb(main):001:0> numero = 100 => 100 irb(main):002:0> if numero > 10 irb(main):003:1> puts "O numero é maior que 10" irb(main):004:1> else irb(main):005:1* puts "o numero é menor que 10" irb(main):006:1> end 41
- 43. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF O numero é maior que 10 => nil irb(main):007:0> Existe também o elsif, é muito intuitivo, mas mesmo assim, vamos mostrar um exemplo: irb(main):001:0> valor = 5 => 5 irb(main):002:0> if valor > 5 irb(main):003:1> puts "Numero maior que cinco" irb(main):004:1> elsif valor == 5 irb(main):005:1> puts "Numero igual a cinco" irb(main):006:1> else irb(main):007:1* puts "Numero menos que cinco" irb(main):008:1> end Numero igual a cinco => nil irb(main):009:0> 6.1.2 Case Uma condicional extremante útil é o case. Você primeiramente atribui um valor para uma variável; depois o valor servirá como uma condicional para entrar em alguma das ações. Ele é mais utilizado quando você programa primeiramente com um editor de texto, quando você pede ao usuário que forneça um valor. A partir daí, você cria blocos com as condições possíveis que o usuário possa digitar. Vamos mostrar apenas o básico, sem o editor de texo. Mais para frente mostraremos programas que utilizam um editor de texto e é executado no terminal. Exemplo de case: irb(main):001:0> opcao = 3 => 3 irb(main):002:0> case opcao irb(main):003:1> when 0..10 irb(main):004:1> puts "A opcao está entre 0 e 10" irb(main):005:1> when 10..20 irb(main):006:1> puts "A opcao esta entre 10 e 20" irb(main):007:1> else irb(main):008:1* puts "Nao esta em nenhum dos intervalos" irb(main):009:1> end A opcao está no entre 0 e 10 => nil irb(main):010:0> Usamos um range (intervalo, está lembrado?) aqui para demonstrar a utilização do case. Geralmente é feito sempre: case (variavel)...when...else...end. 42
- 44. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 6.2 Loops Quando temos diversas atividades a serem digitadas como uma forma de repetição, podemos utilizar um comando que "faz"essas repetições para você. São os chamados Loops. 6.2.1 While Vamos começar falando do loop while. Primeiramente temos um determinado valor que con- trolará o while, isto é, o número de repetições que o while fará. No interior do while, é colocado o comando e um contador para que o loop termine. Veja o exemplo: irb(main):001:0> contador = 0 => 0 irb(main):002:0> while contador < 4 irb(main):003:1> puts contador irb(main):004:1> contador += 1 irb(main):005:1> end 0 1 2 3 => nil irb(main):006:0> Observação: Você deve ter estranhado o comando "+=". Tal comando incrementa o valor da variável. Analogamente, temos um comando decrementador que é: -="(Sem as aspas) 6.2.2 for Um outro tipo de loop é o for. Veja o exemplo para ver como ele é chamado: irb(main):001:0> for cont in (0..3) irb(main):002:1> puts "teste" irb(main):003:1> end teste teste teste teste => 0..3 irb(main):004:0> Veja que temos um contador novamente chamado "cont"e um intervalo a ser percorrido, no caso uma range, como no comando while, existe para determinar o número de repetições preten- didas. E no seu interior foi determinado o comando que será repetido, no caso, a impressão da string "teste". 43
- 45. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 6.2.3 until Uma variante do while é o until. Veja um exemplo: irb(main):001:0> cont = 0 => 0 irb(main):002:0> until cont == 5 irb(main):003:1> puts "executa" irb(main):004:1> cont += 1 irb(main):005:1> end executa executa executa executa executa => nil irb(main):006:0> Podemos utilizar o begin junto com o while e until da seguinte forma: Utilizando o while e until. irb(main):001:0> cont1 = 0 => 0 irb(main):002:0> begin irb(main):003:1* puts cont1 irb(main):004:1> cont1 += 1 irb(main):005:1> end while cont1 < 5 0 1 2 3 4 => nil irb(main):006:0> begin irb(main):007:1* puts cont1 irb(main):008:1> cont1 -= 1 irb(main):009:1> end until cont1 == 0 5 4 3 2 1 => nil irb(main):010:0> Perceba que, como o loop encontra-se no 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 valor impresso é o 5. 44
- 46. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 6.3 Comentando o Código Para finalizar essa lição, vamos falar sobre comentários de código. Tais comentários, são muito importantes, porque explica o que você está no seu código, facilitando a compreensão do mesmo. Pode ser feito de duas formas: • Utilizando "#"(sem aspas) para comentários com apenas uma linha (veja ex1); • utilizando =begin...=end para comentários com mais linhas (veja ex2). Veja alguns exemplo: Ex1: irb(main):001:0> def veja_o_teste irb(main):002:1> puts "veja como funciona um comentario" irb(main):003:1> end # O comentario nao e executado => nil irb(main):004:0> veja_o_teste veja como funciona um comentario => nil irb(main):005:0> Ex2: irb(main):001:0> def loops(cont) irb(main):002:1> begin irb(main):003:2* puts "Imprima isso" irb(main):004:2> cont += 1 irb(main):005:2> end while cont < 3 irb(main):006:1> end => nil irb(main):007:0> loops(0) Imprima isso Imprima isso Imprima isso => nil irb(main):008:0> =begin irb(main):009:0= veja como funciona irb(main):010:0= um codigo de varias linhas irb(main):011:0>= =end irb(main):012:0> 45
- 47. Capítulo 7 Classes Finalmente chegamosà etapa do curso que realmente interessa no Ruby, que a parte de Orientação a objetos. Depois da breve noção de OO (Orientação a objetos) abordada na lição anterior, iremos aprofundar bem esse tópico com essa lição. Iremos utilizar agora também, o tão esperado editor de texto(sugerido no início do curso, o gedit) e deixar um pouco de lado o irb. Lembram-se no início do curso, que foi pedido que se instalasse o Ruby e posteriormente o irb a 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 no terminal da seguinte forma: Depois de escrito o código, salve-o como ’nome do arquivo’.rb. Um exemplo: digamos que você tenha criado um arquivo com nome de Cachorro. Você deverá salvar como: Cachorro.rb. Feito isso, você irá abrir o terminal e digitar: ruby Cachorro.rb Para esta lição, vamos criar a classe Carro.rb no editor de texto: class Carro def initialize(marca,modelo,cor) @marca = marca @modelo = modelo @cor = cor end end corsa = Carro::new("GMC","Corsa","Vermelho") puts corsa 7.1 Variáveis de Instância Vamos agora analisar o que foi feito aqui. Você deve estar com muitas dúvidas, uma vez que apareceram diversas coisas novas, tais como: initialize, @ e ::new. Vamos falar agora sobre as variáveis de instância. e as novidades que apareceram no exemplo para construir uma classe: • initialize é um método utilizado em Ruby como construtor de classes. O que está entre parênteses são os parâmetros utilizados pelas variáveis de instância; • O "@"é utilizado para definir variáveis de instância, como foi visto, basta colocar @<nome da variável> ; 46
- 48. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF • new é um método de classe, por isso que foi chamado com "::". Depois disso, criamos a variável corsa, com as respectivas características e pedimos para mostrar seu conteúdo utilizando o puts. Aparecendo: #<Carro:0xb7d15954>. Apareceu isso, pois foi pedido para mostrar um objeto. Para que apareça as características do carro, é preciso utilizar o "to_s"para converter objetos em strings, como visto em lições anteriores. Para isso, criaremos o método to_s. Veja um exemplo a seguir: class Carro def initialize(marca,modelo,cor) @marca = marca @modelo = modelo @cor = cor end def to_s "marca: #{@marca}, modelo: #{@modelo}, cor: #{@cor}" end end corsa = Carro::new("Chevrolet","Corsa","Vermelho") puts corsa Mais uma novidade: o "#expressão". Ele funciona imprimindo a expressão que se encontra no interior das chaves. Voltemos rapidamente ao irb: irb(main):001:0> expressa = "Veja o exemplo" => "Veja o exemplo" irb(main):002:0> puts "#{expressa}" Veja o exemplo => nil irb(main):003:0> Veremos agora uma maneira de acessar as variáveis de instância. Logicamente, não pode- mos utilizar o puts corsa.marca, pois "marca"é uma variável privada da classe. Ocorrerá um erro de método, faça isso e verifique. Para contornarmos esse erro, faremos o seguinte: class Carro def initialize(marca,modelo,cor) @marca = marca @modelo = modelo @cor = cor end def to_s "marca: #{@marca}, modelo: #{@modelo}, cor: #{@cor}" end 47
- 49. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF def modelo #metodo para acessar a variavel de instancia @modelo end def modelo=(novo_modelo) #metodo para alterar a variavel de instancia @modelo = novo_modelo end corsa = Carro::new("Chevrolet","Corsa","Vermelho") puts corsa puts corsa.modelo corsa.modelo = "GMC" puts corsa.modelo Explicando o código: criamos o método "modelo", para podermos acessar a variável privada "modelo". Logo depois criamos o método "modelo=(novo_modelo)", para alterarmos a variável de instância "modelo". Feito isso, pedimos para mostrar novamente a variável corsa, qual o modelo, a alteração do modelo e finalmente pedindo para mostrar a variável alterada. Mas como Ruby é o melhor amigo do programador, ele permite que você tenha acesso a essas variáveis da seguinte forma: class Carro attr_reader :marca, :modelo, :cor attr_writer :cor def initialize(marca,modelo,cor) @marca = marca @modelo = modelo @cor = cor end def to_s "marca: #{@marca}, modelo: #{@modelo}, cor: #{@cor}" end def modelo #metodo para acessar a variavel de instancia @modelo end def modelo=(novo_modelo) #metodo para alterar a variável de instância @modelo = novo_modelo end O reader e writer tem como função acessar as variáveis da classe utilizando símbolos (lem- bram que foi falado que símbolo seria melhor abordado) como referência. Vale lembrar que, em Ruby, as classes nunca são fechadas, isto é, pode-se adicionar novos métodos dinamicamente, como mostrado abaixo na classe Carro: 48
- 50. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF class Carro def novo_metodo puts "Novo metodo definido dinamicamente" end def puts "Mais um metodo definido dinamicamente" end end Com isso, os novos métodos poderão ser acessados normalmente pelas instâncias da classe Carro. Isso pode ser útil para alterarmos as classes sem a necessidade de reescrevê-las. Podemos também acessar constantes de classes facilmente. Veja como (utilizando uma classe diferente): class Const Constante = 1234 end puts Const::constante 7.2 Variáveis de Classe São variáveis que estão no contexto das classes e não das instâncias. Existe somente uma cópia delas por classe e são declaradas escrevendo @@ antes do nome escolhido e SEMPRE tem que ser inicializadas antes de serem usadas. Veja um exemplo abordando tudo o que já foi visto: class Veiculo attr_reader :marca, :modelo, :cor def initialize(marca,modelo,cor) @marca = marca @modelo = modelo @cor = cor end def to_s "marca:#{@marca} modelo:#{@modelo} cor:#{@cor}" end end class Fabricante attr_reader :fabrica, :modelos, :quantidade_fabricada 49
- 51. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF @@numero_total_de_veiculos = 0 def initialize(nome,modelos) @nome = nome @modelos = modelos @quantidade_fabricada = 0 end def fabrica(modelo,cor) if !@modelos.include? modelo puts "Alerta! O Fabricante #{@nome} não fabrica o modelo #{modelo}" return nil end puts "Fabricando um #{modelo} no fabricante #{@nome}" @@numero_total_de_veiculos += 1 @quantidade_fabricada += 1 Veiculo::new(@nome,modelo,cor,@modelos[modelo]) end def Fabricante.numero_total_de_veiculos @@numero_total_de_veiculos end end # Vamos criar agora as fabricantes volks = Fabricante::new("Volkswagen",{"Parati"=>30,"Jetta"=>40,"Passat"=>10}) ford = Fabricante::new("Ford",{"Ranger"=>30,"EcoSport"=>20,"Focus"=>10}) # Vamos criar agora os veiculos da Volks (com um erro) veiculos_volks = [] veiculos_volks.push(volks.fabrica("Parati",:vermelho)) veiculos_volks.push(volks.fabrica("Jetta",:verde)) veiculos_volks.push(volks.fabrica("Ranger",:preto)) puts "#{volks.nome} fabricou #{volks.quantidade_fabricada} automóveis até o momento" veiculos_volks.each {|v| puts v unless v.nil?} puts #Vamos agora criar os veiculos da Ford veiculos_ford = [] veiculos_ford.push(ford.fabrica("Ranger",:preto)) veiculos_ford.push(ford.fabrica("EcoSport",:amarelo)) veiculos_ford.push(ford.fabrica("Focus",:prata)) puts "#{ford.nome} fabricou #{ford.quantidade_fabricada} automóveis até o momento" 50
- 52. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF automoveis_ford.each {|v| puts v unless v.nil?} puts puts "Quantidade total de automóveis no mundo é: #{Montadora:: numero_total_de_veiculos}" Quando criamos classes com alguma ligação entre elas, surge uma hierarquia entre elas. A primeira classe é a chamada classe pai e as demais as classes filhas. Para executar os métodos da classe pai, usamos o super, que funciona enviando todos os parâmetros recebidos no método para a classe pai. No entanto, há vezes que, por falta de atenção do programador, o número de argumentos enviados para a classe pai é diferente do número de argumentos, com isso aparece o seguinte erro: <ArgumentError> . Para contornar esse erro devemos fazer o seguinte: super(parâmetro1, parâmetro2,...) para que a chamada seja de acordo com os parâmetros utilizados pela classe pai. Veja alguns exemplos a seguir: Ex1: class Apenas_teste def initialize (a1,a2) @i1 = a1 @I2 = A2 end def imprime puts "primeiro argumento: #{@i1}, segundo argumento: #{@i2}" end end class Apenas_outro_teste < Apenas_teste def initialize(a1,a2) super end end e1 = Apenas_teste::new(a,b) e2 = Apenas_outro_teste::new(c,d) e1.imprime e2.imprime Isso vai mostrar na tela: primeiro argumento: a, segundo argumento: b primeiro argumento: c, primeiro argumento: d Ex2: class Apenas_teste def initialize (a1,a2) @i1 = a1 @I2 = A2 51
- 53. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF end def imprime puts "primeiro argumento: #{@i1}, segundo argumento: #{@i2}" end end class Apenas_outro_teste < Apenas_teste def initialize(a1,a2) super end end e1 = Apenas_teste::new(a,b) e2 = Apenas_outro_teste::new(d) e1.imprime e2.imprime Aparecerá o seguinte erro: super.rb:12:in ?initialize?: wrong number of arguments (1 for 2) (ArgumentError) from super.rb:12:in ?initialize? from super.rb:17:in ?new? from super.rb:17 Isso ocorreu devido ao número de parâmetros que foram passados para a classe pai. Para contornar a situação devemos fazer: class Apenas_teste def initialize (a1,a2) @i1 = a1 @I2 = A2 end def imprime puts "primeiro argumento: #{@i1}, segundo argumento: #{@i2}" end end class Apenas_outro_teste < Apenas_teste def initialize(a1,a2) super(0,a2) end end e1 = Apenas_teste::new(a,b) e2 = Apenas_outro_teste::new(d) e1.imprime e2.imprime 52
- 54. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF Isso vai mostrar na tela: primeiro argumento: a, segundo argumento: b primeiro argumento: 0, primeiro argumento: d Mostraremos aqui agora um pouco sobre herança. Como foi dito na lição anterior, herança significa que toda classe definida como uma subclasse de outra receberá automaticamente todo o conteúdo da classe pai. Com isso, voltando ao exemplo das montadoras, a classe veículo pode criar tanto automóveis quanto caminhões. Portanto, basta criar uma classe pai com os atributos e métodos em comum e depois criar diversas subclasses com as características da classe pai e mais alguns métodos e atributos. Veja o exemplo a seguir: class Veiculo attr_reader :marca, :modelo, :cor def initialize(marca,modelo,cor) @marca = marca @modelo = modelo @cor = cor end def to_s "marca:#{@marca} modelo:#{@modelo} cor:#{@cor}" end class Carro < Veiculo def to_s #o to_s foi usado para retornar se será fabricado um carro ou um caminhão. "Carro: "+super end #veja que para criar uma classe a partir de outra, basta fazer classe_nova < classe_velha end class Caminhonete < Veiculo def to_s "Caminhonete: "+Veiculo end end end class Fabricante attr_reader :fabrica, :modelos, :quantidade_fabricada @@numero_total_de_veiculos = 0 def initialize(nome,modelos) @nome = nome @modelos = modelos @quantidade_fabricada = 0 end def fabrica(modelo,cor) 53
- 55. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF if !@modelos.include? modelo puts "Alerta! O Fabricante #{@nome} não fabrica o modelo #{modelo}" return nil end puts "Fabricando um #{modelo} no fabricante #{@nome} " @@numero_total_de_veiculos += 1 @quantidade_fabricada += 1 Veiculo::new(@nome,modelo,cor) end Carro::new(@nome,modelo,cor) Caminhonete::new(@nome,modelo,cor) def Fabricante.numero_total_de_veiculos @@numero_total_de_veiculos end end # Vamos criar agora as fabricantes volks = Fabricante::new("Volkswagen",{"Parati"=>30,"Jetta"=>40,"Passat"=>10, "17210C"=>275}) ford = Fabricante::new("Ford",{"Ranger"=>30,"EcoSport"=>20,"Focus"=>10, "C-815"=>150}) # Vamos criar agora os veiculos da Volks (com um erro) veiculos_volks = [] veiculos_volks.push(volks.fabrica("Parati",:vermelho)) veiculos_volks.push(volks.fabrica("Jetta",:verde)) veiculos_volks.push(volks.fabrica("Ranger",:preto)) veiculos_volks.push(volks.fabrica("17210C",:branco)) puts "#{volks.nome} fabricou #{volks.quantidade_fabricada} automóveis até o momento" veiculos_volks.each {|v| puts v unless v.nil?} puts #Vamos agora criar os veiculos da Ford veiculos_ford = [] veiculos_ford.push(ford.fabrica("Ranger",:preto)) veiculos_ford.push(ford.fabrica("EcoSport",:amarelo)) veiculos_ford.push(ford.fabrica("Focus",:prata)) veiculos_ford.push(ford.fabrica("C-815",:cinza)) puts "#{ford.nome} fabricou #{ford.quantidade_fabricada} automóveis até o momento" 54
- 56. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF automoveis_ford.each {|v| puts v unless v.nil?} puts puts "Quantidade total de automóveis no mundo é: #{Montadora::numero_total_de_ veiculos}" Como foi falado no comentário do código, para criarmos uma classe nova, basta fazermos: classe_velha < classe nova. De acordo com a herança a nova classe terá os atributos e os métodos da classe pai. Nos métodos temos presente também, os controles de acesso. São eles: os método públicos, privados e protegidos. O tipo de acesso é especificado por símbolos. Os métodos públicos podem ser acessados por qualquer método em qualquer objeto. Ex: class ApenasTeste def diz_ola "ola!" end def cumprimenta(diferente) puts "Eu cumprimento:"+diz_ola puts "A outra classe cumprimenta:"+diferente.diz_ola end public :diz_ola # Especificação por símbolos. end class ApenasTesteFilha < ApenasTeste def metodo_ola puts "Filha cumprimento:"+diz_ola end end class ClasseDiferente def cumprimenta(outra_forma) puts "Classe diferente acessando:"+diferente.diz_ola end end pub1 = ApenasTeste::new pub2 = ApenasTeste::new filha= ApenasTesteFilha::new dif = ClasseDiferente::new pub1.cumprimenta(pub2) filha.metodo_ola dif.cumprimente(pub1) 55
- 57. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF No "pub1.cumprimenta(pub)"A instância de pub1 chama o método diz_ola de pub2. Isso é possível porque o método de pub2 é público e pode ser chamado por qualquer classe, que esteja na hierarquia, no caso a classe ApenasTesteFilha. Os métodos privados só podem ser chamados dentro do seu próprio objeto, no entanto, nunca é possível que seu método seja acessado por outro objeto, mesmo que esse objeto seja uma sub- classe da classe do primeiro objeto mencionado. Ex.: class Teste1 def diz_ola "ola!" end def cumprimenta(diferente) puts "Eu cumprimento:"+diz_ola puts "A outra classe cumprimenta:"+diferente.diz_ola end private :diz_ola end class Teste1Filha < Teste1 def metodo_oi puts "Filha cumprimenta:"+diz_ola end end class ClasseDiferente def cumprimente(outra_forma) puts "Classe diferente acessando:"+outra.diz_ola end end pri1 = Teste1::new pri2 = Teste1::new filha= Teste1Filha::new dif = ClasseDiferente::new filha.metodo_ola pri1.cumprimente(pri2) # pri1 nao consegue acessar pri2 dif.cumprimente(pri1) # estranha nao consegue acessar pri1 Se rodarmos esse código aparecerá o seguinte erro: TestePrivado.rb:7:in ?cumprimenta?: private method ?diz_ola? called for #<Teste1:0xb7e573e0> (NoMethodError) from Teste1.rb:30 Esse erro ocorre porque, primeiramente chamamos o método da filha que aciona o método herdado "diz_ola". A classe principal chama seu método "diz_ola", no entanto não consegue acessar o método da outra classe mesmo que as duas pertençam ao mesmo objeto. Os métodos protegidos podem ser acessados pelos seus descendentes. 56
- 58. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF Ex.: class TesteProtect def diz_ola "ola!" end def cumprimenta(diferente) puts "Eu cumprimento:"+diz_ola puts "A outra classe cumprimenta::"+diferente.diz_ola end protected :diz_ola end class TesteProtectFilha < TesteProtect def metodo_oi puts "Filha cumprimenta:"+diz_ola end end class ClasseDiferente def cumprimenta(diferente) puts "Classe diferente acessando:"+diferente.diz_ola end end pro1 = TesteProtect::new pro2 = TesteProtect::new filha= TesteProtectFilha::new dif = Classediferente::new pro1.cumprimenta(pro2) # pro1 consegue acessar pro2 filha.metodo_oi dif.cumprimente(pro1) # diferente nao consegue acessar pro1 Tais conceitos de métodos públicos e privados são exclusivos da linguagem Ruby, diferindo das outras linguagens de programação. 57
- 59. Capítulo 8 Entradas eSaí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 entrada e 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 e mantém na mesma linha. Já um fluxo de entrada simples é o gets. Veja o exemplo desses fluxos de entrada e saída no código abaixo feito no editor de texto: begin puts puts puts " CODIGO DE ENTRADA E SAÍDA" print "--------------------------" puts puts puts puts "Insira o nome do usuário: " nome = gets # foi digitado aqui fulano de tal puts puts puts "O nome do usuário é: #{nome}" puts puts "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
- 60. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 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 visualizar melhor o código. Isso vai do gosto do programador. É feito para melhorar o contato entre o programa 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 como finalidade 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 o usuário pressionar "enter". 8.2 Arquivos Já os fluxos de entrada e saída são mais complexos, podemos citar os arquivos. A linguagem Ruby trabalha muito bem com arquivo texto. Vamos ver um código que abordará de forma geral tudo que precisamos saber sobre arquivos. No editor de Texto (sugiro novamente o gedit), vamos começar com o corpo principal do nosso problema: criar uma agenda. Posteriormente faremos algumas "brincadeiras"para melhorar o contato 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 antes de 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 de vá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 ser utilizado quando iniciamos a variável com "File.new(...)". Após o metódo está o que será escrito no arquivo. O segundo modo é utilizando o método "puts". Ele funciona semelhantemente ao primeiro método (write), diferindo na hora da escrita. O "puts"coloca uma informação em cada linha e o write coloca tudo na mesma linha. Depois de escrever o que queríamos, utilizamos o método "close"para fecharmos o arquivo da seguinte forma: exemplo_texto.close Juntando tudo já temos o seguinte: 59
- 61. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 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, no caso podemos salvar como: ApenasTeste.rb. Rodem no terminal digitando: ruby ApenasTeste.rb O 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 = gets print " Insira o numero do telefone: " telefone = gets agend = 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ário deve fazer, com isso o cursor do terminal fica na frente da frase e não pula uma linha como aconteceria 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 fechamento do 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") => ["joaon", "45545454n"] irb(main):002:0> Útil seria se armazenássemos o que tem dentro do arquivo em uma variável para que seja melhor compreendido: irb(main):001:0> File.readlines("Agenda.txt") => ["joaon", "45545454n"] irb(main):002:0> text = File.readlines("Agenda.txt") => ["joaon", "45545454n"] irb(main):003:0> puts text joao 45545454 => nil irb(main):004:0> 60