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

Je ne suis pas clair sur 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 est-ce si différent?

Sam Ruby a un diaporama cool qui décrit les différences .

Dans l’intérêt de mettre ces informations en ligne pour faciliter la consultation, et au cas où le lien disparaîtrait dans l’avenir abstrait, voici un aperçu des diapositives de Sam. Le diaporama est moins compliqué à revoir, mais le fait d’avoir tout cela dans une liste comme celle-ci est également utile.

Ruby 1.9 – Principales fonctionnalités

  • Performance
  • Fils / Fibres
  • Encodage / Unicode
  • gems est (principalement) intégré maintenant
  • si les instructions n’introduisent pas la scope dans Ruby.

Qu’est-ce qui a changé?

Chaînes de caractères uniques.

Ruby 1.9

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

Ruby 1.8.6

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

Index de chaîne.

Ruby 1.9

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

Ruby 1.8.6

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

{“a”, “b”} Plus supporté

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} 

Action: Convertir en {1 => 2}


Array.to_s contient maintenant la ponctuation

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" 

Action: utilisez plutôt .join


Le côlon n’est plus valide dans les déclarations quand

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 

Action: Utilisez le point-virgule, puis, ou la nouvelle ligne


Blocage des variables maintenant ombrage des 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 

Action: utilisez Hash.key


Fixnum.to_sym maintenant Fixnum.to_sym

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 

(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 sont maintenant désordonnées

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

L’ordre est l’ordre d’insertion


Expressions régulières Unicode plus ssortingctes

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 et Regexp maintenant comprendre Unicode

Ruby 1.9

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

pack et 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 Plus brutal que 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 

Action: Utiliser :: Math :: PI


Changements de délégation

Ruby 1.9

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

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> 

Défaut 17700


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

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 maintenant un tableau de symboles

Ruby 1.9

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

Ruby 1.8.6

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

Action: remplacez instance_methods.include? avec method_defined?


Codage du fichier source

De base

 # coding: utf-8 

Emacs

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

Case

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

Filetage réel

  • Conditions de course
  • Hypothèses de commande implicites
  • Code de test

Quoi de neuf?

Syntaxe alternative pour le symbole en tant que clés de hachage

Ruby 1.9

 {a: b} redirect_to action: show 

Rubis 1.8.6

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

Bloquer les variables locales

Ruby 1.9

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

Méthodes d'injection

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 

Pas de bloc? Enum!

Ruby 1.9

 e = [1,2,3].each 

Sténographie Lambda

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) 

Nombres complexes

Ruby 1.9

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

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

Ruby 1.9

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

Regex "Propriétés"

Ruby 1.9

 /\p{Space}/ 

Ruby 1.8.6

 /[:space:]/ 

Splat au milieu

Ruby 1.9

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

Des fibres

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} 

Valeurs de rupture

Ruby 1.9

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

Méthodes "nestedes"

Ruby 1.9

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

HTH!

Une grande différence serait le passage de l’interprète de Matz à YARV , une machine virtuelle à code bytec qui aide significativement les performances.

Beaucoup recommandent maintenant le langage de programmation Ruby sur la pioche – plus précisément, il contient tous les détails des différences 1.8 / 1.9.

Quelques autres changements:

Retourner un tableau splatch singleton:

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

arguments de tableau

 def function(array) array.each { |v| pv } end function "1" 
  • rbuy 1.8: “1”
  • Ruby 1.9: méthode non définie `each ‘pour” 1 “: Ssortingng