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

StackOverflow https://stackoverflow.com/questions/21574

  •  09-06-2019
  •  | 
  •  

Pregunta

No tengo claras las diferencias entre la versión "actual" de Ruby (1.8) y la versión "nueva" (1.9).¿Existe una explicación "fácil" o "simple" de las diferencias y de por qué son tan diferentes?

¿Fue útil?

Solución

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

Con el fin de incorporar esta información para una referencia más sencilla, y en caso de que el enlace falle en el futuro abstracto, aquí hay una descripción general de las diapositivas de Sam.La presentación de diapositivas es menos abrumadora de revisar, pero también es útil tenerlo todo dispuesto en una lista como esta.

Ruby 1.9 - Características principales

  • Actuación
  • Hilos/Fibras
  • Codificación/Unicode
  • Las gemas están (en su mayor parte) integradas ahora.
  • Las declaraciones if no introducen alcance en Ruby.

¿Qué ha cambiado?

Cadenas de un solo carácter.

Rubí 1.9

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

Rubí 1.8.6

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

Índice de cadena.

Rubí 1.9

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

Rubí 1.8.6

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

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

Rubí 1.9

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

Rubí 1.8.6

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

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

Array.to_s Ahora contiene puntuación

Rubí 1.9

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

Rubí 1.8.6

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

Acción: Utilice .join en su lugar

Los dos puntos ya no son válidos en las declaraciones When

Rubí 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'

Rubí 1.8.6

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

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

Las variables de bloque ahora sombrean las variables locales

Rubí 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

Rubí 1.8.6

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

Hash.index Obsoleto

Rubí 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

Rubí 1.8.6

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

Acción: Utilice la clave Hash

Fixnum.to_sym Ahora se ha ido

Rubí 1.9

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

Rubí 1.8.6

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

(Continuación) 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 claves hash ahora están desordenadas

Rubí 1.9

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

Rubí 1.8.6

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

El pedido es orden de inserción.

Expresiones regulares Unicode más estrictas

Rubí 1.9

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

Rubí 1.8.6

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

tr y Regexp Ahora entienda Unicode

Rubí 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

Rubí 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 Más brutal que BlankSlate

Rubí 1.9

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

Rubí 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: Utilice ::Matemáticas::PI

Cambios de delegación

Rubí 1.9

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

Rubí 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

Rubí 1.9

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

Rubí 1.8.6

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

instance_methods Ahora una variedad de símbolos

Rubí 1.9

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

Rubí 1.8.6

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

Acción: ¿Reemplazar instancia_methods.include?con método_definido?

Codificación del archivo fuente

Básico

# coding: utf-8

Emacs

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

El asunto

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

Enhebrado real

  • Condiciones de carrera
  • Supuestos de orden implícito
  • Código de prueba

¿Qué hay de nuevo?

Sintaxis alternativa para símbolo como claves hash

Rubí 1.9

{a: b}

redirect_to action: show

Rubí 1.8.6

{:a => b}

redirect_to :action => show

Bloquear variables locales

Rubí 1.9

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

Métodos de inyección

Rubí 1.9

[1,2].inject(:+)

Rubí 1.8.6

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

to_enum

Rubí 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?¡Enumeración!

Rubí 1.9

e = [1,2,3].each

Taquigrafía Lambda

Rubí 1.9

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

Rubí 1.8.6

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

Números complejos

Rubí 1.9

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

El decimal todavía no es el predeterminado

Rubí 1.9

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

"Propiedades" de expresiones regulares

Rubí 1.9

/\p{Space}/

Rubí 1.8.6

/[:space:]/

Salpicar en el medio

Rubí 1.9

def foo(first, *middle, last)

(->a, *b, c {p a-c}).(*5.downto(1))

Fibras

Rubí 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

Rubí 1.9

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

Métodos "anidados"

Rubí 1.9

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

¡HH!

Otros consejos

Una gran diferencia sería el paso del intérprete de Matz a YARV, una máquina virtual de código de bytes que ayuda significativamente con el rendimiento.

Muchos ahora recomiendan El lenguaje de programación Ruby sobre el Pickaxe; más concretamente, tiene todos los detalles de las diferencias 1.8/1.9.

Algunos cambios más:

Devolviendo una matriz singleton splat:

def function
  return *[1]
end

a=function
  • rubí 1.9:[1]
  • rubí 1.8:1

argumentos de matriz

def function(array)
  array.each { |v| p v }
end
function "1"
  • rubí 1.8:"1"
  • rubí 1.9:método indefinido `cada uno' para "1": Cadena
Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top