Curso Ruby

1. Curso de Ruby Regis Pires Magalhães [email_address] “ A melhor forma de prever o futuro é inventá-lo.” Alan Kay

3. Entrada / Saída

4. Comentários

5. Convenções

6. Variáveis, Constantes

7. Operadores

8. Tipos

9. Estruturas de Controle

10. Orientação a Objetos no Ruby

11. Meta-programação

12. Tratamento de Exceções

13. Módulos

14. Mixin

15. Procs

16. Fechamento ou Closure

18. Matz nasceu no Japão em 1965.

19. Junta as melhores partes de gigantes do passado e do presente.

20. Mais usada no Japão que Python.

21. Popularizada pelo Rails.

22. Ruby Segundo Matz: “ Ruby é uma linguagem de scripting interpretada cujo objetivo é tornar a programação orientada a objetos simples e rápida. (...) É simples, direta, extensível e portável.” Fonte: http://www2.ruby-lang.org/en/20020101.html

24. Tipagem forte;

25. Livre / Open Source;

26. Foco na simplicidade e produtividade ;

27. Programação divertida ;

28. Interpretada;

29. Mixins, blocos e fechamentos;

30. Totalmente orientada a objetos.

31. Classes e objetos são abertos para redefinições a qualquer momento

33. JRuby – Implementação em Java

36. IronRuby – Implementação em .NET

37. MagLev – Ruby sobre VM da GemStone (excelente VM SmallTalk)

41. Testando o Ruby ruby -v

43. Permite executar trechos de códigos Ruby, retornando o resultado de imediato. C : InstantRails rails_apps > irb irb ( main ) :001:0 > a = 123 => 123 irb ( main ) :002:0 > b = 456 => 456 irb ( main ) :003:0 > a * b => 56088 irb ( main ) :004:0 >

45. Com o irb já em execução:

47. Qualquer coisa que não seja executado dentro de um método, está implicitamente sendo executado dentro do método main da classe Object . irb ( main ) :001:0 > puts self . class Object => nil irb ( main ) :002:0 > puts self main => nil

48. Totalmente orientada a objetos 1.class # => Fixnum 1.class . class # => Class 1.class . superclass # => Integer

50. A classe Fixnum é instância da classe Class.

51. Class define todas as classes em Ruby.

52. Class é uma metaclasse, ou seja, uma classe que descreve uma classe.

54. Metaclasses: Object => Module => Class

57. Exemplo.methods é diferente de Exemplo.new.methods . Totalmente orientada a objetos Object . class # => Class class Exemplo ; end Exemplo . class # => Class Exemplo . methods # => [...]

58. O método methods 1.methods.sort 1.public_methods.sort 1.protected_methods.sort 1.private_methods.sort String.methods.sort

59. Entrada / Saída nome = gets . chomp Pedro # => "Pedro" puts nome Pedro # => nil chomp -> mastigar, roer

60. Comentários x = y + 5 # Isto é um comentário de linha. # Isto é um outro comentário de linha. =begin Isto é um comentário de bloco. =end

61. Convenções NomesDeClasse nomes_de_metodos e nomes_de_variaveis metodos_fazendo_pergunta? metodos_perigosos! @variaveis_de_instancia @@variaveis_de_classe $variaveis_globais ALGUMAS_CONSTANTES ou OutrasConstantes

63. São fortemente tipadas: 2 + "2" não é possível.

64. Variáveis locais: quantidade_dias = 3

66. Variáveis de classe: @@vogais = ['a', 'e', 'i', 'o', 'u']

68. Variáveis são referências para objetos. ~ $ irb irb ( main ) :001:0 > a = 1 => 1 irb ( main ) :002:0 > a = "1" => "1" '

70. Igualdade e comparação: >, >=, <, <=, ==, <=> ... etc.

71. Atribuição: =, +=, -=, *=, /=, ||= ... etc.

72. Lógico: &&, and, ||, or, !, not ... etc.

73. Ternário: (a == 2 ? "Dois" : "Outra coisa")

76. Devem iniciar em caixa alta: PI = 3.14

77. Por convenção possuem todas as letras em caixa alta!

78. Podem ser alteradas: NOME = "Sapo" NOME = "Gato" # Gera um alerta warning: already initialized constant NOME

80. Booleanos

81. nil

82. Strings

83. Ranges

84. [Arrays]

85. {Hashes}

86. :simbolos

87. Expressões Regulares

89. Eles podem ter qualquer tamanho O tamanho do inteiro é que define seu tipo: n = 1000000 # => 1000000 n . class # => Fixnum n = 1000000000000000 # => 1000000000000000 n . class # => Bignum

91. A classe Bignum pode representar número com precisão infinita, restrita somente à memória e processamento da máquina.

95. Pode carregar caracteres "imprimíveis" ou dados binários.

96. Podem ser delimitadas por aspas 'simples' ou "duplas".

97. Podem ocupar várias linhas, sem precisar ficar concatenando.

98. Strings s = "Curso de Ruby" s [ 0 ] # => 67 s [ 0 ]. chr # => "C" s [ 6 , 2 ] # => "de" s [ 6 . . 7 ] # => "de"

99. Strings – Métodos Destrutivos a = "Ruby" # => "Ruby" a . object_id # => 20641550 a . upcase # => "RUBY" a # => "Ruby" a . upcase! # => "RUBY" a # => "RUBY" a . object_id # => 20641550 a.downcase! # => "ruby" a # => "ruby"

102. Strings longas nome = "Descartes" s = << FIM Penso, logo existo é uma frase de #{nome} FIM puts s # Penso, logo existo # é uma frase de Descartes

103. Strings a = "valor" # => "valor" 'aspas simples: #{a}' # => "aspas simples: {a}" "aspas duplas: #{ a } " # => "aspas duplas: valor" %( marcadores especiais : #{a}) # => "marcadores especiais: valor" s = << FIM string com quebra de linha FIM # => "string com quebra de linha" 'sem interpolacao,' "interpolacao e contrabarras" %q(sem interpolacao) %Q(interpolacao e contrabarras) %(interpolacao e contrabarras)

104. Comparação de Strings a = "Uma string qualquer" b = String . new ( "Uma string qualquer" ) a == b # => true

105. Strings - Métodos s = "Ruby on Rails" s . gsub ( ' ' , '-' ) # => "Ruby-on-Rails" s . gsub ( /[aeiou]/ , '_' ) # => "R_by _n R__ls" s . index ( 'on' ) # => 5 "hello" . chomp #=> "hello" "hello there" . chomp #=> "hello there" "hello" . chomp ( "llo" ) #=> "he" s = 'Ruby on Rails' s [ 5 , 2 ] # => "on" s [ 5..6 ] # => "on " "Ruby" .reverse # => "ybuR"

107. 1..7 inclui 1, 2, 3, 4, 5, 6 e 7

108. 1...7 não inclui o 7 "Ruby" [ 1 . . 2 ] # --> "ub" [ 1 , 2 , 3 , 4 , 5 ][ 1 . . 2 ] # --> [2,3] ( 2 . . 10 ) === 3 # true ( "a" .. "z" ). each {| i | puts i } for n in 5 . . 10 ; puts n ; end

111. [Arrays] a = [ 1 , 2 , 3 , 4 , 5 ] puts a 1 2 3 4 5 puts a.inspect [ 1 , 2 , 3 , 4 , 5 ]

112. %w – array de palavras a = %w(curso de ruby on rails) => [ "curso" , "de" , "ruby" , "on" , "rails" ] nome , sobrenome = 'regis' , 'pires' a = %w(#{ nome } #{ sobrenome }) => [ "{nome}" , "{sobrenome}" ] a = %W(#{ nome } #{ sobrenome }) => [ "regis" , "pires" ]

113. Arrays s = 'Ruby on Rails' s . split ( ' ' ) # => ["Ruby", "on", "Rails"] a = %w(um dois tres quatro cinco seis sete oito nove dez) => [ "um" , "dois" , "tres" , "quatro" , "cinco" , "seis" , "sete" , "oito" , "nove" , "dez" ] a . grep ( /s$/ ) => [ "dois" , "tres" , "seis" ]

115. Cada entrada é composta por uma chave (única) e um valor a = { 'um' => 1 , 'bola' => 2 , 3 => 'Maria' } a . class => Hash a [ 1 ] => nil a [ 'um' ] => 1 a . length => 3 a = Hash . new a = {}

118. :simbolos :nome . to_s # => "nome"

121. then é opcional no if e unless

123. Estruturas de Controle puts 'ola' if not a or not b puts 'oi' unless y != 3 if x < 5 then puts 'menor que 5' end x = if a>0 then b else c end x = unless a<=0 then c else b end

125. Estruturas de Controle case scale when 'C' , 'c' F = 1.8 * temp + 32 when 'F' , 'f' C = ( 5.0 / 9.0 ) * (temp- 32 ) else abort "Must specify C or F." end

128. Estruturas de Controle list = [ 1 , 2 , 3 ] i= 0 while i < list.size do print " #{list[i]} " i += 1 end list = [ 1 , 2 , 3 ] i= 0 until i == list.size do print " #{list[i]} " i += 1 end

129. Laços contados 1.upto ( 10 ) { |x| puts x } 10.downto ( 1 ) { |x| puts x } 10.step ( 1 , - 2 ) { |x| puts x }

133. ola.rb def diga_ola ( nome ) if nome [ 0. . 3 ] == 'Matz' puts 'Ah, foi vc quem criou o Ruby!' else puts ( "Ola #{ nome } " ) end end print "Qual o seu nome? " nome = gets # Pede uma entrada do usuario diga_ola nome

134. Date require 'date' c = Date.today d = Date . new ( 2010 , 10 , 21 ) # => #<Date: 4910981/2,0,2299161> d . day # => 21 d .mon # => 10 d .month # => 10 d . year # => 2010 d .wda y # => 4 d .mda y # => 21 d . yday # => 294 d . to_s # => "2010-10-21" dt = DateTime.now t = Time.now

135. Arquivos f = File.new( "teste.txt" , "w" ) f << "linha um" f << "linha dois" f << "linha tres" f.close a = File.readlines( "teste.txt" ) => [ "linha um" , "linha dois" , "linha tres" ] a = File.readlines( "teste.txt" ).find_all {|l| l =~ /s$/} => [ "linha dois" , "linha tres" ]

136. UDP Server require 'socket' porta = 12345 s = UDPSocket.new s.bind( "localhost" ,porta) puts "Servidor iniciado na porta #{porta} ..." loop do msg,sender = s.recvfrom( 256 ) host = sender[ 3 ] puts "Host #{host} enviou um pacote UDP: #{msg} " end s.close

137. UDP Client require 'socket' porta = 12345 s = UDPSocket.open s.connect( "localhost" , porta) s.send(ARGV[ 0 ], 0 ) s.close

139. São delimitados por {...} ou do...end .

140. Convenção: use {...} em uma só linha, e do...end para várias linhas.

141. Podem receber parâmetros: meu_array . each { | obj | puts obj } ( 1. . 10 ). each { | i | puts i } ( "a" .. "z" ). each { | i | puts i }

143. Arquivos com blocos de código File.open( "teste.txt" , 'w' ) do |f| f << "linha um" f << "linha dois" f << "linha tres" end File.readlines( "teste.txt" ).each {|l| puts l} File.open( "teste.txt" ) do |f| f.each_line do |l| print l end end Vantagem: não há perigo de esquecer o arquivo aberto, pois ele é fechado automaticamente.

145. “Getters” e “Setters”

146. Variáveis de classe e de instância

147. Métodos de classe e de instância

148. Herança

149. Visibilidade dos Membros

151. Os objetos possuem dados (atributos/variáveis) e comportamentos (métodos).

152. Objetos também são chamados de instâncias.

153. 3, 12, 999 são instâncias da classe Fixnum.

155. Usamos o ponto (.) para acessar os métodos: @pessoa.nome .

157. Classes e Objetos class Pessoa def initialize (nome, idade) @nome = nome @idade = idade end def to_s " #{ @nome } tem #{ @idade } anos" end end p1 = Pessoa . new ( "Paulo" , 12) p2 = Pessoa . new ( "Marcio" , 34 )

159. initialize é automaticamente definido como private.

161. Ou utilizamos 'atalhos' para isso: attr_reader, attr_writter, attr_accessor .

162. “Getters” e “Setters” class Pessoa def initialize ( nome , idade ) @nome = nome @idade = idade end def nome= ( nome ) @nome = nome end def nome @nome end attr_accessor :idade end

164. O valor de uma variável de classe é compartilhado com as suas instâncias

165. Variáveis de classe e de instância class Pessoa @@numero_pessoas = 0 # Atrib de classe def initialize ( nome , idade ) @nome = nome # Atrib.de instância @idade = idade @@numero_pessoas += 1 end def numero_pessoas @@numero_pessoas end end

167. Métodos de classe não acessam atributos de instância.

168. Método de instância: p.dados .

171. Math é uma constante que referencia um objeto Module .

172. File é uma constante que referencia um objeto Class .

173. Métodos de classe e de instância class Pessoa @@numero_pessoas = 0 def initialize ( nome , idade ) @nome = nome @idade = idade @@numero_pesssoas += 1 end def self . numero_pessoas @@numero_pessoas end end p = Pessoa . new 'Joao' , 23 p2 = Pessoa . new 'Maria' , 21 Pessoa . numero_pessoas # => 2 p .to_s # => "Joao tem 23 anos"

176. A classe mais genérica é chamada de super-classe, e a mais específica de sub-classe.

177. Em Ruby existe apenas herança simples, embora possamos simular herança múltipla através de mixins.

178. O super chama o correspondente da super-classe.

179. Herança class B < A end

180. Herança class PessoaFisica < Pessoa def initialize ( nome , idade , cpf ) super ( nome , idade ) @cpf = cpf end # Método dados redefinido def to_s super + ", Cpf= #{ @cpf } " end end

182. Protegidos - chamados apenas pela família.

184. public , protected e private são métodos que modificam a classe dinamicamente e mantém o escopo de acesso até que outro escopo seja chamado.

185. Visibilidade dos Membros class MinhaClasse # Público é o default def metodo1 ... end protected # os seguintes serão protegidos def metodo2 ... end private # os seguintes serão privados def metodo3 ... end public # os seguintes serão públicos def metodo4 ... end end

187. Meta-programação Cao = Class . new Cao . class_eval << FIM def latir puts "Au, Au" end FIM c = Cao . new # => #<Cao:0x2ae93c0> c . latir # => nil Au , Au Programação de programas que escrevem ou manipulam outros programas (ou a si próprios)

189. Meta-programação class Object class << self def reader (* params ) for p in params self . class_eval "def #{ p } ; @ #{ p } ; end" end end end end Cria dinamicamente um “getter” semelhante a attr_reader.

193. Podem ter variáveis, constantes e métodos.

194. Não podem ser instanciados.

197. Módulos # No arquivo calc.rb module Calc PI = 3.141592654 def self . seno ( x ) puts "calc.seno de #{x}" end def self . cosseno ( x ) puts "calc.cosseno de #{x}" end end # Em outro programa carregamos o arquivo # calc.rb usando require 'calc' # Chamamos métodos com "." e constantes com "::" y = Calc . seno ( Calc :: PI / 4 )

199. Mixin module MyArray def hello puts "Oi! #{ self . length } " if self . respond_to? :length end end class String include MyArray end class Array include MyArray end str = 'teste' arr = [ 1 , 2 , 3 ] str . hello # "Oi!5" arr . hello # "Oi!3"

203. include Modulo1, Modulo2

205. Procs encapsulam blocos em objetos.

206. Pode-se usar Proc.new , proc ou lambda . vezes3 = Proc . new {| n | n * 3 } vezes3 . call ( 1 ) => 3 vezes3 . call ( 2 ) => 6 vezes3 . call ( 3 ) => 9

209. Closures podem fazer referência a variáveis visíveis no momento em que elas foram definidas.

210. Closure = bloco de código + ligações ao ambiente do qual vieram.

211. São métodos anônimos com escopo fechado.

212. São métodos que carregam o contexto no qual foram criados.

213. O bloco pode usar todas as informações do seu contexto original mesmo que o ambiente no qual ele foi definido não mais exista.

214. Fechamento ou Closure def faz2 yield yield end faz2 { puts 'oi' }

215. Fechamento ou Closure class Array def each2 for element in self yield element end end end a = [ 1 , 2 , 3 ] a . each2 { | i | puts i }

218. Fechamento ou Closure def n_vezes ( algo ) Proc . new {| n | algo * n } end p1 = n_vezes 2 p1 . call ( 3 ) => 6 p1 . call ( 4 ) => 8 p2 = n_vezes 'Oi ' p2 . call ( 3 ) => "Oi Oi Oi "

220. Rubygems é o projeto que desenvolveu o sistema de pacotes gem.

221. Simplifica bastante a instalação de bibliotecas em Ruby.

223. Testes "Sempre que estiver tentado a escrever um print ou uma expressão de depuração, escreva um teste." Martin Fowler

224. Testes class Retangulo def initialize (base, altura) @base = base @altura = altura end def area () @base * @altura end def perimetro () 2 * @base + 2 * @altura end end

225. Testes com RUnit # retangulo_test.rb require 'test/unit' require 'retangulo' class RetanguloTest < Test::Unit::TestCase def setup @r = Retangulo.new( 2 , 3 ) end def test_area assert_equal( 6 , @r .area) end def test_perimetro assert_equal( 10 , @r .perimetro) end def teardown @r = nil end end

229. Testes com RSpec # retangulo_spec.rb require 'retangulo' describe Retangulo do before( :each ) do @r = Retangulo.new( 2 , 3 ) end it 'calcula area do retangulo' do @r .area.should == 6 end it 'calcula perimetro do retangulo' do @r .perimetro.should == 10 end after( :each ) do @r = nil end end

Curso Ruby

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (18)

Destaque

Destaque (20)

Semelhante a Curso Ruby

Semelhante a Curso Ruby (20)

Mais de Regis Magalhães

Mais de Regis Magalhães (17)

Curso Ruby