Post jaro da evoluo liberigi , dinamika, objekt-orientita programlingvo kiu estas tre efika en programevoluo kaj asimilas la plej bonajn ecojn de Perl, Java, Python, Smalltalk, Eiffel, Ada, kaj Lisp. La projektkodo estas distribuita sub la permesiloj BSD ("2-paragrafo BSDL") kaj "Ruby", kiuj rilatas al la plej nova versio de la GPL-licenco kaj estas plene kongrua kun GPLv3. Ruby 2.7 estas la sepa grava eldono post laŭplana evoluprocezo, kiu daŭras jaron por prepari funkciajn plibonigojn kaj produktas prizorgajn eldonojn ĉiujn 2-3 monatojn.
Ĉefa :
- Eksperimenta ŝablono kongruo (), kiuj ebligas al vi ripetadi super donita objekto kaj atribui valoron se estas kongruo al la ŝablono.
kazo [0, [1, 2, 3]] en [a, [b, *c]] pa #=> 0
pb # => 1
pc # => [2, 3] finokazo {a: 0, b: 1}
en{a:0,x:1}
:nedisponebla
en {a: 0, b: var}
p var # => 1
fino - La ŝelo de interagaj kalkuloj irb (REPL, Read-Eval-Print-Loop) nun havas plurlinian redaktadon, efektivigitan uzante readline-kongruan bibliotekon skribita en Ruby. Subteno por rdoc estis integrita, kio permesas vidi referencan informon pri specifitaj klasoj, moduloj kaj metodoj en irb. Kolora reliefigo de linioj kun kodo montrita per Binding#irb kaj rezultoj de inspektado de bazklasaj objektoj estas provizita.
- Aldonita kompakta rubokolektilo (Compaction GC) kiu povas malfragmenti regionon de memoro, solvante la problemojn de malrapida agado kaj pliigita memorkonsumo pro memorfragmentiĝo kiu okazas dum la funkciado de kelkaj plurfadenaj Ruby-aplikoj. Paki objektojn sur la amaso GC.compact metodo por redukti la nombron da memorpaĝoj uzataj kaj optimumigi la amason por operacioj
Bovino (kopio-sur-skribi). - prepariĝante por apartigi argumentojn bazitajn sur listpozicio ("def foo(a,b,c)") kaj ŝlosilvortoj ("def foo(ŝlosilo: val)"). Aŭtomata argumenta konvertiĝo bazita sur ŝlosilvortoj kaj pozicio estas malrekomendita kaj ne estos subtenata en la branĉo Ruby 3.0. Specife, ĝi malrekomendis uzi la lastan argumenton kiel ŝlosilvorto-parametrojn, pasante ŝlosilvorto-bazitajn argumentojn kiel la lasta hash-parametron, kaj dividante la lastan argumenton en poziciajn kaj ŝlosilvortojn parametrojn.
def foo(ŝlosilo: 42); fino; foo({ŝlosilo: 42}) #avertita
def foo(**kw); fino; foo({ŝlosilo: 42}) # avertita
def foo(ŝlosilo: 42); fino; foo(**{ŝlosilo: 42}) # Bone
def foo(**kw); fino; foo(**{ŝlosilo: 42}) # Bonedef foo(h, **kw); fino; foo(ŝlosilo: 42) #avertita
def foo(h, klavo: 42); fino; foo(ŝlosilo: 42) #avertita
def foo(h, **kw); fino; foo({ŝlosilo: 42}) # Bone
def foo(h, klavo: 42); fino; foo({ŝlosilo: 42}) # Bonedef foo(h={}, ŝlosilo: 42); fino; foo("key" => 43, klavo: 42) # avertita
def foo(h={}, ŝlosilo: 42); fino; foo({"key" => 43, ŝlosilo: 42}) # avertita
def foo(h={}, ŝlosilo: 42); fino; foo({"key" => 43}, klavo: 42) # Bonedef foo(opt={}); fino; foo(ŝlosilo: 42) # Bone
def foo(h, **nil); fino; foo(ŝlosilo: 1) #ArgumentError
def foo(h, **nil); fino; foo(**{ŝlosilo: 1}) # ArgumentError
def foo(h, **nil); fino; foo ("str" => 1) # ArgumentError
def foo(h, **nil); fino; foo({ŝlosilo: 1}) # Bone
def foo(h, **nil); fino; foo({"str" => 1}) # Boneh = {}; def foo(*a) end; foo(**h) # [] h = {}; def foo(a) end; foo(**h) # {} kaj averto
h = {}; def foo(*a) a end; foo(h) # [{}] h = {}; def foo(a) a end; foo(h) # {} - uzante numeritajn defaŭltajn variablonomojn por blokaj parametroj.
[1, 2, 3].ĉiu { metas @1 } # sama kiel [1, 2, 3].ĉiu { |i| metas i}
- Eksperimenta subteno por intervaloj sen komenca valoro.
ary[..3] # simila al ary[0..3] rel.where(vendoj: ..100)
- Aldonita la metodo Enumerable#tally, kiu kalkulas kiom da fojoj okazas ĉiu elemento.
["a", "b", "c", "b"].tally
#=> {“a” => 1, “b” => 2, “c” => 1} - Permesita voki privatan metodon kun la laŭvorta "memo"
def foo
fino
private :foo
mem.foo - Aldonita Enumerator::Lazy#eager-metodo por generi regulan listigon de maldiligenta listigilo (Enumerator::Lazy).
a = %w(foo bar baz)
e = a.lazy.map {|x| x.majuskle }.mapo {|x| x + "!" }.avida
p e.class #=> Enumeralo
p e.mapo {|x| x + "?" } #=> ["FOO!?", "BAR!?", "BAZ!?"] - La evoluo de eksperimenta JIT-kompililo daŭris, kiu povas signife plibonigi la agadon de aplikoj en la Ruby-lingvo. La JIT-kompililo de Ruby unue skribas C-kodon al disko, kaj poste vokas eksteran C-kompililon por generi maŝininstrukciojn (subtenas voki GCC, Clang, kaj Microsoft VC++). La nova versio efektivigas metodon por enlinia deplojo se necese, selektema apliko de optimumigaj reĝimoj dum kompilo estas certigita, la defaŭlta valoro de "--jit-min-calls" estas pliigita de 5 ĝis 10000, kaj "--jit-max- kaŝmemoro” de 1000 ĝis 100 .
- Plibonigita rendimento de CGI.escapeHTML, Monitor kaj MonitorMixin.
- Module#name, true.to_s, false.to_s, kaj nil.to_s certigas, ke ĉeno estas resendita senŝanĝa por la specifita objekto.
- La grandeco de binaraj dosieroj generitaj de la RubyVM::InstructionSequence#to_binary-metodo estis reduktita;
- Ĝisdatigitaj versioj de enkonstruitaj komponantoj, inkluzive
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; - Bibliotekoj moviĝis de baza distribuo al eksteraj gempakaĵoj
CMath (cmath gemo),
Scanf (skanf gemo),
Ŝelo (ŝelo gemo)
Sinkronigilo (sinkroniga gemo),
ThreadsWait (atendu gemo),
E2MM (e2mmap gemo). - La defaŭltaj stdlib-moduloj estas publikigitaj ĉe rubygems.org:
komparnormo,
cgi,
delegito,
getoptlong,
reta popmuziko,
net-smtp
malfermita3,
pbutiko,
singleton. monitoraj moduloj ne movitaj al rubygems.org
observanto,
timeout
spurilo,
uri,
yaml, kiuj estas nur provizitaj en rubeno-kerno. - Konstruado de Ruby nun postulas C-kompililon kiu subtenas la C99-normon.
fonto: opennet.ru