Qual è la differenza tra Ruby 1.8 e Ruby 1.9

https://stackoverflow.com/questions/21574

09-06-2019
|

Domanda

Non mi sono chiare le differenze tra la versione "attuale" di Ruby (1.8) e la "nuova" versione (1.9).Esiste una spiegazione "facile" o "semplice" delle differenze e del perché è così diverso?

Soluzione

Sam Ruby ha un bella presentazione che delinea le differenze.

Nell'interesse di riportare queste informazioni in linea per una consultazione più semplice, e nel caso in cui il collegamento venga interrotto in un futuro astratto, ecco una panoramica delle diapositive di Sam.La presentazione è meno travolgente da rivedere, ma è utile anche avere tutto disposto in un elenco come questo.

Ruby 1.9 - Caratteristiche principali

Prestazione
Fili/Fibre
Codifica/Unicode
gems è (per lo più) integrato ora
if le istruzioni non introducono l'ambito in Ruby.

Cosa è cambiato?

Stringhe di singoli caratteri.

Rubino 1.9

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

Rubino 1.8.6

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

Indice delle stringhe.

Rubino 1.9

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

Rubino 1.8.6

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

{"a","b"} Non più supportato

Rubino 1.9

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

Rubino 1.8.6

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

Azione: Converti in {1 => 2}

`Array.to_s` Ora contiene la punteggiatura

Rubino 1.9

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

Rubino 1.8.6

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

Azione: Utilizzare invece .join

I due punti non sono più validi nelle dichiarazioni When

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

Rubino 1.8.6

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

Azione: Utilizza il punto e virgola, quindi, o il ritorno a capo

Blocca le variabili ora oscura le variabili locali

Rubino 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

Rubino 1.8.6

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

`Hash.index` Deprecato

Rubino 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

Rubino 1.8.6

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

Azione: Utilizzare Hash.key

`Fixnum.to_sym` Ora andato

Rubino 1.9

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

Rubino 1.8.6

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

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

Chiavi hash ora non ordinate

Rubino 1.9

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

Rubino 1.8.6

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

L'ordine è l'ordine di inserimento

Espressioni regolari Unicode più rigorose

Rubino 1.9

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

Rubino 1.8.6

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

`tr` E `Regexp` Ora comprendi Unicode

Rubino 1.9

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

`pack` E `unpack`

Rubino 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` Più brutale di `BlankSlate`

Rubino 1.9

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

Rubino 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

Azione: Utilizzare ::Matematica::PI

Modifiche della delegazione

Rubino 1.9

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

Rubino 1.8.6

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

~~Difetto 17700~~

L'uso di $KCODE produce avvisi

Rubino 1.9

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

Rubino 1.8.6

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

`instance_methods` Ora una serie di simboli

Rubino 1.9

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

Rubino 1.8.6

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

Azione: Sostituisci istanza_methods.include?con metodo_definito?

Codifica del file sorgente

Di base

# coding: utf-8

Emacs

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

Shebang

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

Filettatura reale

Condizioni di gara
Presupposti di ordinamento implicito
Codice di prova

Cosa c'è di nuovo?

Sintassi alternativa per il simbolo come chiavi hash

Rubino 1.9

{a: b}

redirect_to action: show

Rubino 1.8.6

{:a => b}

redirect_to :action => show

Blocca variabili locali

Rubino 1.9

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

Metodi di iniezione

Rubino 1.9

[1,2].inject(:+)

Rubino 1.8.6

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

`to_enum`

Rubino 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

Nessun blocco?Enumerazione!

Rubino 1.9

e = [1,2,3].each

Stenografia Lambda

Rubino 1.9

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

Rubino 1.8.6

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

Numeri complessi

Rubino 1.9

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

Il decimale non è ancora l'impostazione predefinita

Rubino 1.9

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

“Proprietà” delle espressioni regolari

Rubino 1.9

/\p{Space}/

Rubino 1.8.6

/[:space:]/

Splat nel mezzo

Rubino 1.9

def foo(first, *middle, last)

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

Fibre

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

Rompere i valori

Rubino 1.9

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

Metodi “nidificati”.

Rubino 1.9

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

HTH!

Altri suggerimenti

Una differenza enorme sarebbe il passaggio dall'interprete di Matz a YARV, una macchina virtuale bytecode che aiuta in modo significativo con le prestazioni.

Molti ora lo consigliano Il linguaggio di programmazione Ruby sopra il Piccone - più precisamente, ha tutti i dettagli delle differenze 1.8/1.9.

Alcune ulteriori modifiche:

Restituendo un array singleton splat:

def function
  return *[1]
end

a=function

rubino 1.9:[1]
rubino 1.8:1

argomenti dell'array

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

rubino 1.8:"1"
rubino 1.9:metodo indefinito `each' per "1":String

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow

Qual è la differenza tra Ruby 1.8 e Ruby 1.9

Ruby 1.9 - Caratteristiche principali

Cosa è cambiato?

Stringhe di singoli caratteri.

Indice delle stringhe.

{"a","b"} Non più supportato

Array.to_s Ora contiene la punteggiatura

I due punti non sono più validi nelle dichiarazioni When

Blocca le variabili ora oscura le variabili locali

Hash.index Deprecato

Fixnum.to_sym Ora andato

Chiavi hash ora non ordinate

Espressioni regolari Unicode più rigorose

tr E Regexp Ora comprendi Unicode

pack E unpack

BasicObject Più brutale di BlankSlate

Modifiche della delegazione

L'uso di $KCODE produce avvisi

instance_methods Ora una serie di simboli

Codifica del file sorgente

Di base

Emacs

Shebang

Filettatura reale

Cosa c'è di nuovo?

Sintassi alternativa per il simbolo come chiavi hash

Blocca variabili locali

Metodi di iniezione

to_enum

Nessun blocco?Enumerazione!

Stenografia Lambda

Numeri complessi

Il decimale non è ancora l'impostazione predefinita

“Proprietà” delle espressioni regolari

Splat nel mezzo

Fibre

Rompere i valori

Metodi “nidificati”.

`Array.to_s` Ora contiene la punteggiatura

`Hash.index` Deprecato

`Fixnum.to_sym` Ora andato

`tr` E `Regexp` Ora comprendi Unicode

`pack` E `unpack`

`BasicObject` Più brutale di `BlankSlate`

`instance_methods` Ora una serie di simboli

`to_enum`