ruby ruby-1.9 ruby-1.8

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

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.