Մեկ տարի զարգացումից հետո արձակել , դինամիկ օբյեկտի վրա հիմնված ծրագրավորման լեզու, որը շատ արդյունավետ է ծրագրերի մշակման մեջ և ներառում է Perl-ի, Java-ի, Python-ի, Smalltalk-ի, Eiffel-ի, Ada-ի և Lisp-ի լավագույն հատկանիշները: Ծրագրի կոդը բաշխված է BSD («2-clause BSDL») և «Ruby» լիցենզիաների ներքո, որը վերաբերում է GPL լիցենզիայի վերջին տարբերակին և լիովին համատեղելի է GPLv3-ի հետ: Ruby 2.7-ը յոթերորդ հիմնական թողարկումն է, որը թողարկվել է որպես մշակման պլանավորված գործընթացի մաս, որը ներառում է մեկ տարի հատկացնել գործառույթների բարելավման համար և 2-3 ամիս տևողությամբ կարկատել:
Հիմնական :
- փորձարարական օրինաչափությունների համապատասխանություն () կրկնել տվյալ օբյեկտի վրա և արժեք նշանակել, եթե կա օրինաչափության համընկնում:
դեպք [0, [1, 2, 3]] [a, [b, *c]] pa #=> 0-ում
pb #=> 1
pc #=> [2, 3] վերջդեպք {a: 0, b: 1}
in{a:0,x:1}
:անհասանելի
{a: 0, b: var}-ում
p var #=> 1
վերջ - irb (REPL, Read-Eval-Print-Loop) ինտերակտիվ հաշվարկների կեղևն այժմ ունի բազմակողմանի խմբագրման հնարավորություն, որն իրականացվում է readline-ի հետ համատեղելի գրադարանի միջոցով: գրված է Ռուբինով։ Ինտեգրվել է rdoc-ի աջակցությունը, որը թույլ է տալիս irb-ում դիտել տեղեկատու տեղեկատվություն նշված դասերի, մոդուլների և մեթոդների վերաբերյալ: Տրվում է գծերի գունավոր ընդգծում Binding#irb-ի միջոցով ցուցադրված կոդով և բազային դասի օբյեկտների ստուգման արդյունքներով:
- Ավելացվեց կոմպակտ աղբի հավաքիչ (Compaction GC), որը կարող է վերափոխել հիշողության տարածքը՝ լուծելով դանդաղ աշխատանքի և հիշողության սպառման ավելացման խնդիրները՝ հիշողության մասնատման պատճառով, որը տեղի է ունենում Ruby-ի որոշ բազմաշերտ հավելվածների շահագործման ընթացքում: Իրերը կույտի վրա փաթեթավորելու համար GC.compact մեթոդ՝ օգտագործվող հիշողության էջերի քանակը նվազեցնելու և օպերացիաների համար կույտը օպտիմալացնելու համար
CoW (պատճենել-գրել): - պատրաստվելով առանձնացնել փաստարկները՝ հիմնվելով ցուցակում դիրքի վրա («def foo(a,b,c)») և հիմնաբառեր («def foo(key: val)»): Հիմնաբառերի և դիրքի վրա հիմնված փաստարկների ավտոմատ փոխարկումը հնացել է և չի ապահովվի Ruby 3.0 մասնաճյուղում: Մասնավորապես, հնացել է վերջին արգումենտը որպես բանալի բառի պարամետրեր օգտագործելը, հիմնաբառի վրա հիմնված արգումենտները որպես վերջին հեշ պարամետր փոխանցելը և վերջին արգումենտը դիրքային և հիմնաբառի պարամետրերի բաժանելը:
def foo (բանալի՝ 42); վերջ; foo({key: 42}) #warned
def foo (**kw); վերջ; foo({key: 42}) #warned
def foo (բանալի՝ 42); վերջ; foo(**{բանալի` 42}) # Լավ
def foo (**kw); վերջ; foo(**{բանալի` 42}) # Լավdef foo (h, ** kw); վերջ; foo(բանալի՝ 42) #նախազգուշացրել
def foo (h, բանալին՝ 42); վերջ; foo(բանալի՝ 42) #նախազգուշացրել
def foo (h, ** kw); վերջ; foo ({key: 42}) # Լավ
def foo (h, բանալին՝ 42); վերջ; foo ({key: 42}) # Լավdef foo(h={}, բանալի՝ 42); վերջ; foo("key" => 43, key: 42) #warned
def foo(h={}, բանալի՝ 42); վերջ; foo({"key" => 43, key: 42}) # warned
def foo(h={}, բանալի՝ 42); վերջ; foo({"key" => 43}, key: 42) # OKdef foo(opt={}); վերջ; foo( բանալի՝ 42 ) # OK
def foo(h, **nil); վերջ; foo (բանալի՝ 1) # ԱրգումենտՍխալ
def foo(h, **nil); վերջ; foo(**{բանալի՝ 1}) # ԱրգումենտՍխալ
def foo(h, **nil); վերջ; foo ("str" => 1) # Փաստարկ Սխալ
def foo(h, **nil); վերջ; foo({key: 1}) # Լավ
def foo(h, **nil); վերջ; foo ({"str" => 1}) # Լավh = {}; def foo(*a) end; foo(**h) # [] h = {}; def foo(a) end; foo(**h) # {} և զգուշացում
h = {}; def foo(*a) end; foo(h) # [{}] h = {}; def foo(a) end; foo(h) # {} - օգտագործելով համարակալված լռելյայն փոփոխականների անունները բլոկի պարամետրերի համար:
[1, 2, 3]. յուրաքանչյուրը { դնում է @1 } # նման [1, 2, 3]. յուրաքանչյուրը { |i| դնում է }
- Փորձարարական աջակցություն սկզբնական արժեք չունեցող տիրույթների համար:
ary[..3] # նույնը, ինչ ary[0..3] rel.where (վաճառք՝ ..100)
- Ավելացվեց Enumerable#tally մեթոդը, որը հաշվում է, թե քանի անգամ է տեղի ունենում յուրաքանչյուր տարր:
["a", "b", "c", "b"].tally
#=> {"a"=>1, "b"=>2, "c"=>1} - Մասնավոր մեթոդով զանգը թույլատրվում է «ես» բառացի
deffoo
վերջ
մասնավոր :foo
self.foo - Ավելացվեց Enumerator::Lazy#eager մեթոդ՝ ծույլ (Enumerator::Lazy) թվարկումից կանոնավոր թվարկում առաջացնելու համար:
a = %w(foo bar baz)
e = a.lazy.map {|x| x.upcase }.քարտեզ {|x| x + "!" }.համարձակ
p e.class #=> Հաշվիչ
e.քարտեզ {|x| x + "?" } #=> [«FOO!», «BAR!?», «BAZ!»] - Շարունակվել է փորձարարական JIT կոմպիլյատորի մշակումը, որը կարող է զգալիորեն բարելավել Ruby լեզվով հավելվածների աշխատանքը։ Ruby-ում առաջարկվող JIT կոմպիլյատորը նախ գրում է C կոդը սկավառակի վրա, որից հետո կանչում է արտաքին C կոմպիլյատոր՝ մեքենայի հրահանգներ ստեղծելու համար (աջակցվում են GCC, Clang և Microsoft VC ++): Նոր տարբերակում ներդրվում է անհրաժեշտության դեպքում ներկառուցված տեղակայման մեթոդ, կոմպիլյացիայի ժամանակ օպտիմալացման ռեժիմների ընտրովի կիրառում, «--jit-min-call»-ի լռելյայն արժեքը 5-ից 10000-ի է հասցվում, իսկ «--jit-max-cache»-ը: 1000-ից մինչև 100.
- CGI.escapeHTML-ի, Monitor-ի և MonitorMixin-ի բարելավված կատարումը:
- Module#name, true.to_s, false.to_s և nil.to_s ապահովում են, որ տողը վերադարձվի, որն անփոփոխ է նշված օբյեկտի համար:
- RubyVM::InstructionSequence#to_binary մեթոդով ստեղծված երկուական ֆայլերի չափը կրճատվել է;
- Ներկառուցված բաղադրիչների թարմացված տարբերակները, ներառյալ
Bundler 2.1.2, RubyGems 3.1.2,
Racc 1.4.15,
CSV 3.1.2, REXML 3.2.3,
RSS 0.2.8,
Լարային սկաներ 1.0.3; - Գրադարանները բազային բաշխումից տեղափոխվեցին արտաքին թանկարժեք փաթեթներ
CMath (cmath գոհար),
Scanf (scanf Gem),
Կեղև (կեղևային գոհար),
Սինքրոնիզատոր (համաժամեցված գոհար),
ThreadsՍպասեք (thwait gem),
E2MM (e2mmap գոհար): - Նախնական stdlib մոդուլները հրապարակված են rubygems.org կայքում.
ելակետային,
cgi,
պատվիրակ
երկարանալ,
զուտ փոփ,
զուտ smtp,
բաց 3,
pstore,
սինգլտոն. Մոնիտորի մոդուլները չեն տեղափոխվել rubygems.org
դիտորդ,
ընդմիջում,
հետագծող,
ուրի,
yaml, որոնք առաքվում են միայն ruby-core-ով: - Ruby-ի կառուցման համար այժմ պահանջվում է C կոմպիլյատոր, որն աջակցում է C99 ստանդարտին:
Source: opennet.ru