Rhyddhau iaith raglennu Ruby 2.7.0

Ar ôl blwyddyn o ddatblygiad cyhoeddi rhyddhau Ruby 2.7.0, iaith raglennu ddeinamig sy'n canolbwyntio ar wrthrych sy'n hynod effeithlon o ran datblygu rhaglenni ac sy'n ymgorffori nodweddion gorau Perl, Java, Python, Smalltalk, Eiffel, Ada a Lisp. Mae cod y prosiect yn cael ei ddosbarthu o dan y trwyddedau BSD ("2-gymal BSDL") a "Ruby", sy'n cyfeirio at y fersiwn ddiweddaraf o'r drwydded GPL ac mae'n gwbl gydnaws â GPLv3. Ruby 2.7 yw'r seithfed datganiad mawr i'w gynhyrchu fel rhan o broses ddatblygu gynlluniedig sy'n cynnwys neilltuo blwyddyn ar gyfer gwella nodweddion a rhyddhau patsh 2-3 mis.

Y prif gwelliannau:

• arbrofol cefnogaeth paru patrwm (Paru patrymau) i ailadrodd dros y gwrthrych a roddwyd a phennu gwerth os oes patrwm cyfatebol.

  achos [0, [1, 2, 3]] yn [a, [b, *c]] pa #=> 0
  pb #=> 1
  pc #=> [2, 3] diwedd

  achos {a: 0, b: 1}
  yn{a:0,x:1}
  : anghyraeddadwy
  yn {a: 0, b: var}
  p var #=> 1
  diwedd

• Bellach mae gan y gragen o gyfrifiadau rhyngweithiol irb (REPL, Read-Eval-Print-Loop) y posibilrwydd o olygu aml-linell, wedi'i weithredu gan ddefnyddio llyfrgell darllen-lein ail-leinioysgrifennwyd yn Ruby. Mae cefnogaeth ar gyfer rdoc wedi'i hintegreiddio, sy'n caniatáu edrych ar wybodaeth gyfeirio ar ddosbarthiadau, modiwlau a dulliau penodol yn irb. Darperir aroleuo llinellau lliw gyda chod trwy Rhwymo#irb a chanlyniadau archwilio gwrthrychau dosbarth sylfaen.
  

• Mae Compaction GC wedi'i ychwanegu a all ddarnio rhanbarth o gof, gan ddatrys problemau perfformiad araf a mwy o ddefnydd cof oherwydd darnio cof sy'n digwydd yn ystod gweithrediad rhai cymwysiadau Ruby aml-edau. I bacio gwrthrychau ar y domen arfaethedig Dull GC.compact i leihau nifer y tudalennau cof a ddefnyddir a gwneud y gorau o'r domen ar gyfer gweithrediadau
  CoW (copi-ar-ysgrifennu).

• Wedi'i wneud paratoi i wahanu dadleuon yn seiliedig ar safle yn y rhestr ("def foo(a,b,c)") a geiriau allweddol ("def foo (allwedd: val)"). Mae trosi dadl awtomatig yn seiliedig ar allweddeiriau a safle wedi'i anghymeradwyo ac ni fydd yn cael ei gefnogi yng nghangen Ruby 3.0. Yn benodol, mae'n anghymeradwy i ddefnyddio'r ddadl olaf fel paramedrau allweddair, i basio dadleuon sy'n seiliedig ar allweddair fel y paramedr hash olaf, ac i rannu'r ddadl olaf yn baramedrau lleoliadol ac allweddair.

  def foo (allwedd: 42); diwedd; foo({allwedd: 42}) #rhybudd
  def foo(**kw); diwedd; foo({allwedd: 42}) #rhybudd
  def foo (allwedd: 42); diwedd; foo(**{allwedd: 42}) # Iawn
  def foo(**kw); diwedd; foo(**{allwedd: 42}) # Iawn

  def foo(h, **kw); diwedd; foo(allwedd: 42) #rhybudd
  def foo(h, allwedd: 42); diwedd; foo(allwedd: 42) #rhybudd
  def foo(h, **kw); diwedd; foo({key: 42}) # Iawn
  def foo(h, allwedd: 42); diwedd; foo({key: 42}) # Iawn

  def foo(h={}, allwedd: 42); diwedd; foo("key" => 43, allwedd: 42) #rhybudd
  def foo(h={}, allwedd: 42); diwedd; foo({ "key" => 43, allwedd: 42}) # rhybuddio
  def foo(h={}, allwedd: 42); diwedd; foo({ "key" => 43}, allwedd: 42) # Iawn

  def foo(opt={}); diwedd; foo( allwedd: 42 ) # Iawn

  def foo(h, **dim); diwedd; foo(allwedd: 1) # ArgumentError
  def foo(h, **dim); diwedd; foo(**{ allwedd: 1}) # ArgumentError
  def foo(h, **dim); diwedd; foo( "str" ​​=> 1) # ArgumentError
  def foo(h, **dim); diwedd; foo({key: 1}) # Iawn
  def foo(h, **dim); diwedd; foo({ "str" ​​=> 1}) # Iawn

  h = {} ; def foo(*a) diwedd; foo(**h) # [] h = {}; def foo(a) diwedd; foo(**h) # {} a rhybudd
  h = {} ; def foo(*a) diwedd; foo(h) # [{}] h = {}; def foo(a) diwedd; foo(h) # {}

• Cyfle defnyddio enwau newidyn wedi'u rhifo yn ddiofyn ar gyfer paramedrau bloc.

  [1, 2, 3].each { yn rhoi @1 } # fel [1, 2, 3].each { |i| yn rhoi i }

• Cefnogaeth arbrofol ar gyfer ystodau heb unrhyw werth cychwynnol.

  ary[..3] # yr un peth ag ary[0..3] rel.where(gwerthiannau: ..100)

• Wedi ychwanegu'r dull rhif # rhif, sy'n cyfrif sawl gwaith mae pob elfen yn digwydd.

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

• Caniateir galwad dull preifat gyda "hunan" yn llythrennol

  deffoo
  diwedd
  preifat: foo
  hunan.foo

• Ychwanegwyd y Cyfrifydd::Dull diog#aer i gynhyrchu rhif arferol o gyfrif diog (Rhifiadur::Diog).

  a = % w(foo bar baz)
  e = a.lazy.map {|x| x.upcase }.map {|x| x + "!" }.yn awyddus
  p e.class #=> Rhifiadur
  e.map {|x| x +"?" } #=> ["FOO!?", "BAR!?", "BAZ!?"]

• Mae datblygiad casglwr JIT arbrofol wedi parhau, a all wella perfformiad cymwysiadau yn yr iaith Ruby yn sylweddol. Mae'r casglwr JIT a gynigir yn Ruby yn ysgrifennu cod C i ddisg yn gyntaf, ac ar ôl hynny mae'n galw casglwr C allanol i gynhyrchu cyfarwyddiadau peiriant (cefnogir GCC, Clang a Microsoft VC ++). Mae'r fersiwn newydd yn gweithredu dull ar gyfer defnyddio mewnol os oes angen, cymhwyso dulliau optimeiddio yn ddetholus yn ystod y broses lunio, cynyddir gwerth rhagosodedig "--jit-min-calls" o 5 i 10000, a "--jit-max-cache" o 1000 i 100.
• Gwell perfformiad o CGI.escapeHTML, Monitor a MonitorMixin.
• Mae Modiwl#name, true.to_s, false.to_s, a nil.to_s yn sicrhau bod llinyn yn cael ei ddychwelyd heb ei newid ar gyfer y gwrthrych penodedig.
• Mae maint y ffeiliau deuaidd a gynhyrchir gan y dull RubyVM::InstructionSequence#to_binary wedi'i leihau;
• Fersiynau wedi'u diweddaru o gydrannau adeiledig, gan gynnwys
  Bwndelwr 2.1.2, RubyGems 3.1.2,
  Racc 1.4.15,
  CSV 3.1.2, REXML 3.2.3,
  RSS 0.2.8,
  Sganiwr Llinynnol 1.0.3;

• Symudodd llyfrgelloedd o ddosbarthiad sylfaenol i becynnau gemau allanol
  CMath (cmath gem),
  Scanf (scanff gem),
  Cragen (plys cragen),
  Synchronizer (cydamseru gem),
  ThreadsWait (thwait gem),
  E2MM (gem e2mmap).

• Cyhoeddir y modiwlau stdlib rhagosodedig ar rubygems.org:
  meincnod,
  cgi,
  dirprwyo,
  getoptlong,
  pop rhwyd,
  smtp net,
  agor 3,
  pstore,
  sengl. Monitro modiwlau heb eu symud i rubygems.org
  sylwedydd,
  Amser allan,
  olrheiniwr,
  wri,
  yaml, sy'n cael eu cludo gyda rhuddem craidd yn unig.

• Mae Building Ruby bellach angen casglwr C sy'n cefnogi safon C99.

Ffynhonnell: opennet.ru