O documento descreve conceitos básicos da linguagem de programação Ruby, incluindo:
1) Sua origem no Japão e influências de outras linguagens como Smalltalk e Perl.
2) Conceitos como orientação a objetos, dinamismo, blocos de código e falta de tipagem.
3) Ferramentas como RVM para gerenciar versões do Ruby e Rubygems para gerenciar pacotes.
2. O que?
— Do Japão
◦ Yukihiko “Matz” Matsumoto
— Trazida
ao mundo ocidental pelos
Pragmatic Programmers
◦ Andy Hunt e Dave Thomas (livro da
machadinha)
— Completamente orientada a objetos
◦ Não existem tipos primitivos
3. Como?
— Linguagem “de script” interpretada;
— Muito influenciada por Smalltalk e Perl;
— Contém conceitos de linguagens
funcionais (closures – blocos de código);
— Completamente
dinâmica (tudo pode
mudar em tempo de execução);
4. RVM – Ruby Version Manager
— Solução
pra instalar vários
interpretadores Ruby ao mesmo tempo
na sua máquina;
— Possibilita
criar aplicações completamente
independentes no seu ambiente de
desenvolvimento, isolando tudo e todos;
5. Instalando o RVM
— Instale o Git na sua máquina
— bash
< <(curl –s
https://rvm.beginrescueend.com/install/rvm)
— Feche o console e abra outra vez
— rvm notes
◦ E faça o que ele mandar
6. Instalando um Ruby com o RVM
— rvm install ruby-1.9.2
— rvm use 1.9.2
— rvm --default use 1.9.2
7. Rubygems!
— gem install bundler rails
— ORubygems é o gerenciador de pacotes
do Ruby, é com ele que você vai instalar
as dependências da sua aplicação;
— Na
sua máquina ele é chamado pelo
comando “gem”;
8. Bundler -> bundle install
— É
quem garante que todas as
dependências da sua aplicação estão
disponíveis para que ela possa executar;
— Usaum arquivo chamando Gemfile onde
você define as suas dependências e ele as
instala usando o Rubygems;
— Garante
que todos os desenvolvedores
usam as mesmas coisas no trabalho;
9. Começando a brincar com o IRB
— IRBé o “Interactive Ruby”, o console da
linguagem;
— Pode-se enviar comandos ou se definir
classes, módulos, funções e qualquer
outra coisa pra se utilizar durante uma
sessão;
11. Primeiras tres regras de Ruby
— Nãose usam ‘;’ ou qualquer outra coisa pra
indicar o fim de uma linha, o fim da linha é o
fim da linha, oras;
— Variáveis
não tem tipo, elas simplesmente
guardam um objeto qualquer, de qualquer
tipo;
— Quando nós vamos dar nomes a variáveis,
normalmente separamos nomes compostos
com “_”;
13. Mais quatro regrinhas – 1
— A
definição de um método começa com
“def” depois vem o nome do método e
depois seus parâmetros entre parenteses;
— Blocosde código, como métodos, classes,
“ifs” são sempre fechados com “end”, aqui
não tem “{}” não;
14. Mais quatro (5) regrinhas - 2
— EmRuby não se usa “return”, se a última
expressão no corpo de um método for
avaliada para um valor, esse valor é
retornado;
— O
uso de parênteses não é obrigatório na
chamada de métodos, mas tenha cuidado
com a legibilidade;
— Bem, vocêainda pode usar “return” se
quiser, mas é feio, oras;
15. Classes
class Song
def initialize(name, artist, duration)
@name = name
@artist = artist
@duration = duration
end
end
musica = Song.new “Denied”, “Sonic
Syndicate”, 3
musica.inspect
16. Mais regras
— A
definição de uma classe começa com a
palavra “class”;
— As
classes são sempre “abertas”, você pode
redefinir os métodos de uma classe em
qualquer lugar, é só declarar ela outra vez;
— Nomesde classe normalmente são definidos
usando CamelCase (como em
NomeDeClasse);
17. Mais regras
— Os contrutores são os métodos “initialize
()”, que são invocados indiretamente,
através do método de classe “new”;
— Nãoé possível fazer sobrecarga de
construtores em Ruby =( ;
— Variáveis
de instância tem o nome
começado por “@”;
18. Atributos
class Song
attr_writer :duration
attr_reader :duration
attr_acessor :title
end
song = Song.new("Bicylops", "Fleck", 260)
song.duration = 257
song.title = ‘Triciclops’
19. Regras denovo
— attr_reader
define métodos de acesso a
um atributo de instância de um objeto;
— attr_writer
define métodos de alteraçao a
um atributo de instância de um objeto,
assim como o reader, ele cria a variável
dentro do objeto;
— attr_acessor
faz o mesmo que os dois
anteriores juntos;
20. Definindo atributos virtuais
class Song
def duration_in_minutes
@duration/60.0
end
def duration_in_minutes=(new_duration)
@duration = (new_duration * 60).to_i
end
end
21. O que é que nós fizemos?
— Criamosmétodos de acesso a um
atributo, mas o cliente não sabe se são
métodos ou se ele está acessando os
atributos diretamente;
— Sobrescrevemos o operador
“=“ (atribuição) para a nossa propriedade,
Ruby tem sobrecarga de operadores
(alguns, apenas)!
22. Constantes,Variáveis e métodos de
classe
class SongList
@@calls_total
MAX_TIME = 5*60 # 5 minutos
MIN_TIME = 1*60 # 1 minuto
def SongList.is_too_long(song)
song.duration > MAX_TIME
end
def self.is_too_short(song)
song.duration < MIN_TIME
end
end
23. E aí?
— Variáveis
de classe são definidas com dois
“@”, como em “@@variavel_de_classe”;
— Constantessão definidas com o seu nome
completo em “caixa alta” (na verdade é só a
primeira letra, mas use o NOME
COMPLETO);
— Métodos
de classe são definidos colocando
o nome da classe antes do nome do método
ou usando “self” (é o “this” em Ruby);
24. acesso aos objetos
class MyClass
def method1 # o padrão é public
end
protected
def method2
end
private
def method3
end
public
def method4
end
end
25. Como acessar?
— Osníveis de acesso são definidos em
blocos, quando não há definição, é public,
quando se quer definir um nível de
acesso, deve-se utilizar um bloco de
acesso;
— Um bloco termina assim que outro se
iniciar;
26. Mas não é ruim não ter tipos?
Eu faço “quack()”, “nadar()”
e “voar()”, igual a qualquer
outro pato, eu sou ou não
um pato?
27. Tudo são mensagens!
— Pois é, você perdeu a aula de Smalltalk né?
— Nãoimporta qual o tipo do objeto, o que
importa são as mensagens (métodos?)
que ele é capaz de responder;
— Se
faz quack, nada e voa feito um pato,
então pra mim é um pato;
28. Arrays
a = [ 3.14159, "pie", 99 ]
a[0] # 3.14159
a[3] # nil
a << 123 # adicionando um item
a[4] = 456 #adicionando outro item
a[-1] # 456 – acessando de trás pra frente
a[2..4] # [99, 123, 456]
29. Explicando arrays
— Arrays
são definidos pela simples
declaração de “[]”, como em “a = []”,
também pode-se fazer “a = Array.new”;
— Arrayssão acessados pelo índice, tanto
positivo (ordem crescente) como
negativo (ordem decrescente);
— Quando se acessa um índice que não
existe em um array, ele retorna “nil”;
30. Explicando arrays
— Novos items podem ser colocados no array
simplesmente utilizando o próprio operador
“[]”, como em “a[10] = 10”;
— Para
se adicionar um item no fim do array
usa-se o operador “<<“, como em “a <<
10”;
— Arrays
podem ser pegos em ‘pedaços’ como
em “a[1..3]”, que cria um novo array com os
itens do índice 1 ao 3;
32. Entendendo hashes
— São
conjuntos de “chave-valor” (Lembra
do Map em Java?);
— São
declarados com o uso de “{}” como
em “h = {}”, ou usando Hash.new;
— Para
se adicionar itens basta usar o
operador [], como em “h[‘chave’] =
‘valor’”;
33. Você consegue explicar isso?
class SongList
def with_title(title)
for i in 0...@songs.length
return @songs[i] if title ==
@songs[i].name
end
return nil
end
end
34. E isso?
class SongList
def with_title(title)
@songs.find {|song| title ==
song.name }
end
end
35. Código solto?
— Blocossão pedaços de código que podem
ser passados como parâmetros para
funções, para fazer algum trabalho
especial, como filtragem, ordenação e
outros;
— Você
pode definir os seus próprios
métodos que aceitam blocos;
36. Strings
'escape using ""' # escape using ""
'That's right' ! #That's right
"Seconds/day: #{24*60*60}" # Seconds/day:
86400
def to_s
“Song: #@song Artist: #{@artist}”
end
37. strings
#Q!String de muitas linhas com aspas
duplas e acessando variáveis #{variavel}!
#q( String de muitas linhas com aspas
simples, aqui não pode ter variável )
‘a’ << ‘b’ << ‘c’ # ‘abc’
38. Como é?
— Strings
são sequências de caracteres de 8
bits, não necessariamente Unicode;
— Elas
podem ser definidas usando ‘’ (aspas
simples) ou “” (aspas duplas);
— Usando aspas duplas você pode colocar
expressões ou variáveis com o uso do
caracter “#” seguido de “{}” para variáveis de
método ou funções ou apenas ‘@’ para
variáveis de instância;
40. O que são ranges?
— São
um conjunto de objetos em
sequência, normalmente caracteres ou
números;
— São definidos através da declaração de
[ ‘valor inicial’ .. ‘valor final’ ], como em
[1..100];
— Você
pode definir os seus próprios ranges
com o operador “<=>” (disco voador?);
41. Criando Seu próprio range
class VU include Comparable
attr :volume
def initialize(volume)
@volume = volume
end
def to_s
'#' * @volume
end
def <=>(other)
self.volume <=> other.volume
end
def succ
raise(IndexError, "Volume too big") if @volume >= 9
VU.new(@volume.succ)
end
end
43. Um pouco mais sobre métodos
def cool_dude(arg1="Miles", arg2="Coltrane",
arg3="Roach")
"#{arg1}, #{arg2}, #{arg3}."
end
cool_dude # "Miles, Coltrane, Roach."
cool_dude("Bart") # "Bart, Coltrane, Roach."
cool_dude("Bart", "Elwood") # "Bart, Elwood,
Roach."
cool_dude("Bart", "Elwood", "Linus") # "Bart,
Elwood, Linus."
44. Um pouco mais sobre métodos
def meth_three
100.times do |num|
square = num*num
return num, square if square > 1000
end
end
num, square = meth_three
45. Um pouco mais sobre metodos
def five(a, b, c, d, e)
"I was passed #{a} #{b} #{c} #{d} #{e}"
end
five(1, 2, 3, 4, 5 ) # "I was passed 1 2 3 4 5"
five(1, 2, 3, *['a', 'b']) # "I was passed 1 2 3 a
b"
five(*(10..14).to_a) # "I was passed 10 11
12 13 14"
46. Ainda em métodos
class SongList
def create_search(name, params)
# ...
end
end
list.create_search('short jazz songs',
:genre => :jazz,
:duration_less_than => 270)
47. If/unless
puts "a = #{a}" if debug
print total unless total.zero?
if x == 2
puts x
elsif x < 0
puts “#{x} é menor que zero”
else
puts ‘Caiu no else’
end
48. Case/when (conhece o swiTch?)
leap = case
when year % 400 == 0 then true
when year % 100 == 0 then false
else year % 4 == 0
end
49. Que lindo switch
case input_line
when "debug"
dump_debug_info
dump_symbols
when /ps+(w+)/
dump_variable($1)
when "quit", "exit"
exit
else
print "Illegal command: #{input_line}"
end
50. while
print "Hellon" while false
begin
print "Goodbyen"
end while false
while x < 10
puts “X é #{x}”
x=x+1
end
51. Quem precisa de um for?
3.times do
print "Ho! “
end
0.upto(9) do |x|
print x, " "
end
[ 1..5 ].each {|val| puts “ #{val} ” }
52. Mas você ainda quer um for?
for i in ['fee', 'fi', 'fo', 'fum']
print i, " "
end
for i in 1..3
print i, " "
end
53. Break, redo e next
while line = gets
next if line =~ /^s*#/ # pular comentários
break if line =~ /^END/ # parar no fim
# executar coisas
redo if line.gsub!(/`(.*?)`/) { eval($1) }
# process line ...
end
54. Tente outra vez
for i in 1..100
print "Now at #{i}. Restart? "
retry if gets =~ /^y/i
end