Ruby programmēšanas valodas 2.7.0 izlaišana

Pēc gada attīstības publicēta atbrīvot Ruby 2.7.0, dinamiska objektorientēta programmēšanas valoda, kas ir ļoti efektīva programmu izstrādē un ietver Perl, Java, Python, Smalltalk, Eiffel, Ada un Lisp labākās iespējas. Projekta kods tiek izplatīts saskaņā ar BSD ("2 klauzulu BSDL") un "Ruby" licencēm, kas attiecas uz jaunāko GPL licences versiju un ir pilnībā savietojams ar GPLv3. Ruby 2.7 ir septītais lielākais laidiens, kas tiks ražots kā daļa no plānotā izstrādes procesa, kas ietver gada atvēlēšanu funkciju uzlabojumiem un 2–3 mēnešu ielāpu.

Galvenais uzlabojumi:

• eksperimentāls atbalstīt modeļa saskaņošana (Rakstu saskaņošana), lai atkārtotu doto objektu un piešķirtu vērtību, ja ir modeļa atbilstība.

  gadījums [0, [1, 2, 3]] in [a, [b, *c]] pa #=> 0
  pb #=> 1
  pc #=> [2, 3] beigas

  gadījums {a: 0, b: 1}
  in{a:0,x:1}
  : nesasniedzams
  {a: 0, b: var}
  p var #=> 1
  beigas

• Interaktīvo aprēķinu apvalkam irb (REPL, Read-Eval-Print-Loop) tagad ir vairāku rindu rediģēšanas iespēja, kas ieviesta, izmantojot ar readline saderīgu bibliotēku. atslābtrakstīts rubīnā. Ir integrēts rdoc atbalsts, kas ļauj skatīt atsauces informāciju par norādītajām klasēm, moduļiem un metodēm programmā irb. Tiek nodrošināta krāsaina līniju izcelšana ar kodu, kas parādīts caur Binding#irb, un bāzes klases objektu pārbaudes rezultāti.
  

• Pievienots kompakts atkritumu savācējs (Compaction GC), kas var defragmentēt atmiņas apgabalu, atrisinot lēnas veiktspējas un palielināta atmiņas patēriņa problēmas, ko izraisa atmiņas sadrumstalotība, kas rodas dažu daudzpavedienu Ruby lietojumprogrammu darbības laikā. Lai iepakotu priekšmetus uz kaudzes ierosināts GC.compact metode, lai samazinātu izmantoto atmiņas lapu skaitu un optimizētu kaudzi operācijām
  COW (kopēt-uz-rakstīt).

• Izpildīts gatavojas atdalīt argumentus, pamatojoties uz pozīciju sarakstā ("def foo(a,b,c)") un atslēgvārdiem ("def foo(key: val)"). Automātiskā argumentu konvertēšana, pamatojoties uz atslēgvārdiem un pozīciju, ir novecojusi, un Ruby 3.0 filiālē tā netiks atbalstīta. Jo īpaši ir novecojusi pēdējā argumenta izmantošana kā atslēgvārdu parametri, uz atslēgvārdiem balstītu argumentu nodošana kā pēdējais jaukšanas parametrs un pēdējā argumenta sadalīšana pozīcijas un atslēgvārdu parametros.

  def foo(atslēga: 42); beigas; foo({key: 42}) #warned
  def foo(**kw); beigas; foo({key: 42}) #warned
  def foo(atslēga: 42); beigas; foo(**{key: 42}) # Labi
  def foo(**kw); beigas; foo(**{key: 42}) # Labi

  def foo(h, **kw); beigas; foo(atslēga: 42) #brīdināts
  def foo(h, taustiņš: 42); beigas; foo(atslēga: 42) #brīdināts
  def foo(h, **kw); beigas; foo({key: 42}) # Labi
  def foo(h, taustiņš: 42); beigas; foo({key: 42}) # Labi

  def foo(h={}, atslēga: 42); beigas; foo("atslēga" => 43, atslēga: 42) #brīdināts
  def foo(h={}, atslēga: 42); beigas; foo({"atslēga" => 43, atslēga: 42}) # brīdināts
  def foo(h={}, atslēga: 42); beigas; foo({"key" => 43}, taustiņš: 42) # Labi

  def foo(opt={}); beigas; foo(taustiņš: 42) # Labi

  def foo(h, **nulle); beigas; foo(atslēga: 1) #ArgumentError
  def foo(h, **nulle); beigas; foo(**{key: 1}) # ArgumentError
  def foo(h, **nulle); beigas; foo("str" => 1) # Argumenta kļūda
  def foo(h, **nulle); beigas; foo({key: 1}) # Labi
  def foo(h, **nulle); beigas; foo({"str" ​​​​=> 1}) # Labi

  h = {}; def foo(*a) beigas; foo(**h) # [] h = {}; def foo(a) end; foo(**h) # {} un brīdinājums
  h = {}; def foo(*a) end; foo(h) # [{}] h = {}; def foo(a) end; foo(h) # {}

• Iespēja bloka parametriem izmantojot numurētus noklusējuma mainīgo nosaukumus.

  [1, 2, 3]. katrs { liek @1 } # patīk [1, 2, 3]. katrs { |i| ieliek es }

• Eksperimentāls atbalsts diapazoniem bez sākotnējās vērtības.

  ary[..3] # tāds pats kā ary[0..3] rel.where(pārdošana: ..100)

• Pievienota metode Enumerable#tally, kas uzskaita, cik reižu katrs elements parādās.

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

• Atļauts privātās metodes izsaukums ar burtu "self".

  deffoo
  beigas
  privāts :foo
  self.foo

• Pievienots Enumerator::Lazy#eager metode, lai ģenerētu regulāru uzskaitījumu no slinka (Enumerator::Lazy) uzskaitījuma.

  a = %w(foo bar baz)
  e = a.slinks.karte {|x| x.upcase }.map {|x| x + "!" }.eager
  p e.klase #=> Uzskaitītājs
  e.karte {|x| x + "?" } #=> ["FOO!?", "BAR!?", "BAZ!?"]

• Turpinājās eksperimentāla JIT kompilatora izstrāde, kas var būtiski uzlabot aplikāciju veiktspēju Ruby valodā. Ruby piedāvātais JIT kompilators vispirms ieraksta C kodu diskā, pēc tam izsauc ārēju C kompilatoru, lai ģenerētu mašīnas instrukcijas (tiek atbalstīti GCC, Clang un Microsoft VC ++). Jaunajā versijā ir ieviesta nepieciešamības gadījumā iekļauta izvietošanas metode, selektīva optimizācijas režīmu pielietošana kompilācijas laikā, noklusējuma vērtība "--jit-min-calls" tiek palielināta no 5 līdz 10000 un "--jit-max-cache" no 1000 līdz 100.
• Uzlabota CGI.escapeHTML, Monitor un MonitorMixin veiktspēja.
• Moduļa#nosaukums, true.to_s, false.to_s un nil.to_s nodrošina, ka norādītajam objektam tiek atgriezta virkne, kas nav mainīta.
• Ir samazināts RubyVM::InstructionSequence#to_binary metodes ģenerēto bināro failu lielums;
• Atjauninātas iebūvēto komponentu versijas, t.sk
  Bundler 2.1.2, RubyGems 3.1.2,
  Racc 1.4.15,
  CSV 3.1.2, REXML 3.2.3,
  RSS 0.2.8,
  String Scanner 1.0.3;

• Bibliotēkas tika pārvietotas no bāzes izplatīšanas uz ārējām dārgakmeņu pakotnēm
  CMath (Cmath dārgakmens),
  Scanf (scanf dārgakmens),
  Shell (čaulas dārgakmens),
  Sinhronizators (sinhronizācijas dārgakmens),
  ThreadsWait (thwait gem),
  E2MM (e2mmap dārgakmens).

• Noklusējuma stdlib moduļi ir publicēti rubygems.org:
  etalons,
  cgi,
  deleģēt,
  izklaidēties,
  tīkla pop,
  neto smtp,
  atvērts3,
  veikals,
  singleton. Monitora moduļi nav pārvietoti uz rubygems.org
  novērotājs,
  pārtraukums,
  izsekotājs
  uri,
  yaml, kas tiek piegādāti tikai ar rubīna kodolu.

• Lai izveidotu Ruby, tagad ir nepieciešams C kompilators, kas atbalsta C99 standartu.

Avots: opennet.ru