ਰੂਬੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੀ ਰਿਲੀਜ਼ 2.7.0

ਵਿਕਾਸ ਦੇ ਇੱਕ ਸਾਲ ਬਾਅਦ ਪ੍ਰਕਾਸ਼ਿਤ ਜਾਰੀ ਰੂਬੀ 2.7.0, ਇੱਕ ਗਤੀਸ਼ੀਲ ਆਬਜੈਕਟ-ਅਧਾਰਿਤ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਜੋ ਪ੍ਰੋਗਰਾਮ ਦੇ ਵਿਕਾਸ ਵਿੱਚ ਬਹੁਤ ਕੁਸ਼ਲ ਹੈ ਅਤੇ ਪਰਲ, ਜਾਵਾ, ਪਾਈਥਨ, ਸਮਾਲਟਾਕ, ਆਈਫਲ, ਐਡਾ ਅਤੇ ਲਿਸਪ ਦੀਆਂ ਸਭ ਤੋਂ ਵਧੀਆ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਦੀ ਹੈ। ਪ੍ਰੋਜੈਕਟ ਕੋਡ ਨੂੰ BSD ("2-ਕਲਾਜ਼ BSDL") ਅਤੇ "ਰੂਬੀ" ਲਾਇਸੰਸ ਦੇ ਅਧੀਨ ਵੰਡਿਆ ਗਿਆ ਹੈ, ਜੋ GPL ਲਾਇਸੰਸ ਦੇ ਨਵੀਨਤਮ ਸੰਸਕਰਣ ਦਾ ਹਵਾਲਾ ਦਿੰਦਾ ਹੈ ਅਤੇ GPLv3 ਨਾਲ ਪੂਰੀ ਤਰ੍ਹਾਂ ਅਨੁਕੂਲ ਹੈ। ਰੂਬੀ 2.7 ਇੱਕ ਯੋਜਨਾਬੱਧ ਵਿਕਾਸ ਪ੍ਰਕਿਰਿਆ ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਤਿਆਰ ਕੀਤੀ ਜਾਣ ਵਾਲੀ ਸੱਤਵੀਂ ਵੱਡੀ ਰੀਲੀਜ਼ ਹੈ ਜਿਸ ਵਿੱਚ ਵਿਸ਼ੇਸ਼ਤਾ ਸੁਧਾਰਾਂ ਲਈ ਇੱਕ ਸਾਲ ਵੱਖਰਾ ਰੱਖਣਾ ਅਤੇ 2-3 ਮਹੀਨੇ ਦੇ ਪੈਚ ਰੀਲੀਜ਼ ਸ਼ਾਮਲ ਹਨ।

ਮੁੱਖ ਸੁਧਾਰ:

• ਪ੍ਰਯੋਗਾਤਮਕ ਸਹਿਯੋਗ ਪੈਟਰਨ ਮੇਲ (ਪੈਟਰਨ ਮੇਲ ਖਾਂਦਾ ਹੈ), ਜੋ ਤੁਹਾਨੂੰ ਦਿੱਤੇ ਗਏ ਆਬਜੈਕਟ ਉੱਤੇ ਦੁਹਰਾਉਣ ਅਤੇ ਪੈਟਰਨ ਨਾਲ ਮੇਲ ਹੋਣ 'ਤੇ ਇੱਕ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।

  ਕੇਸ [0, [1, 2, 3]] [a, [b, *c]] pa #=> 0 ਵਿੱਚ
  pb #=> 1
  pc #=> [2, 3] ਅੰਤ

  ਕੇਸ {a: 0, b: 1}
  in{a:0,x:1}
  : ਅਣਉਪਲਬਧ
  {a: 0, b: var} ਵਿੱਚ
  p var #=> 1
  ਅੰਤ

• ਇੰਟਰਐਕਟਿਵ ਕੈਲਕੂਲੇਸ਼ਨ irb (REPL, Read-Eval-Print-Loop) ਦੇ ਸ਼ੈੱਲ ਵਿੱਚ ਹੁਣ ਬਹੁ-ਲਾਈਨ ਸੰਪਾਦਨ ਦੀ ਸੰਭਾਵਨਾ ਹੈ, ਇੱਕ ਰੀਡਲਾਈਨ-ਅਨੁਕੂਲ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ। ਲਾਈਨਰੂਬੀ ਵਿੱਚ ਲਿਖਿਆ. rdoc ਲਈ ਸਮਰਥਨ ਏਕੀਕ੍ਰਿਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਜੋ ਕਿ irb ਵਿੱਚ ਨਿਰਧਾਰਤ ਕਲਾਸਾਂ, ਮੋਡੀਊਲ ਅਤੇ ਢੰਗਾਂ ਬਾਰੇ ਹਵਾਲਾ ਜਾਣਕਾਰੀ ਦੇਖਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਬਾਈਡਿੰਗ#irb ਦੁਆਰਾ ਦਿਖਾਏ ਗਏ ਕੋਡ ਦੇ ਨਾਲ ਲਾਈਨਾਂ ਦੀ ਰੰਗੀਨ ਹਾਈਲਾਈਟਿੰਗ ਅਤੇ ਬੇਸ ਕਲਾਸ ਆਬਜੈਕਟ ਦੀ ਜਾਂਚ ਦੇ ਨਤੀਜੇ ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਹਨ।
  

• ਇੱਕ ਸੰਖੇਪ ਕੂੜਾ ਇਕੱਠਾ ਕਰਨ ਵਾਲਾ (ਕੰਪੈਕਸ਼ਨ GC) ਜੋੜਿਆ ਗਿਆ ਹੈ ਜੋ ਮੈਮੋਰੀ ਦੇ ਇੱਕ ਖੇਤਰ ਨੂੰ ਡੀਫ੍ਰੈਗਮੈਂਟ ਕਰ ਸਕਦਾ ਹੈ, ਹੌਲੀ ਕਾਰਗੁਜ਼ਾਰੀ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ ਮੈਮੋਰੀ ਫਰੈਗਮੈਂਟੇਸ਼ਨ ਦੇ ਕਾਰਨ ਵਧੀ ਹੋਈ ਮੈਮੋਰੀ ਖਪਤ ਜੋ ਕਿ ਕੁਝ ਮਲਟੀ-ਥ੍ਰੈਡਡ ਰੂਬੀ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੇ ਸੰਚਾਲਨ ਦੌਰਾਨ ਵਾਪਰਦਾ ਹੈ। ਢੇਰ 'ਤੇ ਵਸਤੂਆਂ ਨੂੰ ਪੈਕ ਕਰਨ ਲਈ ਪ੍ਰਸਤਾਵਿਤ GC.compact ਢੰਗ ਵਰਤੇ ਗਏ ਮੈਮੋਰੀ ਪੰਨਿਆਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਅਤੇ ਓਪਰੇਸ਼ਨਾਂ ਲਈ ਹੀਪ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ
  CoW (ਨਕਲ-ਤੇ-ਲਿਖਣ)।

• ਕੀਤਾ ਸੂਚੀ ("def foo(a,b,c)") ਅਤੇ ਕੀਵਰਡਸ ("def foo(key: val)") ਵਿੱਚ ਸਥਿਤੀ ਦੇ ਆਧਾਰ 'ਤੇ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਵੱਖ ਕਰਨ ਦੀ ਤਿਆਰੀ। ਕੀਵਰਡਸ ਅਤੇ ਸਥਿਤੀ ਦੇ ਆਧਾਰ 'ਤੇ ਆਟੋਮੈਟਿਕ ਆਰਗੂਮੈਂਟ ਪਰਿਵਰਤਨ ਨੂੰ ਬਰਤਰਫ਼ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਰੂਬੀ 3.0 ਸ਼ਾਖਾ ਵਿੱਚ ਸਮਰਥਿਤ ਨਹੀਂ ਹੋਵੇਗਾ। ਖਾਸ ਤੌਰ 'ਤੇ, ਆਖਰੀ ਆਰਗੂਮੈਂਟ ਨੂੰ ਕੀਵਰਡ ਪੈਰਾਮੀਟਰਾਂ ਵਜੋਂ ਵਰਤਣ ਲਈ, ਕੀਵਰਡ-ਅਧਾਰਿਤ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਆਖਰੀ ਹੈਸ਼ ਪੈਰਾਮੀਟਰ ਵਜੋਂ ਪਾਸ ਕਰਨ ਲਈ, ਅਤੇ ਆਖਰੀ ਆਰਗੂਮੈਂਟ ਨੂੰ ਸਥਿਤੀ ਅਤੇ ਕੀਵਰਡ ਪੈਰਾਮੀਟਰਾਂ ਵਿੱਚ ਵੰਡਣ ਲਈ ਬਰਤਰਫ਼ ਕੀਤਾ ਗਿਆ ਹੈ।

  def foo (ਕੁੰਜੀ: 42); ਅੰਤ; foo({key: 42}) # ਚੇਤਾਵਨੀ ਦਿੱਤੀ
  def foo (** kw); ਅੰਤ; foo({key: 42}) # ਚੇਤਾਵਨੀ ਦਿੱਤੀ
  def foo (ਕੁੰਜੀ: 42); ਅੰਤ; foo(**{ਕੁੰਜੀ: 42}) # ਠੀਕ ਹੈ
  def foo (** kw); ਅੰਤ; foo(**{ਕੁੰਜੀ: 42}) # ਠੀਕ ਹੈ

  def foo(h, **kw); ਅੰਤ; foo (ਕੁੰਜੀ: 42) # ਚੇਤਾਵਨੀ ਦਿੱਤੀ
  def foo(h, ਕੁੰਜੀ: 42); ਅੰਤ; foo (ਕੁੰਜੀ: 42) # ਚੇਤਾਵਨੀ ਦਿੱਤੀ
  def foo(h, **kw); ਅੰਤ; foo({key: 42}) # ਠੀਕ ਹੈ
  def foo(h, ਕੁੰਜੀ: 42); ਅੰਤ; foo({key: 42}) # ਠੀਕ ਹੈ

  def foo(h={}, ਕੁੰਜੀ: 42); ਅੰਤ; foo("key" => 43, ਕੁੰਜੀ: 42) # ਚੇਤਾਵਨੀ ਦਿੱਤੀ
  def foo(h={}, ਕੁੰਜੀ: 42); ਅੰਤ; foo({"key" => 43, ਕੁੰਜੀ: 42}) # ਚੇਤਾਵਨੀ ਦਿੱਤੀ ਗਈ
  def foo(h={}, ਕੁੰਜੀ: 42); ਅੰਤ; foo({"key" => 43}, ਕੁੰਜੀ: 42) # ਠੀਕ ਹੈ

  def foo(opt={}); ਅੰਤ; foo (ਕੁੰਜੀ: 42) # ਠੀਕ ਹੈ

  def foo(h, **nil); ਅੰਤ; foo(ਕੁੰਜੀ: 1) # ਆਰਗੂਮੈਂਟ ਐਰਰ
  def foo(h, **nil); ਅੰਤ; foo(**{ਕੁੰਜੀ: 1}) # ਆਰਗੂਮੈਂਟ ਐਰਰ
  def foo(h, **nil); ਅੰਤ; foo("str" ​​=> 1) # ਆਰਗੂਮੈਂਟ ਐਰਰ
  def foo(h, **nil); ਅੰਤ; foo({key: 1}) # ਠੀਕ ਹੈ
  def foo(h, **nil); ਅੰਤ; foo({"str" ​​=> 1}) # ਠੀਕ ਹੈ

  h = {}; def foo(*a) ਅੰਤ; foo(**h) # [] h = {}; def foo(a) ਅੰਤ; foo(**h) # {} ਅਤੇ ਚੇਤਾਵਨੀ
  h = {}; def foo(*a) ਅੰਤ; foo(h) # [{}] h = {}; def foo(a) ਅੰਤ; foo(h) # {}

• ਮੌਕਾ ਬਲਾਕ ਪੈਰਾਮੀਟਰਾਂ ਲਈ ਮੂਲ ਰੂਪ ਵਿੱਚ ਨੰਬਰ ਵਾਲੇ ਵੇਰੀਏਬਲ ਨਾਮਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ।

  [1, 2, 3]।ਹਰੇਕ { @1 ਰੱਖਦਾ ਹੈ } # ਜਿਵੇਂ [1, 2, 3]।ਹਰ { |i| ਰੱਖਦਾ ਹੈ }

• ਸ਼ੁਰੂਆਤੀ ਮੁੱਲ ਦੇ ਬਿਨਾਂ ਰੇਂਜਾਂ ਲਈ ਪ੍ਰਯੋਗਾਤਮਕ ਸਮਰਥਨ।

  ary[..3] # ary[0..3] rel.where (ਵਿਕਰੀ: ..100) ਦੇ ਸਮਾਨ

• ਗਿਣਨਯੋਗ#ਟੈਲੀ ਵਿਧੀ ਸ਼ਾਮਲ ਕੀਤੀ ਗਈ, ਜੋ ਹਰੇਕ ਤੱਤ ਦੇ ਦਿਖਾਈ ਦੇਣ ਦੀ ਗਿਣਤੀ ਦੀ ਗਿਣਤੀ ਕਰਦੀ ਹੈ।

  ["a", "b", "c", "b"]।ਟੈਲੀ
  #=> {“a”=>1, “b”=>2, “c”=>1}

• "ਸਵੈ" ਸ਼ਾਬਦਿਕ ਨਾਲ ਨਿਜੀ ਵਿਧੀ ਕਾਲ ਦੀ ਇਜਾਜ਼ਤ ਹੈ

  deffoo
  ਅੰਤ
  ਨਿੱਜੀ:foo
  self.foo

• ਆਲਸੀ (ਅੰਕਕਾਰ::ਆਲਸੀ) ਗਣਨਾ ਤੋਂ ਨਿਯਮਤ ਗਣਨਾ ਤਿਆਰ ਕਰਨ ਲਈ ਐਨੂਮੇਰੇਟਰ::ਆਲਸੀ#ਏਜਰ ਵਿਧੀ ਸ਼ਾਮਲ ਕੀਤੀ ਗਈ।

  a = %w(foo ਬਾਰ ਬਾਜ਼)
  e = a.lazy.map {|x| x.upcase }. ਨਕਸ਼ਾ {|x| x + "!" }. ਉਤਸੁਕ
  p e.class #=> ਗਿਣਤੀਕਾਰ
  e.map {|x| x + "?" } #=> ["FOO!?", "BAR!?", "BAZ!?"]

• ਇੱਕ ਪ੍ਰਯੋਗਾਤਮਕ JIT ਕੰਪਾਈਲਰ ਦਾ ਵਿਕਾਸ ਜਾਰੀ ਹੈ, ਜੋ ਰੂਬੀ ਭਾਸ਼ਾ ਵਿੱਚ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਸੁਧਾਰ ਕਰ ਸਕਦਾ ਹੈ। ਰੂਬੀ ਵਿੱਚ ਪ੍ਰਸਤਾਵਿਤ JIT ਕੰਪਾਈਲਰ ਪਹਿਲਾਂ ਡਿਸਕ 'ਤੇ C ਕੋਡ ਲਿਖਦਾ ਹੈ, ਜਿਸ ਤੋਂ ਬਾਅਦ ਇਹ ਮਸ਼ੀਨ ਨਿਰਦੇਸ਼ ਤਿਆਰ ਕਰਨ ਲਈ ਇੱਕ ਬਾਹਰੀ C ਕੰਪਾਈਲਰ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ (GCC, Clang ਅਤੇ Microsoft VC ++ ਸਮਰਥਿਤ ਹਨ)। ਨਵਾਂ ਸੰਸਕਰਣ ਇਨਲਾਈਨ ਤੈਨਾਤੀ ਲਈ ਇੱਕ ਵਿਧੀ ਲਾਗੂ ਕਰਦਾ ਹੈ ਜੇਕਰ ਲੋੜ ਹੋਵੇ, ਸੰਕਲਨ ਦੇ ਦੌਰਾਨ ਅਨੁਕੂਲਨ ਮੋਡਾਂ ਦੀ ਚੋਣਵੀਂ ਐਪਲੀਕੇਸ਼ਨ, "--ਜੀਤ-ਮਿਨ-ਕਾਲਜ਼" ਦਾ ਮੂਲ ਮੁੱਲ 5 ਤੋਂ 10000 ਤੱਕ ਵਧਾ ਦਿੱਤਾ ਗਿਆ ਹੈ, ਅਤੇ "--ਜੀਤ-ਮੈਕਸ-ਕੈਸ਼" 1000 ਤੋਂ 100 ਤੱਕ
• CGI.escapeHTML, ਮਾਨੀਟਰ ਅਤੇ MonitorMixin ਦੀ ਬਿਹਤਰ ਕਾਰਗੁਜ਼ਾਰੀ।
• Module#name, true.to_s, false.to_s, ਅਤੇ nil.to_s ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹਨ ਕਿ ਇੱਕ ਸਟ੍ਰਿੰਗ ਵਾਪਸ ਕੀਤੀ ਗਈ ਹੈ ਜੋ ਨਿਰਧਾਰਤ ਵਸਤੂ ਲਈ ਬਦਲਿਆ ਨਹੀਂ ਹੈ।
• RubyVM::InstructionSequence#to_binary ਵਿਧੀ ਦੁਆਰਾ ਤਿਆਰ ਬਾਈਨਰੀ ਫਾਈਲਾਂ ਦਾ ਆਕਾਰ ਘਟਾ ਦਿੱਤਾ ਗਿਆ ਹੈ;
• ਬਿਲਟ-ਇਨ ਕੰਪੋਨੈਂਟਸ ਦੇ ਅਪਡੇਟ ਕੀਤੇ ਸੰਸਕਰਣ, ਸਮੇਤ
  ਬੰਡਲਰ 2.1.2, RubyGems 3.1.2,
  Racc 1.4.15,
  CSV 3.1.2, REXML 3.2.3,
  RSS 0.2.8,
  ਸਟ੍ਰਿੰਗ ਸਕੈਨਰ 1.0.3;

• ਲਾਇਬ੍ਰੇਰੀਆਂ ਬੇਸ ਡਿਸਟ੍ਰੀਬਿਊਸ਼ਨ ਤੋਂ ਬਾਹਰੀ ਰਤਨ ਪੈਕੇਜਾਂ ਵਿੱਚ ਤਬਦੀਲ ਹੋ ਗਈਆਂ
  CMath (cmath ਹੀਰਾ),
  ਸਕੈਨਫ (ਸਕੈਨਫ ਰਤਨ),
  ਸ਼ੈੱਲ (ਸ਼ੈਲ ਰਤਨ),
  ਸਿੰਕ੍ਰੋਨਾਈਜ਼ਰ (ਸਮਕਾਲੀ ਰਤਨ),
  ਥ੍ਰੈੱਡਸਵੇਟ (ਥਵੇਟ ਰਤਨ),
  E2MM (e2mmap ਰਤਨ)।

• ਡਿਫਾਲਟ stdlib ਮੋਡੀਊਲ rubygems.org 'ਤੇ ਪ੍ਰਕਾਸ਼ਿਤ ਕੀਤੇ ਗਏ ਹਨ:
  ਬੇਂਚਮਾਰਕ,
  cgi,
  ਡੈਲੀਗੇਟ,
  getoptlong,
  ਨੈੱਟ-ਪੌਪ,
  ਨੈੱਟ ਐਸਐਮਟੀਪੀ,
  open3,
  pstore,
  ਸਿੰਗਲਟਨ ਮਾਨੀਟਰ ਮੋਡੀਊਲ rubygems.org 'ਤੇ ਨਹੀਂ ਭੇਜੇ ਗਏ
  ਨਿਰੀਖਕ,
  ਸਮਾਂ ਖ਼ਤਮ
  ਟਰੇਸਰ
  uri,
  yaml, ਜੋ ਸਿਰਫ਼ ਰੂਬੀ-ਕੋਰ ਨਾਲ ਭੇਜੇ ਜਾਂਦੇ ਹਨ।

• ਬਿਲਡਿੰਗ ਰੂਬੀ ਲਈ ਹੁਣ ਇੱਕ C ਕੰਪਾਈਲਰ ਦੀ ਲੋੜ ਹੈ ਜੋ C99 ਸਟੈਂਡਰਡ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ।

ਸਰੋਤ: opennet.ru