Vydání programovacího jazyka Ruby 2.7.0

Po roce vývoje publikováno uvolnění Ruby 2.7.0, dynamický objektově orientovaný programovací jazyk, který je vysoce efektivní při vývoji programů a obsahuje nejlepší vlastnosti Perlu, Javy, Pythonu, Smalltalku, Eiffel, Ada a Lisp. Kód projektu je distribuován pod licencemi BSD ("2-klauzule BSDL") a "Ruby", která odkazuje na nejnovější verzi licence GPL a je plně kompatibilní s GPLv3. Ruby 2.7 je sedmá hlavní verze, která má být vytvořena jako součást plánovaného vývojového procesu, který zahrnuje vyčlenění jednoho roku na vylepšení funkcí a 2–3měsíční vydání oprav.

hlavní vylepšení:

• experimentální podpora shoda vzorů (Shoda vzorů) pro iteraci daného objektu a přiřazení hodnoty, pokud existuje shoda vzoru.

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

  případ {a: 0, b: 1}
  v{a:0,x:1}
  :nedosažitelný
  v {a: 0, b: var}
  p var #=> 1
  konec

• Shell interaktivních výpočtů irb (REPL, Read-Eval-Print-Loop) má nyní možnost víceřádkové editace, implementované pomocí knihovny kompatibilní s readline odpočívatnapsáno v Ruby. Byla integrována podpora pro rdoc, která umožňuje prohlížení referenčních informací o specifikovaných třídách, modulech a metodách v irb. K dispozici je barevné zvýraznění řádků s kódem zobrazeným prostřednictvím Binding#irb a výsledky kontroly objektů základní třídy.
  

• Přidán kompaktní garbage collector (Compaction GC), který dokáže defragmentovat oblast paměti, čímž řeší problémy s pomalým výkonem a zvýšenou spotřebou paměti v důsledku fragmentace paměti, ke které dochází při provozu některých vícevláknových aplikací Ruby. K balení předmětů na hromadě navržený Metoda GC.compact ke snížení počtu použitých stránek paměti a optimalizaci haldy pro operace
  CoW (copy-on-write).

• Odneseno příprava na oddělení argumentů na základě pozice v seznamu ("def foo(a,b,c)") a klíčových slov ("def foo(klíč: val)"). Automatická konverze argumentů na základě klíčových slov a pozice byla zastaralá a nebude podporována ve větvi Ruby 3.0. Zejména bylo zavrženo používání posledního argumentu jako parametrů klíčových slov, předávání argumentů založených na klíčových slovech jako posledního hashovacího parametru a rozdělení posledního argumentu na poziční parametry a parametry klíčových slov.

  def foo(klíč: 42); konec; foo({klíč: 42}) #varován
  def foo(**kw); konec; foo({klíč: 42}) #varován
  def foo(klíč: 42); konec; foo(**{klíč: 42}) # OK
  def foo(**kw); konec; foo(**{klíč: 42}) # OK

  def foo(h, **kw); konec; foo(klíč: 42) #varován
  def foo(h, klíč: 42); konec; foo(klíč: 42) # varován
  def foo(h, **kw); konec; foo({klíč: 42}) # OK
  def foo(h, klíč: 42); konec; foo({klíč: 42}) # OK

  def foo(h={}, klíč: 42); konec; foo("klíč" => 43, klíč: 42) #varováno
  def foo(h={}, klíč: 42); konec; foo({"klíč" => 43, klíč: 42}) # varován
  def foo(h={}, klíč: 42); konec; foo({"klíč" => 43}, klíč: 42) # OK

  def foo(opt={}); konec; foo( klíč: 42 ) # OK

  def foo(h, **nula); konec; foo(klíč: 1) # ArgumentError
  def foo(h, **nula); konec; foo(**{klíč: 1}) # ArgumentError
  def foo(h, **nula); konec; foo("str" ​​​​=> 1) # ArgumentError
  def foo(h, **nula); konec; foo({klíč: 1}) # OK
  def foo(h, **nula); konec; foo({"str" ​​​​=> 1}) # OK

  h = {}; def foo(*a) konec; foo(**h) # [] h = {}; def foo(a) konec; foo(**h) # {} a varování
  h = {}; def foo(*a) konec; foo(h) # [{}] h = {}; def foo(a) konec; foo(h) # {}

• Příležitost použití číslovaných výchozích názvů proměnných pro parametry bloku.

  [1, 2, 3].každý { vloží @1 } # jako [1, 2, 3].každý { |i| klade i}

• Experimentální podpora pro rozsahy bez počáteční hodnoty.

  ary[..3] # stejné jako ary[0..3] rel.where(prodej: ..100)

• Přidána metoda Enumerable#tally, která počítá, kolikrát se každý prvek vyskytuje.

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

• Volání soukromé metody je povoleno s literálem "self".

  deffoo
  konec
  soukromý :foo
  self.foo

• Přidána metoda Enumerator::Lazy#eager pro generování pravidelného výčtu z líného enumerátoru (Enumerator::Lazy).

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

• Pokračoval vývoj experimentálního JIT kompilátoru, který může výrazně zlepšit výkon aplikací v jazyce Ruby. JIT kompilátor Ruby nejprve zapíše kód C na disk a poté zavolá externí kompilátor C, aby vygeneroval strojové instrukce (podporuje volání GCC, Clang a Microsoft VC++). Nová verze implementuje metodu pro inline nasazení v případě potřeby, je zajištěna selektivní aplikace optimalizačních režimů při kompilaci, výchozí hodnota „--jit-min-calls“ je zvýšena z 5 na 10000 a „--jit-max- cache“ od 1000 do 100 .
• Vylepšený výkon CGI.escapeHTML, Monitor a MonitorMixin.
• Module#name, true.to_s, false.to_s a nil.to_s zajišťují, že je vrácen řetězec, který je pro zadaný objekt nezměněn.
• Velikost binárních souborů generovaných metodou RubyVM::InstructionSequence#to_binary byla zmenšena;
• Aktualizované verze vestavěných komponent, včetně
  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;

• Knihovny byly přesunuty ze základního balíčku do externích balíčků drahokamů
  CMath (drahokam cmath),
  Scanf (skenovat drahokam),
  Shell (skořápka drahokam),
  Synchronizátor (synchronizační drahokam),
  ThreadsWait (thwait drahokam),
  E2MM (drahokam e2mmap).

• Výchozí moduly stdlib jsou publikovány na rubygems.org:
  měřítko,
  cgi,
  delegát,
  getoptlong,
  net-pop,
  čistý smtp,
  open3,
  pstore,
  jedináček. Monitorovací moduly nebyly přesunuty na rubygems.org
  pozorovatel,
  Časový limit
  značkovač,
  nenávist,
  yaml, které jsou dodávány pouze s rubínovým jádrem.

• Sestavení Ruby nyní vyžaduje kompilátor C, který podporuje standard C99.

Zdroj: opennet.ru