Você está na página 1de 4

UNIVERSIDADE REGIONAL DE BLUMENAU

DEPARTAMENTO DE SISTEMAS E COMPUTAÇÃO


CURSO DE CIÊNCIA DA COMPUTAÇÃO
Professor: José Roque Voltolini da Silva
Acadêmico: Paulo Alberto Bugmann

Ruby
Criada em 1995, por Yukihiro Matsumoto, Ruby é uma linguagem interpretada, com
tipagem dinâmica e forte, orientada a objetos e com várias semelhanças com Perl,
Python e SmallTalk. Algumas de suas características:
• Possui uma sintaxe simples, praticamente inspirada por Eiffel e Ada;
• Puramente Orientada a Objetos. Isso significa que todo dado em Ruby é um objeto. Por
exemplo, 1 é uma instância da classe Fixnum.
• Ruby tem blocos em sua sintaxe (código delimitado por {...} ou do...end. Esses blocos
podem ser passados para os métodos, ou convertidos em closures.
• Inteiros em Ruby podem ser usados sem contar sua representação interna. Se um valor é
pequeno o bastante, um inteiro é um Fixnum, do contrário é um Bignum A conversão
ocorre automaticamente.
• Ruby não precisa de declaração de variáveis. Apenas usa a convenção de nomeclatura
para delimitar o escopo das variáveis. Por exemplo: var = variável local, @var =
variável de instancia, $var = variável global.

Exemplo de Código
1
2 class Carro
3 #Construtor
4 def initialize(marca,modelo)
5 #variaveis de instancia
6
7
@marca = marca
8 @modelo = modelo
9 end
10
11 def get_modelo
12 @modelo
13 end
14
15 def set_modelo(modelo)
16 @modelo = modelo
17 end
18 end
19 #Criando um objeto
20 car = Carro.new(“Volkswagem”, “Gol”);
21 puts car.get_modelo
22 #=> Gol
23 car.set_modelo(“Fusca”)
24 puts car.get_modelo
25 #=> Fusca
Blocos
Blocos são pedaços de códigos que podem se associados à chamada de um método. O
bloco é formado por chaves que delimitam o inicio e o fim do bloco, entre pipes devem vir
quantos parâmetros forem necessários separados por vírgula e a sentença a ser executada.
Também poderíamos delimitar o início e fim de nosso bloco com do end ao invés de chaves,
mas por padrão os programadores seria utilizar chaves para blocos com apenas uma linha e
blocos maiores do end.

1
2 ["daniel","lopes"].each {|item| puts item}
3
4 # => resultado sera:
5 # => daniel
6 # => lopes

1
meu_hash = {:nome=>"daniel",:sobrenome=>"lopes"}
2
meu_hash.each {|index,item| puts "chave #{index},valor #{item}"}
3
4
# => resultado sera:
5
# chave nome,valor daniel
6
# chave sobrenome,valor lopes
7

Mas e se quisermos atribuir um bloco a uma variável? Não é possível, teremos um erro.
Por definição blocos só são usados com métodos. Então para isso podemos usar o método
lambda que retorna um objeto da classe Proc ou o métod proc, que são equivalente a
Proc.new, mas possui uma diferença ao criar um lambda e proc fazem checagem de parâmetro
enquanto que Proc.new não.

1
2 bloco1 = lambda{|x,y| x+y}
3 bloco1.call(1,2) # => 3
4
5 bloco1.call(1) # erro por numero incorreto de parametros
6 ArgumentError: wrong number of arguments (1 for 2)
7 from (irb):1
8 from (irb):3:in `call'
9 from (irb):3
10
11 bloco2 = Proc.new {|x,y| x+y}
12 bloco2.call(2) # nao checa os parametros e tenta fazer o calculo com
13 nil
14 TypeError: nil can't be coerced into Fixnum
15 from (irb):7:in `+'
16 from (irb):7
17 from (irb):8:in `call'
18 from (irb):8
19 from :0
20
21 bloco2.call(2,3,4,5) #=> 5
22 # na linha acima ignorou 4 e 5 que foram parametros a mais.
23 # abaixo a mesma coisa, mas usando proc
24
25 bloco3 = proc {|x,y| x+y}
26 bloco3.call(2,3,4,5) # erro por parametros
27 ArgumentError: wrong number of arguments (4 for 2)
28 from (irb):10
from (irb):11:in `call'
29
from (irb):11
30
from :0
31

Podemos passar blocos como parâmetros para os métodos, mas devemos saber quando
aquele bloco vai ser executado dentro do método, para isso temos o yield.

1
2 def executa_blocos
3 puts "Olá, vou executar um bloco logo abaixo"
4 yield
5 puts "==============="
6 end
7
8 executa_blocos { puts "rodando bloco!" }
9 # => Olá, vou executar um bloco logo abaixo
10 # => rodando bloco!
11 # => ===============

O método yield espera um bloco, e no momento em que yield for chamado ele irá
executar o bloco disponível.

1
2 def executa_blocos(vezes)
3 vezes.times {yield}
4 end
5
6 executa_blocos(2) { puts "rodando bloco!" }
7 #=> rodando bloco!
8 #=> rodando bloco!

Expressão Regulares
1 print “(M)Multiplicação ou (A)Adição:”
2 operacao = gets #Buscando, a informação digitada na tela
3 print “Número: “
4 #Converte uma String em Inteiro
5 numero = Integer(gets)
6 #O operação ‘=~’ espera que a sua esquerda esteja uma Regex
7 if operacao =~ /^(m|M)
8 calc = lambda { |n| n*numero }
9 else
10 calc = lambda { |n| n+numero }
11 #Criar um coleção de 1..10, o ‘&’ faz uma conversão para tipo Proc
12 Puts((1..10).collect(&calc).join(“, “))

Fatorial
1 def factorial(n)
2 if n == 0
3 1
4 else
5 n * factorial(n-1)
6 end
7 end
8
9 puts factorial(5)

Produto Cartesiano
1 cartprod def (* args)
2 resultado = [[]]
3 enquanto] [! = args
4 t, resultado resultado = []
5 b, * args = args
6 t.each fazer | a |
7 b.each fazer | n |
8 Resultado <<[n] a +
9 final
10 final
11 final
12 resultado
13 final
Exemplo:
cartprod ([1,2], [3,4,5], [6,7,8])
=> [[1, 3, 6], [1, 3, 7], [1, 3, 8], [1, 4, 6], [1, 4, 7], [1, 4,
8] ,
[1, 5, 6], [1, 5, 7], [1, 5, 8], [2, 3, 6], [2, 3, 7], [2, 3, 8],

[2, 4, 6], [2, 4, 7], [2, 4, 8], [2, 5, 6], [2, 5, 7], [2, 5, 8]]

Referências

OLIVERA, Eutáquio Ragel Jr. Ruby: Conhecendo a Linguagem. Brasport Livros e


Multimídia.Ltda, 2006.

MECENAS, Ivan. Ruby: Investigando a Linguagem. Alta Books Ltda, 2006.