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

ruby-1.9 ruby-1.8 (4)

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?

Algunos más cambios:

Devolución de una matriz splat singleton:

def function return *[1] end a=function

ruby 1.9: [1]
rubí 1.8: 1

argumentos de matriz

def function(array) array.each { |v| p v } end function "1"

ruby 1.8: "1"
ruby 1.9: método indefinido `each ''for" 1 ": String

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

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 alcance 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 a-c}).(*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 "anidados"

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.

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

ruby-1.9 ruby-1.8 (4)

Ruby 1.9 - Características principales

¿Qué ha cambiado?

Cadenas de caracteres individuales.

Índice de cadenas

{"a", "b"} ya no es compatible

Array.to_s ahora contiene signos de puntuación

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

Las variables de bloque ahora sombrean las variables locales

Hash.index

Fixnum.to_sym Now Gone

Las teclas hash ahora están desordenadas

Expresiones regulares Unicode más estrictas

tr y Regexp ahora entienden Unicode

pack y unpack

BasicObject More Brutal Than BlankSlate

Cambios de Delegación

El uso de $ KCODE produce advertencias

instance_methods Ahora una matriz de símbolos

Codificación del archivo de origen

BASIC

Emacs

El asunto

Real Threading

¿Qué hay de nuevo?

Sintaxis alternativa para el símbolo como teclas Hash

Bloquear variables locales

Inyectar métodos

to_enum

Sin bloque? Enum!

Lambda Taquigrafía

Números complejos

El decimal aún no es el predeterminado

Regex "Propiedades"

Splat en medio

Fibras

Valores de ruptura

Métodos "anidados"

`Array.to_s` ahora contiene signos de puntuación

`Hash.index`

`Fixnum.to_sym` Now Gone

`tr` y `Regexp` ahora entienden Unicode

`pack` y `unpack`

`BasicObject` More Brutal Than `BlankSlate`

`instance_methods` Ahora una matriz de símbolos

`to_enum`