Vydanie programovacieho jazyka Ruby 2.7.0

Po roku vývoja zverejnená uvoľnenie Ruby 2.7.0, dynamický, objektovo orientovaný programovací jazyk, ktorý je vysoko efektívny pri vývoji programov a zahŕňa najlepšie vlastnosti Perlu, Java, Pythonu, Smalltalku, Eiffela, Ada a Lisp. Kód projektu je distribuovaný pod licenciou BSD („2-klauzulová BSDL“) a „Ruby“, ktorá sa vzťahuje na najnovšiu verziu licencie GPL a je plne kompatibilná s GPLv3. Ruby 2.7 je siedme hlavné vydanie po plánovanom procese vývoja, ktorý trvá jeden rok, kým sa pripravujú funkčné vylepšenia a každé 2-3 mesiace produkuje vydania na údržbu.

Hlavné vylepšenia:

• Experimentálne podpora zhoda vzorov (Zhoda vzorov), ktoré vám umožňujú iterovať daný objekt a priradiť hodnotu, ak existuje zhoda so vzorom.

  prípad [0, [1, 2, 3]] v [a, [b, *c]] pa #=> 0
  pb #=> 1
  pc #=> [2, 3] koniec

  prípad {a: 0, b: 1}
  v {a: 0, x: 1}
  :nedostupné
  v {a: 0, b: var}
  p var #=> 1
  koniec

• Shell interaktívnych výpočtov irb (REPL, Read-Eval-Print-Loop) teraz obsahuje viacriadkové úpravy, implementované pomocou knižnice kompatibilnej s readline odpočívať, napísaný v rubíne. bola integrovaná podpora rdoc, ktorá vám umožňuje zobraziť referenčné informácie o špecifikovaných triedach, moduloch a metódach v irb. Poskytnuté farebné zvýraznenie riadkov kódu zobrazených cez Binding#irb a výsledky kontroly objektov základnej triedy.
  

• Pridaný kompaktný garbage collector (Compaction GC), ktorý dokáže defragmentovať oblasť pamäte, čím rieši problémy s výkonom a spotrebou pamäte spôsobené fragmentáciou pamäte, ktorá sa vyskytuje v niektorých aplikáciách Ruby s viacerými vláknami. Na balenie predmetov na hromadu navrhované Metóda GC.compact, ktorá umožňuje znížiť počet použitých pamäťových stránok a optimalizovať haldu pre operácie
  CoW (copy-on-write).

• Vykonané príprava na oddelenie argumentov na základe pozície v zozname („def foo(a,b,c)“) a kľúčových slov („def foo(key: val)“). Automatická konverzia argumentov na základe kľúčových slov a pozície bola zastaraná a nebude podporovaná vo vetve Ruby 3.0. Konkrétne zastaral používanie posledného argumentu ako parametrov kľúčového slova, odovzdávanie argumentov založených na kľúčových slovách ako posledný hash parameter a rozdelenie posledného argumentu na pozičné parametre a parametre kľúčového slova.

  def foo(kľúč: 42); koniec; foo({key: 42}) # varovaný
  def foo(**kw); koniec; foo({key: 42}) # varovaný
  def foo(kľúč: 42); koniec; foo(**{key: 42}) # OK
  def foo(**kw); koniec; foo(**{key: 42}) # OK

  def foo(h, **kw); koniec; foo(key: 42) # varoval
  def foo(h, kľúč: 42); koniec; foo(key: 42) # varoval
  def foo(h, **kw); koniec; foo({key: 42}) # OK
  def foo(h, kľúč: 42); koniec; foo({key: 42}) # OK

  def foo(h={}, kľúč: 42); koniec; foo("key" => 43, key: 42) # varovany
  def foo(h={}, kľúč: 42); koniec; foo({"key" => 43, kľúč: 42}) # varovaný
  def foo(h={}, kľúč: 42); koniec; foo({"key" => 43}, kľúč: 42) # OK

  def foo(opt={}); koniec; foo( kľúč: 42 ) # OK

  def foo(h, **nula); koniec; foo(kľúč: 1) #ArgumentError
  def foo(h, **nula); koniec; foo(**{key: 1}) # ArgumentError
  def foo(h, **nula); koniec; foo("str" ​​​​=> 1) # ArgumentError
  def foo(h, **nula); koniec; foo({key: 1}) # OK
  def foo(h, **nula); koniec; foo({"str" ​​​​=> 1}) # OK

  h = {}; def foo(*a) koniec; foo(**h) # [] h = {}; def foo(a) koniec; foo(**h) # {} a varovanie
  h = {}; def foo(*a) koniec; foo(h) # [{}] h = {}; def foo(a) koniec; foo(h) # {}

• Príležitosť štandardné používanie číslovaných názvov premenných pre parametre bloku.

  [1, 2, 3].každý { vloží @1 } # to isté ako [1, 2, 3].každý { |i| kladie ja }

• Experimentálna podpora pre rozsahy bez počiatočnej hodnoty.

  ary[..3] # podobne ako ary[0..3] rel.where(predaj: ..100)

• Pridaná metóda Enumerable#tally, ktorá počíta počet výskytov každého prvku.

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

• Povolené volať súkromnú metódu s doslovným „ja“

  def foo
  koniec
  súkromný :foo
  seba.foo

• Pridaná metóda Enumerator::Lazy#eager na generovanie pravidelného enumerácie z lenivého enumerátora (Enumerator::Lazy).

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

• Pokračoval vývoj experimentálneho JIT kompilátora, ktorý môže výrazne zlepšiť výkon aplikácií v jazyku Ruby. Kompilátor JIT od Ruby najprv zapíše kód C na disk a potom zavolá externý kompilátor C na generovanie strojových inštrukcií (podporuje volanie GCC, Clang a Microsoft VC++). Nová verzia implementuje metódu pre inline nasadenie v prípade potreby, je zabezpečená selektívna aplikácia optimalizačných režimov počas kompilácie, predvolená hodnota „--jit-min-calls“ sa zvyšuje z 5 na 10000 1000 a „--jit-max- cache“ od 100 do XNUMX .
• Vylepšený výkon CGI.escapeHTML, Monitor a MonitorMixin.
• Module#name, true.to_s, false.to_s a nil.to_s zaisťujú, že sa vráti reťazec, ktorý je nezmenený pre špecifikovaný objekt.
• Veľkosť binárnych súborov generovaných metódou RubyVM::InstructionSequence#to_binary; bola znížená.
• Aktualizované verzie vstavaných komponentov, vrátane
  Bundler 2.1.2, RubyGems 3.1.2,
  Racc 1.4.15,
  CSV 3.1.2, REXML 3.2.3,
  RSS 0.2.8,
  StringScanner 1.0.3;

• Knižnice boli presunuté zo základného balíka do externých balíčkov drahokamov
  CMath (drahokam cmath),
  Scanf (skenovať drahokam),
  Škrupina (drahokam z mušlí)
  Synchronizátor (synchronizačný drahokam),
  ThreadsWait (thwait drahokam),
  E2MM (drahokam e2mmap).

• Predvolené moduly stdlib sú zverejnené na rubygems.org:
  benchmark,
  cgi,
  delegovať
  getoptlong,
  net-pop,
  net-smtp
  open3,
  pstore,
  singleton. moduly monitora neboli presunuté na rubygems.org
  pozorovateľ
  čas vypršal
  stopár,
  uri,
  yaml, ktoré sú poskytované iba v rubínovom jadre.

• Budovanie Ruby teraz vyžaduje kompilátor C, ktorý podporuje štandard C99.

Zdroj: opennet.ru