slides de uma pequena acção de formação com o objectivo de introduzir a linguagem de programação ruby

1. ruby
a programmer’s best friend

2. introdução ao ruby
índice de conteúdos
introdução
ferramentas cli
nomenclatura & tipos de dados
módulos & classes
blocos & iteradores
excepções & introspecção
rubygems
http://www.ruby-lang.org/pt/

3. = +
introdução ao ruby
a linguagem de programação
:definir => “origem”
criada em 1995 no Japão, por Yukihiro Matsumoto
licenciada sob a GPL – Free Software
multi-plataforma (Windows, Linux, MacOS X, *BSD)
:definir => “linguagem”
dinâmica
linguagem de alto nível, interpretada no momento de execução – facilita a extensão dos programas,
através da modificação dos objectos durante o período de execução
reflectiva
capacidade de introspecção – permite a análise e alteração da estrutura e comportamento do
programa
orientada a objectos – “everything is an object”
5.times { print “Eu *adoro* Ruby!quot; }
http://www.ruby-lang.org/pt/

4. introdução ao ruby
o exemplo clássico
:definir => “hello world #1”
$ ruby -e quot;puts 'Hello World'quot;
:definir => “hello world #2”
$ ruby -e quot;def hello_world; puts 'Hello World'; end; hello_worldquot;
:definir => “hello world #3”
$ ruby -e quot;class HelloWorld; def initialize; puts 'Hello World'; end; end;
HelloWorld.newquot;
4
http://www.ruby-lang.org/pt/

5. introdução ao ruby
ferramentas CLI
:definir => “ri”
ruby information
interface de linha de comando para a documentação do Ruby -- classes, módulos, etc
steel:~ mgcm$ ri IO#puts
Writes the given objects to _ios_ as with +IO#print+. Writes a
record separator (typically a newline) after any that do not
already end with a newline sequence. If called with an array
argument, writes each element on a new line. If called without
arguments, outputs a single record separator.
:definir => “irb”
interactive ruby
shell interactiva, útil para testar pequenos programas ou avaliar expressões rapidamente
steel:~ mgcm$ irb
irb(main):001:0> def soma(n1, n2)
irb(main):002:1> n1 + n2
irb(main):003:1> end
=> nil
irb(main):004:0> soma(2, 3)
=> 5
irb(main):005:0>
http://www.ruby-lang.org/pt/

6. introdução ao ruby
conceitos base - variáveis
:definir => “nomenclatura das variáveis”
variáveis locais
foo = “bar“
a_minha_variavel_com_o_valor_pi = 3.1415
variáveis globais e constantes
$foo = “bar_global“
$COS_PI = Math.cos(Math::PI)
classes , variáveis de instância e variáveis de classe
class MyClass
def initialize
@@my_class_variable = Hash.new
@my_instance_variable = Array.new
end
end
http://www.ruby-lang.org/pt/

7. introdução ao ruby
conceitos base - estruturas de dados
:definir => “tipos de dados”
vectores hashes
irb(main):001:0> a = [] irb(main):001:0> h = {}
=> [] => {}
irb(main):002:0> a.class irb(main):002:0> h.class
=> Array => Hash
irb(main):003:0> a, b = [1, 2], [3, 4] irb(main):003:0> h = {:key => “value”}
=> [[1, 2], [3, 4]] irb(main):004:0> h.values
irb(main):004:0> a + b => [”value”]
=> [1, 2, 3, 4] irb(main):005:0> h.keys
=> [:key]
intervalos e expressões regulares
inteiros, reais e strings
irb(main):001:0> 1..100.class
irb(main):001:0> 1.class
=> Range
=> Fixnum
irb(main):003:0> /^ruby/.class
irb(main):002:0> 2.0.class
=> Regexp
=> Float
irb(main):003:0> “3.1415”.class
=> String
http://www.ruby-lang.org/pt/

8. introdução ao ruby
conceitos base - fluxo
:definir => “controlo de execução”
if-elsif-else-end while
if count > 10 while i < 100 and count > 0
puts “maior de 10” fazer_algo_util
elsif i == 3 i += 1
puts “igual a três” end
else
until
puts “outra coisa qq”
end
until a == true
a = false
case end
case my_string
for
when “hello” then puts “world”
when “goodbye” then puts “cruel world” for i in 0..100
end total += i
end
unless formas concisas
unless i > 5 puts “i maior do que 5” if i > 5
puts “i menor do que 5” i = i + 1 while i < 100
end puts “i menor do que 5” unless i > 5
8
http://www.ruby-lang.org/pt/

9. introdução ao ruby
conceitos base - oop
:definir => “classes”
conta.rb irb
irb(main):001:0> load “conta.rb”
class ContaBancaria
=> true
attr_reader :saldo
irb(main):002:0> c = ContaBancaria.new 123
=> #<ContaBancaria:0x386198 @saldo=123>
def initialize(saldo_inicial)
irb(main):003:0> c.credito 150
@saldo = saldo_inicial
=> 273
end
irb(main):004:0> c.debito 99
=> 174
def credito(valor)
irb(main):005:0> puts c
@saldo += valor
A sua conta tem um saldo de € 174
end
=> nil
def debito(valor)
@saldo -= valor if (@saldo - valor) > 0
end
def to_s
quot;A sua conta tem um saldo de € #{@saldo}quot;
end
end
http://www.ruby-lang.org/pt/

10. introdução ao ruby
conceitos base - herança
:definir => “herança simples”
conta.rb
class ContaOrdenado < ContaBancaria
attr_reader :saldo, :plafond
def initialize(saldo_inicial, plafond)
super(saldo_inicial)
@plafond = plafond if plafond <= ContaOrdenado.plafond_maximo
end
def debito(valor)
@saldo -= valor if (@saldo - valor) > plafond
end
def ContaOrdenado.plafond_maximo
10000
end
end
irb
irb(main):001:0> ContaOrdenado.plafond_maximo
=> 10000
irb(main):002:0> c = ContaBancaria.new 123
=> #<ContaBancaria:0x386198 @saldo=123>
irb(main):003:0> o = ContaOrdenado.new 0, 100
=> #<ContaOrdenado:0x343280 @saldo=0, @plafond=100>
irb(main):004:0> c.class
=> ContaBancaria
irb(main):005:0> o.class
=> ContaOrdenado http://www.ruby-lang.org/pt/

11. introdução ao ruby
conceitos base - módulos
:definir => “módulos”
Módulos::Namespaces
são uma forma lógica de agrupar métodos, classes e constantes. Permitem:
‣ o agrupamento em namespaces, evitando assim colisções de nomes
module Trig irb(main):001:0> require ‘trig’
PI = 3.141592654 => true
irb(main):002:0> y = Trig.sin(Trig::PI/4)
def Trig.sin(x) => 0.707106781186548
# ...
end
Ao contrário de uma classe, um módulo não pode ser instanciado!
def Trig.cos(x)
# ...
end
...
end
http://www.ruby-lang.org/pt/

12. introdução ao ruby
conceitos base - mixins
:definir => “módulos”
Módulos::Mixins
são uma forma lógica de agrupar métodos, classes e constantes. Permitem:
‣ a criaçao de mixins, uma técnica que substitui a herança múltipla de classes, através da
inclusão de módulos em classes
module Observable class TVChannel
def observers include Observable
@observer_list ||= []
end def subscribe(client)
add_observer(client)
def add_observer(obj) end
observers << obj end
end
def notify_observers
observers.each { |o| o.update }
end
end
http://www.ruby-lang.org/pt/

13. introdução ao ruby
conceitos base - novos conceitos
:definir => “blocos e iteradores”
for i in 0..my_array.length
return my_array[i] if my_array[i] == “ruby” my_array.find { |item| item == “ruby” }
end
bloco iterador
conjunto de instruções cujo controlo de execução é um método que pode invocar um bloco de código
passado a um método invocado, tipicamente iterador
class Array
10.times { |i| print i, “ ” }
def find
for i in 0..size
10.times do |i| value = self[i]
print i, “ “ return value if yield(value)
end end
return nil
end
end
13
http://www.ruby-lang.org/pt/

14. introdução ao ruby
conceitos base - erros
:definir => “excepções”
tratamento de excepções
begin
# código sensível
rescue Exception => ex
puts “Erro: #{ex.message}”
# código que trata a excepção caso esta ocorra
ensure
# código a executar após a ocorrência da excepção
end
levantamento de excepções
def o_meu_metodo(valor)
raise “Não aceito valores negativos” if valor < 0
end
http://www.ruby-lang.org/pt/

15. introdução ao ruby
reflexão e introspecção
:definir => “introspecção”
com recurso aos mecanismos de introspecção existentes no Ruby, é possível analisar um programa
em execução e descobrir:
‣ quais os objectos que este contêm
‣ a hierarquia das classes desses objectos
‣ os atributos e métodos desses objectos
‣ extender e alterar os módulos e classes do programa em execução
métodos de um objecto Fixnum
irb(main):043:0> 123.methods
=> [quot;%quot;, quot;inspectquot;, quot;sendquot;, quot;<<quot;, quot;prec_iquot;, quot;divmodquot;, quot;&quot;, quot;clonequot;, quot;>>quot;, quot;integer?quot;,
quot;chrquot;, quot;public_methodsquot;, quot;__send__quot;, quot;equal?quot;, quot;freezequot;, quot;*quot;, quot;+quot;, quot;truncatequot;, quot;to_fquot;,
quot;methodsquot;, quot;instance_evalquot;, quot;-quot;, quot;moduloquot;, quot;prec_fquot;, quot;zero?quot;, quot;to_intquot;, quot;/quot;, quot;sizequot;,
quot;dupquot;, quot;instance_variablesquot;, quot;extendquot;, quot;instance_of?quot;, quot;nextquot;, quot;|quot;, quot;eql?quot;, quot;hashquot;,
quot;~quot;, quot;idquot;, quot;stepquot;, quot;singleton_methodsquot;, quot;remainderquot;, quot;taintquot;, quot;nonzero?quot;, quot;id2namequot;,
quot;frozen?quot;, quot;instance_variable_getquot;, quot;^quot;, quot;methodquot;, quot;kind_of?quot;, quot;floorquot;, quot;to_aquot;, quot;+@quot;,
quot;-@quot;, quot;quoquot;, quot;displayquot;, quot;typequot;, quot;**quot;, quot;downtoquot;, quot;<quot;, quot;protected_methodsquot;, quot;<=>quot;, quot;==quot;,
quot;absquot;, quot;>quot;, quot;===quot;, quot;to_symquot;, quot;instance_variable_setquot;, quot;coercequot;, quot;is_a?quot;, quot;ceilquot;, quot;>=quot;,
quot;respond_to?quot;, quot;uptoquot;, quot;between?quot;, quot;to_squot;, quot;<=quot;, quot;precquot;, quot;divquot;,
quot;singleton_method_addedquot;, quot;object_idquot;, quot;timesquot;, quot;classquot;, quot;tainted?quot;, quot;=~quot;,
quot;private_methodsquot;, quot;__id__quot;, quot;nil?quot;, quot;succquot;, quot;untaintquot;, quot;[]quot;, quot;roundquot;, quot;to_iquot;]
http://www.ruby-lang.org/pt/

16. introdução ao ruby
reflexão e introspecção
:definir => “introspecção”
outras funcionalidades
irb(main):001:0> ContaBancaria.new(100).respond_to?(quot;plafondquot;)
=> false
irb(main):002:0> ContaOrdenado.new(100,10).respond_to?(quot;plafondquot;)
=> true
irb(main):003:0> 123.class
=> Fixnum
irb(main):004:0> 123.instance_of?(Fixnum)
=> true
irb(main):005:0> ContaOrdenado.superclass
=> ContaBancaria
irb(main):006:0> ContaOrdenado.ancestors
=> [ContaOrdenado, ContaBancaria, Object, Kernel]
irb(main):064:0> ContaOrdenado.singleton_methods
=> [quot;plafond_maximoquot;]
... instance_methods, instance_variables, class_variables, constants, etc...
http://www.ruby-lang.org/pt/

17. introdução ao ruby
bibliotecas de código
:definir => “gems”
RubyGems
são formas de distribuir e instalar aplicações e bibliotecas de código ruby, alojadas em repositórios centrais
Exemplos:
‣ rake - uma espécie de Make para Ruby
‣ ruby-net-ldap - cliente LDAP para ruby
‣ rails - plataforma de desenvolvimento web
‣ etc...
‣ mais de 2000 disponíveis online: $ gem list --remote
require ‘rubygems’
require ‘gem_xyz’
http://www.ruby-lang.org/pt/

18. introdução ao ruby
exercício prático
:definir => “exercícios”
valores.csv
formato: fruto, unidades, preço unitário
‣ guardar num vector todos os frutos distintos e ordenar por
ordem alfabética
‣ criar em tempo de execução um objecto para cada uma das
linhas, cuja classe seja do tipo da fruta adequada
http://www.ruby-lang.org/pt/