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