റൂബി 2.7.0 പ്രോഗ്രാമിംഗ് ഭാഷയുടെ പ്രകാശനം

ഒരു വർഷത്തെ വികസനത്തിന് ശേഷം പ്രസിദ്ധീകരിച്ചു പ്രകാശനം റൂബി 2.7.0, ഒരു ഡൈനാമിക് ഒബ്ജക്റ്റ്-ഓറിയന്റഡ് പ്രോഗ്രാമിംഗ് ഭാഷ, അത് പ്രോഗ്രാം ഡെവലപ്‌മെന്റിൽ വളരെ കാര്യക്ഷമമാണ്, കൂടാതെ Perl, Java, Python, Smalltalk, Eiffel, Ada, Lisp എന്നിവയുടെ മികച്ച സവിശേഷതകൾ ഉൾക്കൊള്ളുന്നു. പ്രോജക്റ്റ് കോഡ് 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}
  ഇൻ{a:0,x:1}
  :എത്താനാകില്ല
  {a: 0, b: var}-ൽ
  p var #=> 1
  അവസാനിക്കുന്നു

• ഇന്ററാക്ടീവ് കണക്കുകൂട്ടലുകളുടെ ഷെല്ലിന് (REPL, Read-Eval-Print-Loop) ഇപ്പോൾ മൾട്ടി-ലൈൻ എഡിറ്റിംഗിന്റെ സാദ്ധ്യതയുണ്ട്, ഇത് ഒരു റീഡ്‌ലൈൻ-അനുയോജ്യമായ ലൈബ്രറി ഉപയോഗിച്ച് നടപ്പിലാക്കുന്നു. വിശ്രമിക്കുകറൂബിയിൽ എഴുതിയിരിക്കുന്നു. rdoc-നുള്ള പിന്തുണ സംയോജിപ്പിച്ചിരിക്കുന്നു, ഇത് irb-യിലെ നിർദ്ദിഷ്ട ക്ലാസുകൾ, മൊഡ്യൂളുകൾ, രീതികൾ എന്നിവയെക്കുറിച്ചുള്ള റഫറൻസ് വിവരങ്ങൾ കാണുന്നതിന് അനുവദിക്കുന്നു. Binding#irb-ലൂടെ കാണിച്ചിരിക്കുന്ന കോഡുള്ള ലൈനുകളുടെ നിറമുള്ള ഹൈലൈറ്റിംഗും അടിസ്ഥാന ക്ലാസ് ഒബ്‌ജക്റ്റുകൾ പരിശോധിക്കുന്നതിന്റെ ഫലങ്ങളും നൽകിയിരിക്കുന്നു.
  

• ചില മൾട്ടി-ത്രെഡ് റൂബി ആപ്ലിക്കേഷനുകളുടെ പ്രവർത്തന സമയത്ത് സംഭവിക്കുന്ന മെമ്മറി ഫ്രാഗ്‌മെന്റേഷൻ കാരണം മെമ്മറിയുടെ മന്ദഗതിയിലുള്ള പ്രകടനത്തിന്റെയും വർദ്ധിച്ച മെമ്മറി ഉപഭോഗത്തിന്റെയും പ്രശ്‌നങ്ങൾ പരിഹരിക്കുന്നതിനും മെമ്മറിയുടെ ഒരു പ്രദേശത്തിന്റെ ഡീഫ്രാഗ്മെന്റേഷൻ നടത്താനും കഴിയുന്ന ഒരു കോംപാക്റ്റ് ഗാർബേജ് കളക്ടർ (കോംപാക്‌ഷൻ ജിസി) ചേർത്തു. കൂമ്പാരത്തിൽ വസ്തുക്കൾ പാക്ക് ചെയ്യാൻ നിർദ്ദേശിച്ചു ഉപയോഗിച്ച മെമ്മറി പേജുകളുടെ എണ്ണം കുറയ്ക്കുന്നതിനും പ്രവർത്തനങ്ങൾക്കായി ഹീപ്പ് ഒപ്റ്റിമൈസ് ചെയ്യുന്നതിനുമുള്ള GC.compact രീതി
  പശു (പകർപ്പ്-ഓൺ-റൈറ്റ്).

• നടപ്പിലാക്കി ലിസ്റ്റിലെ സ്ഥാനം ("def foo(a,b,c)") കീവേഡുകൾ ("def foo(key: val)") എന്നിവയെ അടിസ്ഥാനമാക്കി വേർതിരിക്കുന്ന ആർഗ്യുമെന്റുകൾ തയ്യാറാക്കാൻ തയ്യാറെടുക്കുന്നു. കീവേഡുകളും സ്ഥാനവും അടിസ്ഥാനമാക്കിയുള്ള സ്വയമേവയുള്ള ആർഗ്യുമെന്റ് പരിവർത്തനം അവസാനിപ്പിച്ചു, റൂബി 3.0 ബ്രാഞ്ചിൽ പിന്തുണയ്‌ക്കില്ല. പ്രത്യേകിച്ചും, അവസാന ആർഗ്യുമെന്റ് കീവേഡ് പാരാമീറ്ററുകളായി ഉപയോഗിക്കുന്നതിനും കീവേഡ് അധിഷ്‌ഠിത ആർഗ്യുമെന്റുകൾ അവസാന ഹാഷ് പാരാമീറ്ററായി നൽകുന്നതിനും അവസാന ആർഗ്യുമെന്റിനെ പൊസിഷനൽ, കീവേഡ് പാരാമീറ്ററുകളായി വിഭജിക്കാനും ഇത് ഒഴിവാക്കിയിരിക്കുന്നു.

  def foo (കീ: 42); അവസാനിക്കുന്നു; foo({കീ: 42}) #മുന്നറിയിപ്പ് നൽകി
  def foo (**kw); അവസാനിക്കുന്നു; foo({കീ: 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({കീ: 42}) # ശരി
  def foo (h, കീ: 42); അവസാനിക്കുന്നു; foo({കീ: 42}) # ശരി

  def foo(h={}, കീ: 42); അവസാനിക്കുന്നു; foo("കീ" => 43, കീ: 42) #മുന്നറിയിപ്പ് നൽകി
  def foo(h={}, കീ: 42); അവസാനിക്കുന്നു; foo({"key" => 43, key: 42}) # മുന്നറിയിപ്പ് നൽകി
  def foo(h={}, കീ: 42); അവസാനിക്കുന്നു; foo({"കീ" => 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({കീ: 1}) # ശരി
  def foo(h, **nil); അവസാനിക്കുന്നു; foo({"str" ​​=> 1}) # ശരി

  h = {}; def foo(*a) അവസാനം; foo(**h) # [] h = {}; def foo(a) end; foo(**h) # {} കൂടാതെ മുന്നറിയിപ്പ്
  h = {}; def foo(*a) അവസാനം; foo(h) # [{}] h = {}; def foo(a) end; foo(h) # {}

• അവസരം ബ്ലോക്ക് പരാമീറ്ററുകൾക്കായി സ്ഥിരസ്ഥിതിയായി അക്കമിട്ട വേരിയബിൾ നാമങ്ങൾ ഉപയോഗിക്കുന്നു.

  [1, 2, 3].ഓരോന്നും { @1 } # പോലെ [1, 2, 3]. ഓരോന്നിനും { |i| ഞാൻ } ഇടുന്നു

• പ്രാരംഭ മൂല്യമില്ലാത്ത ശ്രേണികൾക്കുള്ള പരീക്ഷണാത്മക പിന്തുണ.

  ary[..3] # ary [0..3] rel.എവിടെ (വിൽപ്പന: ..100)

• ഓരോ മൂലകവും എത്ര തവണ സംഭവിക്കുന്നു എന്ന് കണക്കാക്കുന്ന, Enumerable#tally രീതി ചേർത്തു.

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

• "സ്വയം" എന്ന അക്ഷരാർത്ഥത്തിൽ സ്വകാര്യ രീതിയിലുള്ള കോൾ അനുവദനീയമാണ്

  ഡിഫൂ
  അവസാനിക്കുന്നു
  സ്വകാര്യം :foo
  self.foo

• മടിയൻ (Enumerator::Lazy) എണ്ണത്തിൽ നിന്ന് പതിവ് കണക്കെടുപ്പ് സൃഷ്ടിക്കുന്നതിനുള്ള Enumerator::Lazy#aager രീതി ചേർത്തു.

  a = %w(foo bar baz)
  ഇ = a.lazy.map {|x| x.upcase }.map {|x| x + "!" }.ആഗ്രഹിക്കുന്നു
  p e.class #=> എന്യൂമറേറ്റർ
  ഇ.മാപ്പ് {|x| x + "?" } #=> [“FOO!?”, “BAR!?”, “BAZ!?”]

• ഒരു പരീക്ഷണാത്മക JIT കമ്പൈലറിന്റെ വികസനം തുടരുന്നു, ഇത് റൂബി ഭാഷയിലെ ആപ്ലിക്കേഷനുകളുടെ പ്രകടനം ഗണ്യമായി മെച്ചപ്പെടുത്തും. റൂബിയിൽ നിർദ്ദേശിച്ചിരിക്കുന്ന JIT കംപൈലർ ആദ്യം ഡിസ്കിലേക്ക് C കോഡ് എഴുതുന്നു, അതിനുശേഷം അത് മെഷീൻ നിർദ്ദേശങ്ങൾ സൃഷ്ടിക്കുന്നതിന് ഒരു ബാഹ്യ C കംപൈലറിനെ വിളിക്കുന്നു (GCC, Clang, Microsoft VC ++ എന്നിവ പിന്തുണയ്ക്കുന്നു). പുതിയ പതിപ്പ് ആവശ്യമെങ്കിൽ ഇൻലൈൻ വിന്യാസത്തിനുള്ള ഒരു രീതി നടപ്പിലാക്കുന്നു, കംപൈലേഷൻ സമയത്ത് ഒപ്റ്റിമൈസേഷൻ മോഡുകളുടെ സെലക്ടീവ് ആപ്ലിക്കേഷൻ, "--jit-min-calls" ന്റെ ഡിഫോൾട്ട് മൂല്യം 5 ൽ നിന്ന് 10000 ആയി ഉയർത്തി, കൂടാതെ "--jit-max-cache" 1000 മുതൽ 100 ​​വരെ.
• CGI.escapeHTML, Monitor, MonitorMixin എന്നിവയുടെ മെച്ചപ്പെട്ട പ്രകടനം.
• Module#name, true.to_s, false.to_s, nil.to_s എന്നിവ നിർദ്ദിഷ്‌ട ഒബ്‌ജക്റ്റിന് മാറ്റമില്ലാത്ത ഒരു സ്ട്രിംഗ് തിരികെ നൽകുന്നുവെന്ന് ഉറപ്പാക്കുന്നു.
• RubyVM::InstructionSequence#to_binary രീതി സൃഷ്ടിച്ച ബൈനറി ഫയലുകളുടെ വലിപ്പം കുറച്ചു;
• ഉൾപ്പെടെയുള്ള അന്തർനിർമ്മിത ഘടകങ്ങളുടെ അപ്ഡേറ്റ് ചെയ്ത പതിപ്പുകൾ
  ബണ്ടർ 2.1.2, റൂബിജെംസ് 3.1.2,
  റാക്ക് 1.4.15,
  CSV 3.1.2, REXML 3.2.3,
  RSS 0.2.8,
  സ്ട്രിംഗ് സ്കാനർ 1.0.3;

• ലൈബ്രറികൾ അടിസ്ഥാന വിതരണത്തിൽ നിന്ന് ബാഹ്യ രത്ന പാക്കേജുകളിലേക്ക് മാറ്റി
  CMath (cmath gem),
  സ്കാൻഫ് (സ്കാൻഫ് രത്നം),
  ഷെൽ (ഷെൽ രത്നം),
  സിൻക്രൊണൈസർ (സമന്വയ രത്നം),
  ത്രെഡുകൾ വെയിറ്റ് (രത്നം തൂങ്ങിക്കിടക്കുക),
  E2MM (e2mmap രത്നം).

• സ്ഥിരസ്ഥിതി stdlib മൊഡ്യൂളുകൾ rubygems.org-ൽ പ്രസിദ്ധീകരിക്കുന്നു:
  മാനദണ്ഡം,
  cgi,
  പ്രതിനിധി,
  നീണ്ടുനിൽക്കുക,
  നെറ്റ് പോപ്പ്,
  നെറ്റ് എസ്എംടിപി,
  തുറക്കുക3,
  സ്റ്റോർ,
  സിംഗിൾടൺ. മോണിറ്റർ മൊഡ്യൂളുകൾ rubygems.org-ലേക്ക് നീക്കിയിട്ടില്ല
  നിരീക്ഷകൻ,
  ടൈം ഔട്ട്,
  ട്രേസർ,
  ഉറി,
  യമൽ, റൂബി-കോർ ഉപയോഗിച്ച് മാത്രം അയയ്‌ക്കപ്പെടുന്നു.

• റൂബി നിർമ്മിക്കുന്നതിന് ഇപ്പോൾ C99 സ്റ്റാൻഡേർഡിനെ പിന്തുണയ്ക്കുന്ന ഒരു സി കമ്പൈലർ ആവശ്യമാണ്.

അവലംബം: opennet.ru