🥇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] # podobné 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