मैं रूबी (1.8) के "वर्तमान" संस्करण और "नया" संस्करण (1.9) के बीच के अंतरों पर स्पष्ट नहीं हूं। क्या मतभेदों की "आसान" या "सरल" व्याख्या है और यह इतना अलग क्यों है?
मैं रूबी (1.8) के "वर्तमान" संस्करण और "नया" संस्करण (1.9) के बीच के अंतरों पर स्पष्ट नहीं हूं। क्या मतभेदों की "आसान" या "सरल" व्याख्या है और यह इतना अलग क्यों है?
जवाबों:
सैम रूबी के पास एक शांत स्लाइड शो है जो मतभेदों को रेखांकित करता है ।
इस जानकारी को आसान संदर्भ के लिए इनलाइन लाने के हित में, और यदि लिंक अमूर्त भविष्य में मृत हो जाता है, तो यहां सैम की स्लाइड का अवलोकन किया गया है। स्लाइड शो समीक्षा करने के लिए कम है, लेकिन यह सब इस तरह एक सूची में बाहर रखा भी उपयोगी है।
रूबी 1.9
irb(main):001:0> ?c
=> "c"
रूबी 1.8.6
irb(main):001:0> ?c
=> 99
रूबी 1.9
irb(main):001:0> "cat"[1]
=> "a"
रूबी 1.8.6
irb(main):001:0> "cat"[1]
=> 97
रूबी 1.9
irb(main):002:0> {1,2}
SyntaxError: (irb):2: syntax error, unexpected ',', expecting tASSOC
रूबी 1.8.6
irb(main):001:0> {1,2}
=> {1=>2}
क्रिया: {1 => 2} में बदलें
Array.to_s
अब इसमें विराम चिह्न शामिल हैंरूबी 1.9
irb(main):001:0> [1,2,3].to_s
=> "[1, 2, 3]"
रूबी 1.8.6
irb(main):001:0> [1,2,3].to_s
=> "123"
क्रिया: इसके बजाय .join का उपयोग करें
रूबी 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'
रूबी 1.8.6
irb(main):001:0> case 'a'; when /\w/: puts 'word'; end
word
क्रिया: अर्धविराम, फिर, या न्यूलाइन का उपयोग करें
रूबी 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
रूबी 1.8.6
irb(main):001:0> i=0; [1,2,3].each {|i|}; i
=> 3
Hash.index
पदावनतरूबी 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
रूबी 1.8.6
irb(main):001:0> {1=>2}.index(2)
=> 1
क्रिया: Hash.key का उपयोग करें
Fixnum.to_sym
अब चला गयारूबी 1.9
irb(main):001:0> 5.to_sym
NoMethodError: undefined method 'to_sym' for 5:Fixnum
रूबी 1.8.6
irb(main):001:0> 5.to_sym
=> nil
(योगदान) रूबी 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
रूबी 1.9
irb(main):001:0> {:a=>"a", :c=>"c", :b=>"b"}
=> {:a=>"a", :c=>"c", :b=>"b"}
रूबी 1.8.6
irb(main):001:0> {:a=>"a", :c=>"c", :b=>"b"}
=> {:a=>"a", :b=>"b", :c=>"c"}
आदेश प्रविष्टि क्रम है
रूबी 1.9
irb(main):001:0> /\x80/u
SyntaxError: (irb):2: invalid multibyte escape: /\x80/
रूबी 1.8.6
irb(main):001:0> /\x80/u
=> /\x80/u
tr
और Regexp
अब यूनिकोड को समझेंरूबी 1.9
unicode(string).tr(CP1252_DIFFERENCES, UNICODE_EQUIVALENT).
gsub(INVALID_XML_CHAR, REPLACEMENT_CHAR).
gsub(XML_PREDEFINED) {|c| PREDEFINED[c.ord]}
pack
तथा unpack
रूबी 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
अधिक क्रूर थान BlankSlate
रूबी 1.9
irb(main):001:0> class C < BasicObject; def f; Math::PI; end; end; C.new.f
NameError: uninitialized constant C::Math
रूबी 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
क्रिया: उपयोग :: गणित :: पीआई
रूबी 1.9
irb(main):002:0> class C < SimpleDelegator; end
=> nil
irb(main):003:0> C.new('').class
=> String
रूबी 1.8.6
irb(main):002:0> class C < SimpleDelegator; end
=> nil
irb(main):003:0> C.new('').class
=> C
irb(main):004:0>
रूबी 1.9
irb(main):004:1> $KCODE = 'UTF8'
(irb):4: warning: variable $KCODE is no longer effective; ignored
=> "UTF8"
रूबी 1.8.6
irb(main):001:0> $KCODE = 'UTF8'
=> "UTF8"
instance_methods
अब प्रतीक का एक ऐरेरूबी 1.9
irb(main):001:0> {}.methods.sort.last
=> :zip
रूबी 1.8.6
irb(main):001:0> {}.methods.sort.last
=> "zip"
क्रिया: example_methods.include बदलें? Method_defined के साथ?
# coding: utf-8
# -*- encoding: utf-8 -*-
#!/usr/local/rubybook/bin/ruby
# encoding: utf-8
रूबी 1.9
{a: b}
redirect_to action: show
रूबी 1.8.6
{:a => b}
redirect_to :action => show
रूबी 1.9
[1,2].each {|value; t| t=value*value}
रूबी 1.9
[1,2].inject(:+)
रूबी 1.8.6
[1,2].inject {|a,b| a+b}
to_enum
रूबी 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
रूबी 1.9
e = [1,2,3].each
रूबी 1.9
p = -> a,b,c {a+b+c}
puts p.(1,2,3)
puts p[1,2,3]
रूबी 1.8.6
p = lambda {|a,b,c| a+b+c}
puts p.call(1,2,3)
रूबी 1.9
Complex(3,4) == 3 + 4.im
रूबी 1.9
irb(main):001:0> 1.2-1.1
=> 0.0999999999999999
रूबी 1.9
/\p{Space}/
रूबी 1.8.6
/[:space:]/
रूबी 1.9
def foo(first, *middle, last)
(->a, *b, c {p a-c}).(*5.downto(1))
रूबी 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}
रूबी 1.9
match =
while line = gets
next if line =~ /^#/
break line if line.find('ruby')
end
रूबी 1.9
def toggle
def toggle
"subsequent times"
end
"first time"
end
HTH!
अब कई लोग पिकाक्स पर रूबी प्रोग्रामिंग लैंग्वेज की सलाह देते हैं - इस बिंदु पर अधिक, इसमें 1.8 / 1.9 अंतर के सभी विवरण हैं।
कुछ और बदलाव:
एक शानदार सिंगलटन सरणी लौटना:
def function
return *[1]
end
a=function
सरणी तर्क
def function(array)
array.each { |v| p v }
end
function "1"