ការចេញផ្សាយភាសាកម្មវិធី Ruby 2.7.0

បន្ទាប់ពីមួយឆ្នាំនៃការអភិវឌ្ឍន៍ បានផ្សព្វផ្សាយ។ ការដោះលែង Ruby ២.៦ដែលជាភាសាសរសេរកម្មវិធីតម្រង់ទិសវត្ថុថាមវន្ត ដែលមានប្រសិទ្ធភាពខ្ពស់ក្នុងការអភិវឌ្ឍន៍កម្មវិធី និងរួមបញ្ចូលលក្ខណៈពិសេសល្អបំផុតរបស់ Perl, Java, Python, Smalltalk, Eiffel, Ada និង Lisp។ លេខកូដគម្រោងត្រូវបានចែកចាយក្រោមអាជ្ញាបណ្ណ BSD ("2-ឃ្លា BSDL") និង "Ruby" ដែលសំដៅទៅលើកំណែចុងក្រោយបំផុតនៃអាជ្ញាប័ណ្ណ GPL ហើយត្រូវគ្នាយ៉ាងពេញលេញជាមួយ GPLv3 ។ Ruby 2.7 គឺជាការចេញផ្សាយដ៏សំខាន់ទី 2 បន្ទាប់ពីដំណើរការអភិវឌ្ឍន៍ដែលបានគ្រោងទុកដែលចំណាយពេលមួយឆ្នាំដើម្បីរៀបចំការកែលម្អមុខងារ និងបង្កើតការចេញផ្សាយការថែទាំរៀងរាល់ 3-XNUMX ខែ។

សំខាន់ ការកែលម្អ:

• ពិសោធន៍ ការគាំទ្រ ការផ្គូផ្គងលំនាំ (ការផ្គូផ្គងលំនាំ) ដែលអនុញ្ញាតឱ្យអ្នកធ្វើម្តងទៀតលើវត្ថុដែលបានផ្តល់ឱ្យ ហើយផ្តល់តម្លៃប្រសិនបើមានការផ្គូផ្គងនឹងលំនាំ។

  ករណី [0, [1, 2, 3]] ក្នុង [a, [b, *c]] ប៉ា #=> 0
  pb #=> ១
  pc #=> [2, 3] ចប់

  ករណី {a: 0, b: 1}
  ក្នុង {a: 0, x: 1}
  ៖ មិនអាចចូលបាន។
  ក្នុង {a: 0, b: var}
  p var #=> ១
  បញ្ចប់

• សែលនៃការគណនាអន្តរកម្ម irb (REPL, Read-Eval-Print-Loop) ឥឡូវនេះមានមុខងារកែសម្រួលច្រើនបន្ទាត់ ដែលត្រូវបានអនុវត្តដោយប្រើបណ្ណាល័យដែលត្រូវគ្នានឹងការអាន ពឹងផ្អែកសរសេរនៅក្នុង Ruby ។ ការគាំទ្រ rdoc ត្រូវបានរួមបញ្ចូល ដែលអនុញ្ញាតឱ្យអ្នកមើលព័ត៌មានយោងលើថ្នាក់ដែលបានបញ្ជាក់ ម៉ូឌុល និងវិធីសាស្រ្តក្នុង irb ។ បានផ្តល់ការបន្លិចពណ៌នៃបន្ទាត់នៃកូដដែលបង្ហាញតាមរយៈ Binding #irb និងលទ្ធផលនៃការត្រួតពិនិត្យវត្ថុថ្នាក់មូលដ្ឋាន។
  

• បានបន្ថែមឧបករណ៍ប្រមូលសំរាមតូច (Compaction GC) ដែលអាច defragment តំបន់នៃអង្គចងចាំ ដោះស្រាយបញ្ហាដំណើរការ និងការប្រើប្រាស់អង្គចងចាំដែលបណ្តាលមកពីការបែងចែកអង្គចងចាំដែលកើតឡើងនៅក្នុងកម្មវិធី Ruby ពហុខ្សែមួយចំនួន។ ដើម្បីខ្ចប់វត្ថុនៅលើគំនរ បានស្នើឡើង វិធីសាស្ត្រ GC.compact ដែលអនុញ្ញាតឱ្យអ្នកកាត់បន្ថយចំនួនទំព័រអង្គចងចាំដែលបានប្រើ និងបង្កើនប្រសិទ្ធភាព heap សម្រាប់ប្រតិបត្តិការ។
  CoW (ចម្លងលើការសរសេរ) ។

• បានធ្វើឡើង រៀបចំដើម្បីបំបែកអាគុយម៉ង់ដោយផ្អែកលើទីតាំងនៅក្នុងបញ្ជី ("def foo(a,b,c)") និងពាក្យគន្លឹះ ("def foo(key: val)") ។ ការបម្លែងអាគុយម៉ង់ដោយស្វ័យប្រវត្តិដោយផ្អែកលើពាក្យគន្លឹះ និងទីតាំងត្រូវបានបដិសេធ ហើយនឹងមិនត្រូវបានគាំទ្រនៅក្នុងសាខា Ruby 3.0 ទេ។ ជាពិសេស វាត្រូវបានបដិសេធក្នុងការប្រើអាគុយម៉ង់ចុងក្រោយជាប៉ារ៉ាម៉ែត្រពាក្យគន្លឹះ ដើម្បីឆ្លងកាត់អាគុយម៉ង់ផ្អែកលើពាក្យគន្លឹះជាប៉ារ៉ាម៉ែត្រសញ្ញាចុងក្រោយ និងដើម្បីបំបែកអាគុយម៉ង់ចុងក្រោយទៅជាប៉ារ៉ាម៉ែត្រទីតាំង និងពាក្យគន្លឹះ។

  def foo (គន្លឹះ៖ ៤២); បញ្ចប់; foo({key: 42}) # បានព្រមាន
  def foo(**kw); បញ្ចប់; foo({key: 42}) # បានព្រមាន
  def foo (គន្លឹះ៖ ៤២); បញ្ចប់; foo(**{key: 42}) # យល់ព្រម
  def foo(**kw); បញ្ចប់; foo(**{key: 42}) # យល់ព្រម

  def foo(h, **kw); បញ្ចប់; foo (គន្លឹះ៖ 42) # បានព្រមាន
  def foo(h, key: 42); បញ្ចប់; foo (គន្លឹះ៖ 42) # បានព្រមាន
  def foo(h, **kw); បញ្ចប់; foo({key: 42}) # យល់ព្រម
  def foo(h, key: 42); បញ្ចប់; foo({key: 42}) # យល់ព្រម

  def foo(h={}, key: 42); បញ្ចប់; foo("កូនសោ" => 43, គ្រាប់ចុច: 42) # បានព្រមាន
  def foo(h={}, key: 42); បញ្ចប់; foo({"key" => 43, key: 42}) # ព្រមាន
  def foo(h={}, key: 42); បញ្ចប់; foo({"key" => 43}, key: 42) # យល់ព្រម

  def foo(opt={}); បញ្ចប់; foo(គន្លឹះ៖ 42) # យល់ព្រម

  def foo(h, **nil); បញ្ចប់; foo(key: 1) # ArgumentError
  def foo(h, **nil); បញ្ចប់; foo(**{key: 1}) # ArgumentError
  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].each { |i| ដាក់ខ្ញុំ }

• ជំនួយការសាកល្បងសម្រាប់ជួរដោយគ្មានតម្លៃដំបូង។

  ary[..3] #ស្រដៀងនឹង ary[0..3] rel.where(លក់៖ ..100)

• បានបន្ថែមវិធីសាស្ត្ររាប់លេខ#សរុប ដែលរាប់ចំនួនដងដែលធាតុនីមួយៗលេចឡើង។

  ["a", "b", "c", "b"].tally
  #=> {“a”=>1, “b”=>2, “c”=>1}

• ការហៅតាមវិធីឯកជនត្រូវបានអនុញ្ញាតដោយព្យញ្ជនៈ "ខ្លួនឯង"

  def ហ្វូ
  បញ្ចប់
  ឯកជន៖ ហ្វូ
  self.foo

• Added Enumerator::Lazy#eager method ដើម្បីបង្កើតការរាប់ទៀងទាត់ពីអ្នករាប់លេខខ្ជិល (Enumerator::Lazy)។

  a = %w(foo bar baz)
  e=a.lazy.map {|x| x.upcase }.map {|x| x + "!" }.អន្ទះសារ
  p e.class #=> Enumerator
  p e.map {|x| x + "?" } #=> ["FOO!?", "BAR!?", "BAZ!?"]

• ការអភិវឌ្ឍន៍កម្មវិធីចងក្រង JIT ពិសោធន៍បានបន្ត ដែលអាចធ្វើអោយប្រសើរឡើងនូវការអនុវត្តកម្មវិធីនៅក្នុងភាសា Ruby ។ កម្មវិធីចងក្រង JIT របស់ Ruby ដំបូងសរសេរកូដ C ទៅថាស ហើយបន្ទាប់មកហៅកម្មវិធីចងក្រង C ខាងក្រៅដើម្បីបង្កើតការណែនាំម៉ាស៊ីន (គាំទ្រការហៅ GCC, Clang, និង Microsoft VC++) ។ កំណែថ្មីអនុវត្តវិធីសាស្រ្តសម្រាប់ការដាក់ពង្រាយក្នុងជួរប្រសិនបើចាំបាច់ កម្មវិធីជ្រើសរើសនៃរបៀបបង្កើនប្រសិទ្ធភាពកំឡុងពេលចងក្រងត្រូវបានធានា តម្លៃលំនាំដើមនៃ "--jit-min-calls" ត្រូវបានកើនឡើងពី 5 ទៅ 10000 និង "--jit-max- ឃ្លាំងសម្ងាត់" ពី 1000 ទៅ 100 ។
• ធ្វើឱ្យប្រសើរឡើងនូវការអនុវត្តរបស់ CGI.escapeHTML, Monitor និង MonitorMixin ។
• ម៉ូឌុល#name, true.to_s, false.to_s, និង nil.to_s ធានាថាខ្សែអក្សរមួយត្រូវបានបញ្ជូនមកវិញដែលមិនផ្លាស់ប្តូរសម្រាប់វត្ថុដែលបានបញ្ជាក់។
• ទំហំនៃឯកសារគោលពីរដែលបង្កើតដោយ RubyVM::InstructionSequence#to_binary; method ត្រូវបានកាត់បន្ថយ។
• កំណែដែលបានធ្វើបច្ចុប្បន្នភាពនៃសមាសភាគដែលភ្ជាប់មកជាមួយ រួមទាំង
  Bundler 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 (ត្បូងពេជ្រ)
  ស្កែន (ស្កែនត្បូង),
  សែល (សែល ត្បូង)
  ធ្វើសមកាលកម្ម (ធ្វើសមកាលកម្មត្បូង),
  ត្បូងទទឹម (Thwait Gem),
  E2MM (ត្បូង e2mmap) ។

• ម៉ូឌុល stdlib លំនាំដើមត្រូវបានបោះពុម្ពនៅលើគេហទំព័រ rubygems.org៖
  ស្តង់ដារ,
  cgi,
  ប្រតិភូ
  getoptlong,
  ប៉ុបសុទ្ធ,
  សុទ្ធ-smtp
  បើក 3,
  ហាង​លក់​ទំនិញ
  លីវតុន។ ម៉ូឌុលម៉ូនីទ័រមិនត្រូវបានផ្លាស់ទីទៅ rubygems.org ទេ។
  អ្នកសង្កេតការណ៍
  ដល់​ម៉ោង,
  ដាន,
  យូរី
  yaml ដែលត្រូវបានផ្គត់ផ្គង់តែនៅក្នុង ruby-core ប៉ុណ្ណោះ។

• ការកសាង Ruby ឥឡូវនេះតម្រូវឱ្យមានកម្មវិធីចងក្រង C ដែលគាំទ្រស្តង់ដារ C99 ។

ប្រភព: opennet.ru