O que mudou no Ruby 2.0

O que mudou no Ruby 2.0

Veja a palestra apresentada no 29º GURU-SP.

Cb5d9e9095cd41b636764a85e57ade4b?s=128

Nando Vieira

April 13, 2013
Tweet

Transcript

  1. 7.

    RUBY 1.8 Se você ainda está usando Ruby 1.8, corra

    e atualize sua aplicação. Em junho esta versão deixará receber atualizações, inclusive de segurança.
  2. 8.

    RUBY 1.9 O primeiro release estável saiu em dezembro de

    2009 e trouxe uma série de mudanças incompativeis com o Ruby 1.8.
  3. 9.

    RUBY 2.0 Lançada em fevereiro de 2013, esta versão possui

    compatibilidade quase que total com o Ruby 1.9.
  4. 14.

    Keyword Arguments Há sintaxe de hashes e argumentos nomeados foi

    proposta há quase 11 anos e, só agora, foi completamente implementada. http://fnando.me/d2
  5. 21.

    class Sample def method_missing(name, *args, &block) p args end end

    sample = Sample.new sample.say :what, :are, :you, :doing? #=> [:what, :are, :you, :doing?]
  6. 23.

    class Sample def method_missing(name, *args, **keys, &block) p keys end

    end sample = Sample.new sample.say what: "are", you: "doing?" #=> {:what=>"are", :you=>"doing?"}
  7. 25.
  8. 26.

    def params(a, b = nil, *args, c: nil, **kwords, &block)

    end [ [:req, :a], [:rest, :args], [:key, :c], [:keyrest, :kwords], [:block, :block] ]
  9. 27.

    Literais no Ruby O Ruby possui muitos literais para de

    nir strings e arrays. Agora também podemos de nir arrays de símbolos.
  10. 30.

    Encoding O encoding padrão do no Ruby 1.9 é US-ASCII.

    Para usar caracteres acentuados era preciso usar o magic comment.
  11. 36.

    class MyClass foo_method = instance_method(:foo) define_method :foo do puts "before

    foo" result = foo_method.bind(self).call puts "after foo" result end end MyClass.new.foo #=> before foo #=> original #=> after foo
  12. 37.

    De nir um alias para o método original e sobrescrever

    o método original com a nova implementação.
  13. 38.

    class MyClass alias_method :foo_original, :foo def foo puts "before foo"

    result = foo_original puts "after foo" result end end MyClass.new.foo #=> before foo #=> original #=> after foo
  14. 40.

    require "active_support/all" class MyClass def foo_with_puts puts "before foo" result

    = foo_without_puts puts "after foo" result end alias_method_chain :foo, :puts end MyClass.new.foo #=> before foo #=> original #=> after foo
  15. 42.

    module FooExtension def foo puts "before foo" super puts "after

    foo" end end class MyClass prepend FooExtension end MyClass.new.foo #=> before foo #=> original #=> after foo
  16. 43.
  17. 45.

    Classes abertas Classes abertas e monkey patching sempre foi um

    motivo de preocupação dos iniciantes.
  18. 46.

    Re nements O Re nements tenta amenizar esta situação permitindo

    fazer monkey patching de modo controlado.
  19. 50.

    Re nements Existem tantas incertezas em relação ao re nements

    e isso é reforçado através de um warning ao usar o método Module.re ne.
  20. 53.

    require "ostruct" user = OpenStruct.new( name: "John Doe", email: "john@example.org"

    ) puts user.name #=> John Doe puts user.email #=> john@example.org
  21. 57.

    Regexp O Ruby 2.0 mudou seu engine de expressão regular

    mais uma vez. O Oniguruma saiu para dar lugar ao Onigmo.
  22. 58.

    text = "Line 1\r\nLine 2\vLine 3\nLine 4" lines = text.split(/\R/)

    p lines #=> ["Line 1", "Line 2", "Line 3", "Line 4"]
  23. 60.

    regex = /^(\[a-z]{2})(\1)?(?(2)([a-z]+)|(\d+))$/ "aaaabbbbb".match(regex) #<MatchData "aaaabbbbb" 1:"aa" 2:"aa" 3:"bbbbb" 4:nil>

    "ababccccc".match(regex) #<MatchData "ababccccc" 1:"ab" 2:"ab" 3:"ccccc" 4:nil> "ab1111111".match(regex) #<MatchData "ab1111111" 1:"ab" 2:nil 3:nil 4:"1111111"> "abccccccc".match(regex) # nil "1212ccccc".match(regex) # nil
  24. 61.
  25. 71.

    %[Line 1\nLine 2\nLine 3].lines #=> ["Line 1\n", "Line 2\n", "Line

    3"] %[abcdef].chars #=> ["a", "b", "c", "d", "e", "f"] %[abcdef].bytes #=> [97, 98, 99, 100, 101, 102] %[abcdef].codepoints #=> [97, 98, 99, 100, 101, 102]
  26. 72.

    Enumerator#lazy O Ruby 2.0 introduziu um modo de criarmos enumerators

    que podem ser executados em conjuntos grandes ou mesmo in nitos.
  27. 74.

    require "prime" range = (0..Float::INFINITY) primes = range.lazy .reject {|number|

    number < 50 } .select(&:prime?) .first(10) primes #=> [53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
  28. 75.

    require "benchmark" require "prime" GC.disable range = (0..1000) cycles =

    1_000 def primes(range) range .reject {|number| number < 50 } .select(&:prime?) .first(10) end Benchmark.bmbm do |x| x.report("with lazy") do cycles.times { primes(range.lazy) } end x.report("without lazy") do cycles.times { primes(range) } end end
  29. 76.

    Rehearsal ------------------------------------------------ with lazy 0.250000 0.020000 0.270000 ( 0.265709) without

    lazy 4.740000 0.390000 5.130000 ( 5.219114) --------------------------------------- total: 5.400000sec user system total real with lazy 0.260000 0.020000 0.280000 ( 0.280212) without lazy 5.090000 0.420000 5.510000 ( 5.576948)
  30. 77.

    Muito mais! Backtrace otimizado, TracePoint, DTrace, __callee__, otimizações na VM

    (fork mais rápido), melhorias no Garbage Collector, Kernel#require mais rápido, Rubygems com suporte ao Gem le, e mais um monte de coisas!
  31. 78.