Curso de introdução ao ruby

Introdução à programação
Usando Ruby
Francis S. Wagner
v. 1.0 - Junho/13

Um pouco sobre Ruby
● Criada em 1993 no Japão por Yukihiro Matsumoto
● Linguagem interpretada, de tipagem dinâmica e forte
● Orientada a objetos e suporta o paradigma funcional
● Escrita em linguagem C
● Está entre as 10 linguagens de programação mais
populares segundo o índice Tiobe
● Uma das linguagens mais utilizadas por startups

Por que usar Ruby?
● Fácil aprendizado
● Open Source
● Sintaxe intuitiva
atendente.registra_recado!(agenda_pessoal, recado)
if pessoa_procurada.esta_na_empresa?
● Várias ferramentas usam scripts ruby: SkechtUp,
RallyDev
● Pode-se desenvolver para smartphones - RubyMotion

Por que não usar Ruby?
● É uma das linguagens mais lentas hoje em dia
Como sabemos se ela é lenta?
● O Twitter trocou seu front end por uma ferramenta
criada por eles chamada Blender que é feita em Java

Artigo do Twitter
Para conseguir entender os ganhos de performance, você deve
primeiro entender as ineficiências dos nossos servidores de
front-end anteriores, que eram em Ruby on Rails (…) Nós
sabemos há muito tempo que o modelo síncrono de responder
requisições usam nossos CPUs de forma ineficiente. Com o
tempo, nós também acabamos acumulando um débito técnico
significativo no nosso código Ruby, tornando muito difícil
adicionar novas funcionalidades e melhorar a confiabilidade do
nosso engine de pesquisa. Blender [a nova solução feita com
tecnologias Java] endereçam esses problemas: criando um
serviço de agregação totalmente assíncrono (…)

Empresas e sites que usam Ruby e Rails
● Nasa
● Motorola
● Groupon
● Github
● Basecamp da 37Signals
● Shopify
● Yellow Pages
● Scribd
● Slideshare

... e mais algumas
● Amazon.com
● IBM
● EA
● Cisco
● Oracle
● New York Times
● ThoughtWorks
● Yahoo!
● A List a part

Introdução à linguagem
● IRB
● Números
● Variáveis
● Strings
● Arrays
● Símbolos
● Hash
● Ranges
● Estruturas de controle
● Iterators

Avançando um pouco
● Funções
● Date and Time
● Orientação a Objetos
● Módulos
● Blocos
● Expressões regulares
● IO
● Exceções

IRB
Interface de execução do ambiente Ruby

Ruby
Executando o primeiro programa em Ruby

Números
puts 10 / 5
puts 3 * 10
puts 13 + 19
puts 20 - 1
puts 9 / 2
puts 10.0 / 5.0
puts 3.0 * 10.0
puts 13.0 + 19.0
puts 20.0 - 1.0
puts 9.0 / 2.0
Inteiros Ponto Flutuantes
Formato para números grandes
numero = 1000000000 numero = 1_000_ 000_000

Números randômicos
Retorna um número entre 0 e 1
puts rand
puts rand
Retorna um número entre um número máximo
puts rand 100
puts rand 100

O objeto Math
Constantes
Math::PI
Math::E
Métodos
Math.tan
Math.cos
Math.sin
Math.log
Math.sqrt

Tipagem fraca Vs dinamica
'' == '0'
0 == ''
0 == '0'
false == 'false'
false == '0'
false == undefined
false == null
null == undefined
'trn' == 0
idade = "27"
puts idade.class
idade = 27
puts idade.class
Javascript Ruby

Ache o erro - (Tipagem)
def test(a, b)
a + b
end
def main()
if ARGV.length > 3
puts test(1, test)
else
puts test(1, 2)
end
end
Process.exit(main())
_________________________________________________________________________________________
____
irb>ruby -w -W2 argsTest.rb

Operadores
+ (Adição) - (Subtração) * (Multiplicação)
/ (Divisão) % (Módulo) ** (Expoente)
! e not (Negação) || (Ou) && (E)
.. (Range incl) ... (Range excl) ?: (Ternário)
== (Igual) != (Diferente) < (Menor)
> (Maior) >= (Maior igual) <= (Menor igual)

Operadores de Bit
| (Ou) & (E) ^ (Ou excl)
~ (Compl) << (Left) >> (Right)
Operadores especiais
. (Chamar métodos) :: (Chamar constantes)

Constantes
Ex:
MINHA_CONST = "Teste de constantes"
puts MINHA_CONST
MINHA_CONST = "Mudando o valor da constante"
puts MINHA_CONSTANTE
Variáveis que não mudam de valor após a atribuição
warning: already initialized constant
O que acontece se mudarmos o valor de uma constante?

Exemplo de uso do operador ::
module Foo
COUNT = 10
::COUNT = 20
end
puts COUNT
puts Foo::COUNT
Qual será o resultado?

Palavras reservadas
alias and BEGIN begin break case class def
defined do else elsif END end ensure false
for if in module next nil not or redo
rescue retry return self super then true undef
unless until when while yield

Strings
Ex:
puts 'Teste de strings com apóstrofos'
puts "Teste de strings com aspas"
puts 'Teste de James O'Bryan'
puts %{Teste de strings}
puts %Q{ Teste de strings }
puts %q{teste de strings}
Strings são formadas por ' (apóstrofos) ou " (aspas)
Mundo bizarro! O que acontece com o código abaixo?
"teste " * 3

Concatenação de Strings
str = 'teste ' ; str2 = 'de strings'
puts str + str2
Com +
Com interpolação
puts "Teste #{str2}"
Com <<
puts str << str2
Obs: << muda o estado da string

Variáveis
Ex:
idade = 28
ano = 2013
nome = 'Francis'
puts idade
puts ano
puts nome
São espaços de memória que armazenam informações

Variáveis
nome = 'Francis'
puts "Meu nome eh" + nome
puts "Meu nome eh #{nome}"
puts 'Meu nome eh #{nome}'
puts 'Custo total: %.2f' % 250
Interpolação de Strings
puts "1 + 2 = #{1 + 2}"
A interpolação não necessariamente usa variáveis

Exercícios
1) Crie uma variável "nome" contendo "John O'brien" e outra "idade" com 30
2) Mostre na tela a mensagem "Meu nome eh John O'brien e tenho 30 anos"
3) Execute a soma de duas variaveis, uma contendo 10 e a outra 23
4) Mostre na tela o conteúdo dessas variáveis na frase "10 + 23 = 33"
5) Execute o cálculo 0.0009 - 0.0001 e mostre o resultado na tela. Era o que
esperava? O que houve?
6) Qual o resultado de 10 + 10? E de '10' + '10'? E de '10 + 10'?
Construa os trechos de códigos abaixo

Tudo é objeto em Ruby
puts true.class
puts false.class
Não existem booleanos
puts nil.class
Nem nulo (nil)
puts "teste".class
puts 3.class

Strings continuação
str = "amor" ; str2 = "roma"
puts str.downcase
puts str.upcase
puts str.reverse
puts str.capitalize
puts str.casecmp str2
puts str.chop
Métodos que podem ser aplicados às strings

puts str.concat str2
puts str.delete 'e'
puts str.empty? ? ----> WTF?
puts str.eql?str2
puts str.hash
puts str.include?'b'
puts str.index'r'
puts str.length

str = 'amar'
puts str.insert(4, ' ').insert(5, 'eh...')
str = ' teste '
puts str.lstrip
puts str.rstrip
puts str.strip
puts str.replace 'roma'
str = "a, b, c, d, e, f"
puts str.split ', '
str = 'a'
puts str.succ ------> str.next

str = 'teste'
puts str.swapcase
str = '1.2'
puts str.to_i
puts str.to_f
str = 'teste'
lineWidth = 50
puts str.center lineWidth
puts str.ljust lineWidth
puts str.rjust lineWidth

Pegando valores digitados pelo usuário
str = gets
puts str
puts str.chomp
str = gets.chomp
Tudo é objeto em Ruby, certo?
puts 10.-9
puts 'teste'.+' de'.+' strings'
puts ((6.*9).+10./2.-3).**2

Acessando o conteúdo das strings individualmente
str = "Amor eh..."
str[2] = 'a'
puts str
Ranges de strings
str = "Teste de range"
puts str[0..4]
puts str[0,4]
puts str[-5..-1]
puts str[-5,5]

Exercícios
1) Crie um código que solicite ao usuário o seu nome e a sua idade.
2) Mostre na tela uma mensagem que inclua o nome e a idade digitada.
Ex: Bom dia, meu nome é ... e tenho ... anos.
3) Dada a string 'amor', mostre na tela o inverso, ou seja, 'roma'.
4) Criar uma string com o conteúdo: "teste de strings" e mostre na tela como
"Teste De Strings".
5) Dada a string " teste", remova os espaços em branco
6) Dada a string "a, b, c, d" retorne um array na ordem inversa. Ex: [d], [c], [b], [a]

Comentários em Ruby
Em linha
#Esse trecho de codigo nao será executado
Em bloco
str = "Teste"
=begin
str = "Esse trecho de codigo nao sera executado"
=end
puts str

Arrays
Ex:
my_arr = Array.new
puts my_arr
my_arr2 = []
puts my_arr2
my_arr = [1, 2, 3, "teste"]
puts my_arr
my_arr.push(4)
puts my_arr
São variáveis que comportam mais de uma informação

Arrays continuação
Ex:
my_arr.pop(4)
puts my_arr
my_arr[5] = 6
my_arr
my_arr << 10
puts my_arr[0..2]
puts my_arr[0, 2]

Mais sobre Arrays
Ex:
my_arr = [1, 2, 3, 4]
primeiro, segundo, terceiro = my_arr
puts primeiro
puts segundo
puts terceiro
primeiro, segundo, *restante = my_arr
puts primeiro
puts segundo
puts restante

Arrays de string
arr = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
São chatas de se criar
arr = %w{a b c d e f g h i}
Mas o Ruby possui uma forma mais fácil
arr = %w{"Meu teste" segundo terceiro}
Arrays de palavras que contem espacos sao problematicas
arr = %w{"Meu teste" segundo terceiro}
A solução eh adicionar uma antes do espaço

Operações com Arrays
arr1 = [1, 2, 3, 4]
arr2 = [3, 4, 5, 6, 7, 8]
puts arr1 + arr2
puts arr1 - arr2
arr = [1, 3]
puts arr * 5
puts arr1 | arr2
puts arr1 & arr2
União e interseção de arrays

Ainda mais sobre Arrays
my_arr = [10, 4, 30, 23, 5, 7]
my_arr.sort
Ordenando arrays
my_arr = [1, 2, 3, 4, 5]
my_arr.map { |n| n * n }
Retornando cada elemento do array

Outras formas de criar Arrays
my_arr = Array[0..10]
my_arr = Array['a'..'z']
my_arr = Array.new 10
my_arr = Array.new 10, ''
my_arr = Array.[](1, 2, 3, 4, 5)
Alguns métodos usados com Arrays
my_array.length ou my_array.size
my_array.compact
my_array.at 0 ou my_array[0]
my_array.clear
my_array.delete 4
my_array.delete_at 3

puts :simbolo
:simbolo.class
:simbolo.to_s
"simbolo".to_sym
s1 = "123" ; s2 = "123"
puts s1.object_id
puts s2.object_id
s1 = :simbolo
s2 = :simbolo
puts s1.object_id
puts s2.object_id
Symbols
São como strings, mas imutáveis e persistem em todo o código

meu_hash = Hash.new
meu_hash[1] = 10
meu_hash[2] = 20
meu_hash["str"] = 30
puts meu_hash[1]
puts meu_hash[2]
puts meu_hash["str"]
Hashes
São estruturas formadas por uma chave e um valor

meu_hash = {1 => 10, 2 => 20, "str" => 30}
meu_hash = {:nome => "Joao", :idade => 20, :sexo => "M"}
Mais sobre Hashes
Outras forma de se criar Hashes
meu_hash = {nome: "Joao", idade: 20, sexo: "M"}
Forma mais nova utilizando simbolos

Mais um pouco sobre Hashes
Métodos
meu_hash.keys
meu_hash.values
meu_hash.has_key? :nome
meu_hash.has_value? 20
Não funciona
meu_hash.has_key? "nome"
Mas assim funciona
meu_hash.has_key? "nome".to_sym

Problemas que podem ocorrer
O que acontece?
endereco = meu_hash[:endereco]
endereco.strip #para tirar os espacos em branco da variavel endereco
Precisamos proteger o código
endereco = meu_hash[:endereco] || ''
endereco.strip
endereco = meu_hash.fetch :endereco, ''
endereco.strip

Ranges
São tipos que tem inicio e fim
1..10 # vai de 1 até 10
1...10 # vai de 1 até 9
'a'..'z' # vai de 'a' até 'z'
'a'...'z' # vai de 'a' até 'y'
Testando Ranges
anos = 2000..2013
anos.include? 2012
anos.include? 2014
Podemos converter ranges para arrays
anos.to_a

Estruturas de controle
if
idade = 18
if idade < 18
puts 'Menor de idade'
end
elsif
if idade < 18
elsif idade < 21
puts 'Menor de idade civil'
else
puts 'Maior de idade'
end

if pós-fixado
idade = 17
puts 'Menor de idade' if idade < 18
and e &&, or e ||
and - sempre avalia as duas expressões
&& - se a primeira for falsa, retorna falso
or - sempre avalia as duas expressões
|| - se a primeira for verdadeira, retorna verdadeiro

unless idade >= 18
else
puts 'Maior de idade'
end
idade = 18
unless idade >= 18
end
unless
unless - else

idade = 18
idade < 18 ? puts 'Menor de idade' : 'Maior de idade'
idade = 18
puts 'Menor de idade' unless idade >= 18
unless - pós-fixado
operador ternário

case
a = 10
case
when a < 5
puts 'a é menor que 5'
when a < 10
puts 'a é menor que 10'
else
puts 'a é maior ou igual a 10'
end

case com ranges
ano = 2013
case ano
when 2000..2005
puts 'Ano está entre 2000 e 2005'
when 2006..2010
puts 'Ano está entre 2006 e 2010'
else
puts 'Ano eh maior que 2010'
end

Iterators
for <variavel> in <colecao>
frutas = %w{amora banana maca melao pera uva}
for fruta in frutas
puts "Eu como #{fruta}"
end
Iterando com hashes
carros = { ford:'fiesta', volkswagen:'gol', chevrolet:'onix', nissan:'march' }
for marca, veiculo in carros
puts "Meu carro eh da #{marca} e eh um #{veiculo}"
end

Iterators
while
a = 0
while a < 10 do
puts "a eh igual a #{a}"
a += 1
end
while com arrays
arr = [1, 2, 3, 4, 5]
while arr.length > 0 do
puts "arr eh igual a #{arr.pop}"
end

Iterators
until
a = 0
until a > 10 do
puts "a eh igual a #{a}"
a += 1
end
while com arrays
arr = [1, 2, 3, 4, 5]
until arr.empty? do
puts "arr eh igual a #{arr.pop}"
end

Exercícios
1) Crie um código que solicite ao usuário o seu ano de nascimento e calcule a sua
idade mostrando na tela.
2) Crie um código que solicite ao usuário o seu nome, sua idade e seu sexo.
Coloque esses valores num hash chamado "usuario" e mostre seu conteudo na
tela da seguinte forma: "Olá <nome>, você é <menor/maior> de idade. <Já/Não>
pode dirigir." Garanta que o nome estará com a primeira letra em maiúsculo e que
não conterá espaços em branco.
3) Solicite ao usuário que digite um ano. Caso o ano digitado não esteja entre
2000 e 2012 mostre a mensagem: "Você não está elegível". Caso esteja, mostre a
mensagem: "Você está elegível, parabéns"

Funções
São blocos de código com nomes e que executam alguma tarefa
def soma a, b
a+b
end
puts soma 10, 3
Sempre retornam algum valor
def is_even? numero
numero % 2 == 0
end
puts is_even? 11

Funções
Mais um exemplo de retorno de valor em funções
def fatorial(n)
return 1 if n == 1
n * fatorial (n-1)
end
puts fatorial(10)
puts fatorial(5)
Definindo alias para funções
alias fat fatorial
puts fat 5

Funções
Funções com parâmetros com valor padrão
def truncar_frase str, tam_max=30
str[0, tam_max]
end
truncar_frase 'Teste de truncamento de frases'
truncar_frase 'Teste de truncamento de frases', 20

Funções
Funções com quantidade de parâmetros variados
def numeros (*n)
for i in 0...n.length
puts "Valor de i = #{n[i]}"
end
end
puts numeros(20, 3, 4, 10, 5, 7, 8, 4, 30)

Funções
Ruby pode retornar mais de um valor
def retorna_valores
return 1, 10, 100, 1000, 10000
end
puts retorna_valores
a = retorna_valores
puts a.class
puts a[3]

Funções
Parametros nomeados (Hashes)
def dados(options={})
puts "Nome: #{options[:nome]}, idade: #{options[:idade]}, sexo: #{options[:
sexo]}"
end
dados( :idade => 10, :sexo => 'm', :nome => 'Joao')
Dessa forma não importa a ordem dos parâmetros

Funções
Parametros nomeados com valores padrão
def dados(options={})
o = {
:nome => 'teste',
:idade => 30,
:sexo => 'm'
}.merge(options)
puts "Nome: #{o[:nome]}, idade: #{o[:idade]}, sexo: #{o[:sexo]}"
end
dados
dados( :idade => 10, :sexo => 'm')

Date and Time
Obtendo a data corrente
time1 = Time.new
time2 = Time.now
puts time1.inspect
puts time2.inspect
Obs: Time.new e Time.now são sinônimos

Date and Time
Componentes do objeto Time
puts "Data atual: " + time.inspect
puts time.year # => Ano corrente
puts time.month # => Mês corrente: 1 a 12
puts time.day # => Dia corrente: 1 a 31
puts time.wday # => Dia da semana: 0 eh domingo
puts time.yday # => Dia do ano: 0 a 365
puts time.hour # => Hora: 0 a 23
puts time.min # => Minutos: 0 a 59
puts time.sec # => Segundos: 0 a 59
puts time.usec # => microsegundos: 999999
puts time.zone # => "UTC": timezone

puts time.strftime ("%Y-%m-%d %H:%M:%S")
Date and Time
Formatando a data e hora
Alguns formatos para data e hora
%d - Dia do mês (01 to 31).
%H - Hora (00 to 23).
%I - Hora (01 to 12).
%j - Dia do ano (001 to 366).
%m - Mês (01 to 12).
%M - Minuto (00 to 59).
%p - AM ou PM.
%S - Segundos (00 to 60).
%Y - Ano

Orientação a Objetos
Conta
- saldo
- numero
+ depositar
+ sacar
+ consultar
Fisica
- saldo
- numero
+ depositar
+ sacar
+ consultar
Juridica
- saldo
- numero
+ depositar
+ sacar
+ consultar

Classes
class Conta
def initialize(numero)
@numero = numero
@saldo = 0
end
def depositar(valor)
@saldo += valor
end
end
c = Conta.new "0001"
c.depositar 10

Herança de Classes
class ContaFisica < Conta
def initialize(numero, saldo)
super (numero)
@saldo = saldo
end
end
c = ContaFisica.new "0001", 100
c.depositar 10

Getters
class Conta
def saldo
@saldo
end
def numero
@numero
end
end
c.saldo

Setters
class Conta
def saldo=(new_saldo)
@saldo = new_saldo
end
def numero=(new_numero)
@numero = new_numero
end
end
c.saldo = 100

Accessors
class Conta
attr_reader :numero
attr_writer :saldo
@numero = numero
end
end
c.saldo = 100
c.numero

Accessors - read / write
class Conta
attr_accessor :numero, :saldo
@numero = numero
end
end
c.saldo = 100
c.numero

Variaveis de classe
class Conta
@@tipo_conta = 'normal'
def self.tipo_conta
@@tipo_conta = 'normal'
end
end
Conta.tipo_conta

Outra forma de criar variaveis e métodos de classe
class Conta
class << self
attr_accessor :tipo_conta
def print_tipo_conta
puts @tipo_conta
end
end
@tipo_conta = 'normal'
end
Conta.print_tipo_conta

class Conta
attr_accessor :saldo
attr_reader :numero
@numero = numero ; @saldo = 0
end
def sacar(valor)
@saldo -= valor
end
def depositar(valor)
@saldo += valor
end
end
class ContaFisica < Conta
super(numero)
end
def sacar(valor)
@saldo -= valor * 1.1
end
end
c = ContaFisica.new '0001'
c.depositar 100
c.saldo
c.sacar 10
c.saldo
Herança

Módulos
Criando um módulo
module Messages
def message_OK
puts "OK"
end
end
class C1
include Messages
attr_reader :msg
def initialize(msg)
@msg = msg
end
end
c = C1.new("Erro").message_OK

Blocos
São outra forma de realizar iteração em objetos
#Usando blocos com arrays
frutas = %w{banana maca melancia uva pera laranja}
frutas.each {|fruta| puts "#{fruta}"}
frutas.each do |fruta|
puts "#{fruta}"
end
frutas.each_with_index do |fruta, indice|
puts "#{fruta} - #{indice}
end

class Agenda
def initialize
@contatos = []
end
def add_contato(contato)
@contatos += [contato]
end
def each
@contatos.each {|c| yield c}
end
end
Blocos
Criando iteradores customizados com blocos
class Contato
def initialize(nome, telefone)
@nome = nome
@telefone = telefone
end
attr_accessor:nome, :telefone
end
c1 = Contato.new('Joao', '99229-2222')
c2 = Contato.new('Maria', '99229-2222')
a = Agenda.new
a.add_contato(c1)
a.add_contato(c2)
a.each {|c| puts "#{c.nome} - #{c.telefone}"}

Expressões regulares
Substituindo palavras
"Teste de Java. Esse eh um teste de expressões regulares em Java".sub
('Java','Ruby')
"Teste de Java. Esse eh um teste de expressões regulares em Java".gsub
('Java','Ruby')
"Teste de Ruby. Esse eh um teste de expressões regulares em ruby".sub(/[tT]
este/,'exemplo')
"Teste de Ruby. Esse eh um teste de expressões regulares em ruby".gsub(/[tT]
este/,'exemplo')

Entendendo Expressões Regulares
http://gskinner.com/RegExr/
. - Qualquer caracter que não seja quebra de linha
w - caracteres alphanuméricos (a-zA-Z0-9_)
W - caracteres especiais (./?;:'" *+-=)
d - dígitos (0-9)
D - qualquer caractere que não seja dígito
s - qualquer caracter que seja espaço em branco
S - qualquer caracter que não seja espaço em branco
[0-9] - dígitos de 0 a 9
[a-zA-Z] - caracteres alfabéticos
? - zero ou um caractere
* - zero ou mais caracteres
+ - um oou mais caracteres

Verificando datas
r = /^[0-3]?[0-9]/[0-3]?[0-9]/(?:[0-9]{2})?[0-9]{2}$/
a = "1/12/2000"
res = a.match r
res.captures
Verificando telefone
"(11) 3456-7890".match /(d{2}) d{4}-d{4}/
Verificando duas palavras separadas por espaço
"John Secada".match /(w*)s(w*)/

IO
Lendo todas as linhas de um arquivo de uma só vez
f = File.readlines("teste.txt")
puts f
Lendo determinadas linhas
f = File.readlines("teste.txt").find_all {|linha| linha =~ /^Teste/}
puts f
Lendo determinadas linhas com a função grep
f = File.open("teste.txt") do |handle|
handle.grep(/^Teste/)
end
puts f

IO
Lendo o arquivo byte a byte
File.open("teste.txt") do |handle|
handle.each_byte do |b|
print "b:", b
end
end
Lendo o arquivo byte a byte em ASCII
File.open("teste.rb") do |handle|
handle.each_byte do |b|
print "c: #{b.chr}"
end
end

IO
Escrevendo em arquivos - Forma 1
handle = File.new("teste.txt", "w")
handle.puts "Teste de escrita em arquivos 1"
handle.puts "Teste de escrita em arquivos 2"
handle.close
File.readlines("teste.txt").each {|linha| puts linha}
Escrevendo em arquivos - Forma 2
handle = File.new("teste.txt", "w")
handle.write "Teste de escrita em arquivos 1n"
handle.write "Teste de escrita em arquivos 2n"
handle.close
File.readlines("teste.txt").each {|linha| puts linha}

IO
Renomeando arquivos
File::rename("teste.txt", "teste2.txt")
Apagando arquivos
File::delete("teste.txt")
Verificando se um arquivo existe
f = File.open("teste.txt", "r") if File::exists?("teste.txt")
puts f.readlines
f.close

Exceções
Tratando exceções
begin
file = open("teste.txt")
if file
puts "Arquivo aberto com sucesso"
end
rescue
puts "Impossivel realizar abertura do arquivo"
end

Exceções
Tratando exceções - retry
count = 0
begin
if file
end
rescue
count += 1
retry if count <= 5
end

Exceções
Tratando exceções - ensure
begin
if file
end
rescue
ensure
puts "Encerrando o programa"
end

1) Crie uma classe chamada Contato, que contenha os campos nome, telefone,
data de nascimento e metodos para adicionar/alterar esses campos
2) Crie uma classe chamada Agenda, que permita a inclusão de Contatos. Deve
haver um metodo para iterar todos os contatos da agenda
3) Criar uma função que verifique se uma frase eh ou não um palindrome. Deve-
se desconsiderar a pontuação, ou seja, virgulas, pontos, hifens devem ser
desconsiderados. Dica: Usar gsub para retirar a pontuação.
OBS: Palindromes são frases ou palavras que quando lidas de trás para frente
são idênticas ao original:
Ex: A rara arara
Rir, o breve verbo rir
Erro comum ocorre
Exercícios

4) O método strip retira caracteres em branco no início e no final da string. Crie
um método strip que recebe uma string contendo uma frase e outro parametro
que informa qual o caracter a ser retirado da string.
Ex:
def strip(str, chr)
end
strip("Hello World!!", '!')
# Deve imprimir Hello World
#Dicas: Use blocos. O método each_bytes retorna byte a byte em uma string
Exercícios

def palindrome?(string)
s = string.downcase
s = s.gsub(/[.;,'"<>!?`˜/:-+=_ ]/, '')
s == s.reverse
end
Resposta dos exercícios
Palindrome

def strip (str, chr)
new_str = ''
str.each_byte do |b|
new_str << b.chr unless b.chr == chr
end
new_str
end
Resposta dos exercícios
Método strip

Curso de introdução ao ruby

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Curso de introdução ao ruby

Curso de introdução ao ruby