Quelle est la différence entre Ruby 1.8 et Ruby 1.9

https://stackoverflow.com/questions/21574

09-06-2019
|

Question

Je ne comprends pas clairement les différences entre la version "actuelle" de Ruby (1.8) et la "nouvelle" version (1.9).Existe-t-il une explication « facile » ou « simple » des différences et pourquoi elles sont si différentes ?

La solution

Sam Ruby a un diaporama sympa qui souligne les différences.

Dans le but de mettre ces informations en ligne pour une référence plus facile, et au cas où le lien disparaîtrait dans un avenir abstrait, voici un aperçu des diapositives de Sam.Le diaporama est moins compliqué à examiner, mais le fait de tout présenter dans une liste comme celle-ci est également utile.

Ruby 1.9 - Principales fonctionnalités

Performance
Fils/Fibres
Encodage/Unicode
les gemmes sont (pour la plupart) intégrées maintenant
si les instructions n'introduisent pas de portée dans Ruby.

Qu'est-ce qui a changé ?

Chaînes de caractères uniques.

Rubis 1.9

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

Rubis 1.8.6

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

Index de chaîne.

Rubis 1.9

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

Rubis 1.8.6

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

{"a","b"} N'est plus pris en charge

Rubis 1.9

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

Rubis 1.8.6

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

Action: Convertir en {1 => 2}

`Array.to_s` Contient désormais la ponctuation

Rubis 1.9

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

Rubis 1.8.6

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

Action: Utilisez plutôt .join

Les deux points ne sont plus valides dans les instructions When

Rubis 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'

Rubis 1.8.6

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

Action: Utilisez ensuite un point-virgule ou une nouvelle ligne

Les variables de bloc masquent désormais les variables locales

Rubis 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

Rubis 1.8.6

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

`Hash.index` Obsolète

Rubis 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

Rubis 1.8.6

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

Action: Utiliser Hash.key

`Fixnum.to_sym` Maintenant parti

Rubis 1.9

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

Rubis 1.8.6

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

(suite) 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

Les clés de hachage ne sont plus commandées

Rubis 1.9

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

Rubis 1.8.6

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

L'ordre est un ordre d'insertion

Expressions régulières Unicode plus strictes

Rubis 1.9

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

Rubis 1.8.6

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

`tr` et `Regexp` Comprenez maintenant Unicode

Rubis 1.9

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

`pack` et `unpack`

Rubis 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` Plus brutal que `BlankSlate`

Rubis 1.9

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

Rubis 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

Action: Utiliser ::Math::PI

Modifications de la délégation

Rubis 1.9

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

Rubis 1.8.6

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

~~Défaut 17700~~

L'utilisation de $KCODE génère des avertissements

Rubis 1.9

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

Rubis 1.8.6

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

`instance_methods` Maintenant un tableau de symboles

Rubis 1.9

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

Rubis 1.8.6

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

Action: Remplacer instance_methods.include ?avec méthode_définie ?

Encodage du fichier source

Basique

# coding: utf-8

Emacs

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

Case

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

Fil réel

Conditions de course
Hypothèses de commande implicites
Code d'essai

Quoi de neuf?

Syntaxe alternative pour le symbole sous forme de clés de hachage

Rubis 1.9

{a: b}

redirect_to action: show

Rubis 1.8.6

{:a => b}

redirect_to :action => show

Bloquer les variables locales

Rubis 1.9

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

Méthodes d'injection

Rubis 1.9

[1,2].inject(:+)

Rubis 1.8.6

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

`to_enum`

Rubis 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

Pas de blocage ?Énumération !

Rubis 1.9

e = [1,2,3].each

Raccourci Lambda

Rubis 1.9

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

Rubis 1.8.6

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

Nombres complexes

Rubis 1.9

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

La décimale n'est toujours pas la valeur par défaut

Rubis 1.9

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

« Propriétés » des expressions régulières

Rubis 1.9

/\p{Space}/

Rubis 1.8.6

/[:space:]/

Splat au milieu

Rubis 1.9

def foo(first, *middle, last)

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

Fibres

Rubis 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}

Valeurs de rupture

Rubis 1.9

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

Méthodes « imbriquées »

Rubis 1.9

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

HTH!

Autres conseils

Une énorme différence serait le passage de l'interprète de Matz à YARV, une machine virtuelle de bytecode qui améliore considérablement les performances.

Beaucoup recommandent maintenant Le langage de programmation Ruby par rapport à la pioche - plus précisément, il contient tous les détails des différences 1,8/1,9.

Quelques changements supplémentaires :

Renvoi d'un tableau singleton splat :

def function
  return *[1]
end

a=function

rubis 1.9 :[1]
rubis 1.8 :1

arguments du tableau

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

rubis 1.8 :"1"
rubis 1.9 :méthode non définie `each' pour "1":String

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow

Quelle est la différence entre Ruby 1.8 et Ruby 1.9

Ruby 1.9 - Principales fonctionnalités

Qu'est-ce qui a changé ?

Chaînes de caractères uniques.

Index de chaîne.

{"a","b"} N'est plus pris en charge

Array.to_s Contient désormais la ponctuation

Les deux points ne sont plus valides dans les instructions When

Les variables de bloc masquent désormais les variables locales

Hash.index Obsolète

Fixnum.to_sym Maintenant parti

Les clés de hachage ne sont plus commandées

Expressions régulières Unicode plus strictes

tr et Regexp Comprenez maintenant Unicode

pack et unpack

BasicObject Plus brutal que BlankSlate

Modifications de la délégation

L'utilisation de $KCODE génère des avertissements

instance_methods Maintenant un tableau de symboles

Encodage du fichier source

Basique

Emacs

Case

Fil réel

Quoi de neuf?

Syntaxe alternative pour le symbole sous forme de clés de hachage

Bloquer les variables locales

Méthodes d'injection

to_enum

Pas de blocage ?Énumération !

Raccourci Lambda

Nombres complexes

La décimale n'est toujours pas la valeur par défaut

« Propriétés » des expressions régulières

Splat au milieu

Fibres

Valeurs de rupture

Méthodes « imbriquées »

`Array.to_s` Contient désormais la ponctuation

`Hash.index` Obsolète

`Fixnum.to_sym` Maintenant parti

`tr` et `Regexp` Comprenez maintenant Unicode

`pack` et `unpack`

`BasicObject` Plus brutal que `BlankSlate`

`instance_methods` Maintenant un tableau de symboles

`to_enum`