Cuál es la diferencia entre Ruby 1.8 y Ruby 1.9

No tengo claro las diferencias entre la versión “actual” de Ruby (1.8) y la versión “nueva” (1.9). ¿Hay una explicación “fácil” o “simple” de las diferencias y por qué es tan diferente?

    Sam Ruby tiene una presentación de diapositivas genial que describe las diferencias .

    Con el interés de poner esta información en línea para una referencia más fácil, y en caso de que el enlace se apague en el futuro abstracto, aquí hay una descripción general de las diapositivas de Sam. La presentación de diapositivas es menos abrumadora para revisar, pero tener todo dispuesto en una lista como esta también es útil.

    Ruby 1.9 – Características principales

    • Actuación
    • Hilos / Fibras
    • Codificación / Unicode
    • gems está (en su mayoría) incorporado ahora
    • si las declaraciones no introducen scope en Ruby.

    ¿Qué ha cambiado?

    Cadenas de caracteres individuales.

    Ruby 1.9

    irb(main):001:0> ?c => "c" 

    Ruby 1.8.6

     irb(main):001:0> ?c => 99 

    Índice de cadenas

    Ruby 1.9

     irb(main):001:0> "cat"[1] => "a" 

    Ruby 1.8.6

     irb(main):001:0> "cat"[1] => 97 

    {“a”, “b”} ya no es compatible

    Ruby 1.9

     irb(main):002:0> {1,2} SyntaxError: (irb):2: syntax error, unexpected ',', expecting tASSOC 

    Ruby 1.8.6

     irb(main):001:0> {1,2} => {1=>2} 

    Acción: Convertir a {1 => 2}


    Array.to_s ahora contiene signos de puntuación

    Ruby 1.9

     irb(main):001:0> [1,2,3].to_s => "[1, 2, 3]" 

    Ruby 1.8.6

     irb(main):001:0> [1,2,3].to_s => "123" 

    Acción: utilice .join en su lugar


    Colon ya no es válido en declaraciones de cuándo

    Ruby 1.9

     irb(main):001:0> case 'a'; when /\w/: puts 'word'; end SyntaxError: (irb):1: syntax error, unexpected ':', expecting keyword_then or ',' or ';' or '\n' 

    Ruby 1.8.6

     irb(main):001:0> case 'a'; when /\w/: puts 'word'; end word 

    Acción: use punto y coma, luego o nueva línea


    Las variables de bloque ahora sombrean las variables locales

    Ruby 1.9

     irb(main):001:0> i=0; [1,2,3].each {|i|}; i => 0 irb(main):002:0> i=0; for i in [1,2,3]; end; i => 3 

    Ruby 1.8.6

     irb(main):001:0> i=0; [1,2,3].each {|i|}; i => 3 

    Hash.index

    Ruby 1.9

     irb(main):001:0> {1=>2}.index(2) (irb):18: warning: Hash#index is deprecated; use Hash#key => 1 irb(main):002:0> {1=>2}.key(2) => 1 

    Ruby 1.8.6

     irb(main):001:0> {1=>2}.index(2) => 1 

    Acción: Use Hash.key


    Fixnum.to_sym Now Gone

    Ruby 1.9

     irb(main):001:0> 5.to_sym NoMethodError: undefined method 'to_sym' for 5:Fixnum 

    Ruby 1.8.6

     irb(main):001:0> 5.to_sym => nil 

    (Cont.) Ruby 1.9

     # Find an argument value by name or index. def [](index) lookup(index.to_sym) end 

    svn.ruby-lang.org/repos/ruby/trunk/lib/rake.rb


    Las teclas hash ahora están desordenadas

    Ruby 1.9

     irb(main):001:0> {:a=>"a", :c=>"c", :b=>"b"} => {:a=>"a", :c=>"c", :b=>"b"} 

    Ruby 1.8.6

     irb(main):001:0> {:a=>"a", :c=>"c", :b=>"b"} => {:a=>"a", :b=>"b", :c=>"c"} 

    La orden es orden de inserción


    Expresiones regulares Unicode más estrictas

    Ruby 1.9

     irb(main):001:0> /\x80/u SyntaxError: (irb):2: invalid multibyte escape: /\x80/ 

    Ruby 1.8.6

     irb(main):001:0> /\x80/u => /\x80/u 

    tr y Regexp ahora entienden Unicode

    Ruby 1.9

     unicode(string).tr(CP1252_DIFFERENCES, UNICODE_EQUIVALENT). gsub(INVALID_XML_CHAR, REPLACEMENT_CHAR). gsub(XML_PREDEFINED) {|c| PREDEFINED[c.ord]} 

    pack y unpack

    Ruby 1.8.6

     def xchr(escape=true) n = XChar::CP1252[self] || self case n when *XChar::VALID XChar::PREDEFINED[n] or (n>128 ? n.chr : (escape ? "&##{n};" : [n].pack('U*'))) else Builder::XChar::REPLACEMENT_CHAR end end unpack('U*').map {|n| n.xchr(escape)}.join 

    BasicObject More Brutal Than BlankSlate

    Ruby 1.9

     irb(main):001:0> class C < BasicObject; def f; Math::PI; end; end; C.new.f NameError: uninitialized constant C::Math 

    Ruby 1.8.6

     irb(main):001:0> require 'blankslate' => true irb(main):002:0> class C < BlankSlate; def f; Math::PI; end; end; C.new.f => 3.14159265358979 

    Acción: Usar :: Matemáticas :: PI


    Cambios de Delegación

    Ruby 1.9

     irb(main):002:0> class C < SimpleDelegator; end => nil irb(main):003:0> C.new('').class => String 

    Ruby 1.8.6

     irb(main):002:0> class C < SimpleDelegator; end => nil irb(main):003:0> C.new('').class => C irb(main):004:0> 

    Defecto 17700


    El uso de $ KCODE produce advertencias

    Ruby 1.9

     irb(main):004:1> $KCODE = 'UTF8' (irb):4: warning: variable $KCODE is no longer effective; ignored => "UTF8" 

    Ruby 1.8.6

     irb(main):001:0> $KCODE = 'UTF8' => "UTF8" 

    instance_methods Ahora una matriz de símbolos

    Ruby 1.9

     irb(main):001:0> {}.methods.sort.last => :zip 

    Ruby 1.8.6

     irb(main):001:0> {}.methods.sort.last => "zip" 

    Acción: Reemplazar instance_methods.include? con method_defined?


    Codificación del archivo de origen

    BASIC

     # coding: utf-8 

    Emacs

     # -*- encoding: utf-8 -*- 

    El asunto

     #!/usr/local/rubybook/bin/ruby # encoding: utf-8 

    Real Threading

    • Condiciones de carrera
    • Suposiciones de orden implícitas
    • Código de prueba

    ¿Qué hay de nuevo?

    Sintaxis alternativa para el símbolo como teclas Hash

    Ruby 1.9

     {a: b} redirect_to action: show 

    Ruby 1.8.6

     {:a => b} redirect_to :action => show 

    Bloquear variables locales

    Ruby 1.9

     [1,2].each {|value; t| t=value*value} 

    Inyectar métodos

    Ruby 1.9

     [1,2].inject(:+) 

    Ruby 1.8.6

     [1,2].inject {|a,b| a+b} 

    to_enum

    Ruby 1.9

     short_enum = [1, 2, 3].to_enum long_enum = ('a'..'z').to_enum loop do puts "#{short_enum.next} #{long_enum.next}" end 

    Sin bloque? Enum!

    Ruby 1.9

     e = [1,2,3].each 

    Lambda Taquigrafía

    Ruby 1.9

     p = -> a,b,c {a+b+c} puts p.(1,2,3) puts p[1,2,3] 

    Ruby 1.8.6

     p = lambda {|a,b,c| a+b+c} puts p.call(1,2,3) 

    Números complejos

    Ruby 1.9

     Complex(3,4) == 3 + 4.im 

    El decimal aún no es el predeterminado

    Ruby 1.9

     irb(main):001:0> 1.2-1.1 => 0.0999999999999999 

    Regex "Propiedades"

    Ruby 1.9

     /\p{Space}/ 

    Ruby 1.8.6

     /[:space:]/ 

    Splat en medio

    Ruby 1.9

     def foo(first, *middle, last) (->a, *b, c {p ac}).(*5.downto(1)) 

    Fibras

    Ruby 1.9

     f = Fiber.new do a,b = 0,1 Fiber.yield a Fiber.yield b loop do a,b = b,a+b Fiber.yield b end end 10.times {puts f.resume} 

    Valores de ruptura

    Ruby 1.9

     match = while line = gets next if line =~ /^#/ break line if line.find('ruby') end 

    Métodos "nesteds"

    Ruby 1.9

     def toggle def toggle "subsequent times" end "first time" end 

    HTH!

    Una gran diferencia sería el cambio del intérprete de Matz a YARV , una máquina virtual de bytecode que ayuda significativamente con el rendimiento.

    Muchos ahora recomiendan el lenguaje de progtwigción Ruby sobre el pico – más al punto, tiene todos los detalles de las diferencias 1.8 / 1.9.

    Algunos más cambios:

    Devolución de una matriz splat singleton:

     def function return *[1] end a=function 
    • ruby 1.9: [1]
    • Ruby 1.8: 1

    argumentos de matriz

     def function(array) array.each { |v| pv } end function "1" 
    • ruby 1.8: “1”
    • ruby 1.9: método indefinido `each ‘for” 1 “: String