වසරක සංවර්ධනයෙන් පසු නිකුත්වීම , ගතික වස්තු-නැඹුරු ක්‍රමලේඛන භාෂාවක් වන අතර එය ක්‍රමලේඛ සංවර්ධනයේදී ඉතා කාර්යක්ෂම වන අතර Perl, Java, Python, Smalltalk, Eiffel, Ada සහ Lisp හි හොඳම විශේෂාංග ඇතුළත් වේ. ව්‍යාපෘති කේතය BSD ("2- වගන්ති 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) කවචයට දැන් බහු-රේඛා සංස්කරණය කිරීමේ හැකියාව ඇත, එය කියවීමට අනුකූල පුස්තකාලයක් භාවිතයෙන් ක්‍රියාත්මක වේ. Ruby වලින් ලියා ඇත. rdoc සඳහා සහය ඒකාබද්ධ කර ඇත, එය irb හි නිශ්චිත පන්ති, මොඩියුල සහ ක්‍රම පිළිබඳ විමර්ශන තොරතුරු බැලීමට ඉඩ සලසයි. Binding#irb හරහා පෙන්වන කේතය සහිත රේඛා වර්ණවත් උද්දීපනය සහ මූලික පන්තියේ වස්තු පරීක්ෂා කිරීමේ ප්‍රතිඵල සපයා ඇත.
- සමහර බහු-නූල් රූබි යෙදුම්වල ක්‍රියාකාරීත්වයේදී සිදුවන මතක ඛණ්ඩනය හේතුවෙන් මතකය ඛණ්ඩනය වීම නිසා මතක පරිභෝජනය වැඩි කිරීම, මන්දගාමී ක්‍රියාකාරිත්වයේ ගැටළු විසඳීම සහ මතකයේ කලාපයක් defragment කළ හැකි සංයුක්ත කුණු එකතු කරන්නෙකු (Compaction GC) එක් කරන ලදී. ගොඩ මත වස්තු ඇසුරුම් කිරීමට භාවිතා කරන මතක පිටු ගණන අඩු කිරීමට සහ මෙහෙයුම් සඳහා ගොඩ ප්‍රශස්ත කිරීමට GC.compact ක්‍රමය
CW (පිටපත-මත-ලියන්න). - ලැයිස්තුවේ පිහිටීම ("def foo(a,b,c)") සහ මූල පද ("def foo(key: val)") මත පදනම්ව තර්ක වෙන් කිරීමට සූදානම් වීම. මූල පද සහ ස්ථානය මත පදනම්ව ස්වයංක්‍රීය තර්ක පරිවර්තනය අත්හරින ලද අතර Ruby 3.0 ශාඛාව තුළ සහාය නොදක්වයි. විශේෂයෙන්ම, අවසාන තර්කය Keyword parameters ලෙස භාවිතා කිරීම, Keyword-based arguments අවසාන hash පරාමිතිය ලෙස සම්මත කිරීම සහ අවසාන තර්කය positional සහ keyword parameters ලෙස බෙදීම අත්හරින ලදී.
def foo (යතුර: 42); අවසානය; foo({key: 42}) #අවවාදයයි
def foo (**kw); අවසානය; foo({key: 42}) #අවවාදයයි
def foo (යතුර: 42); අවසානය; foo(**{යතුර: 42}) # හරි
def foo (**kw); අවසානය; foo(**{යතුර: 42}) # හරිdef foo (h, **kw); අවසානය; foo(යතුර: 42) #අවවාදයයි
def foo(h, key: 42); අවසානය; foo(යතුර: 42) #අවවාදයයි
def foo (h, **kw); අවසානය; foo({යතුර: 42}) # හරි
def foo(h, key: 42); අවසානය; foo({යතුර: 42}) # හරිdef foo(h={}, යතුර: 42); අවසානය; foo("යතුර" => 43, යතුර: 42) #අවවාදයයි
def foo(h={}, යතුර: 42); අවසානය; foo({"key" => 43, key: 42}) # අවවාද කළා
def foo(h={}, යතුර: 42); අවසානය; foo({"key" => 43}, key: 42) # හරිdef foo(opt={}); අවසානය; foo(යතුර: 42) # හරි
def foo(h, **nil); අවසානය; foo(යතුර: 1) # තර්ක දෝෂය
def foo(h, **nil); අවසානය; foo(**{key: 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} - "ස්වයං" වචනාර්ථයෙන් පුද්ගලික ක්‍රම ඇමතුමට අවසර ඇත
ඩෙෆූ
අවසානය
පුද්ගලික :foo
self.foo - කම්මැලි (ගණන් කරන්නා:: කම්මැලි) ගණන් බැලීමෙන් නිතිපතා ගණනය කිරීම සඳහා ගණන් කරන්නා:: කම්මැලි# උනන්දුව දක්වන ක්‍රමය එකතු කරන ලදී.
a = %w(foo bar baz)
e = a.lazy.map {|x| x.upcase }.සිතියම {|x| x + "!" }.ආසාවෙන්
p e.class #=> ගණන් කරන්නා
e.map {|x| x + "?" } #=> [“FOO!?”, “BAR!?”, “BAZ!?”] - පර්යේෂණාත්මක JIT සම්පාදකයක් සංවර්ධනය කිරීම අඛණ්ඩව සිදු වී ඇති අතර එමඟින් Ruby භාෂාවේ යෙදුම්වල ක්‍රියාකාරිත්වය සැලකිය යුතු ලෙස වැඩිදියුණු කළ හැකිය. Ruby හි යෝජනා කර ඇති JIT සම්පාදකය පළමුව තැටියට C කේතය ලියයි, ඉන් පසුව එය යන්ත්‍ර උපදෙස් ජනනය කිරීමට බාහිර C සම්පාදකයක් අමතයි (GCC, Clang සහ Microsoft VC ++ සහාය දක්වයි). නව අනුවාදය අවශ්‍ය නම් පේළිගත යෙදවීම සඳහා ක්‍රමයක් ක්‍රියාත්මක කරයි, සම්පාදනය කිරීමේදී ප්‍රශස්තිකරණ ක්‍රම තෝරා ගැනීම, "--jit-min-ඇමතුම්" හි පෙරනිමි අගය 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,
String Scanner 1.0.3; - පුස්තකාල මූලික බෙදාහැරීමේ සිට බාහිර මැණික් පැකේජ වෙත මාරු විය
CMath (cmath මැණික්),
ස්කෑන්ෆ් (ස්කෑන්ෆ් මැණික්),
ෂෙල් (ෂෙල් මැණික්),
සමමුහුර්තකරණය (සමමුහුර්ත මැණික්),
නූල් Wait (thwait මැණික්),
E2MM (e2mmap මැණික්). - පෙරනිමි stdlib මොඩියුල rubygems.org හි ප්‍රකාශයට පත් කෙරේ:
මිණුම් සලකුණ,
cgi,
නියෝජිත,
getoptlong,
නෙට් පොප්,
net smtp,
විවෘත 3,
ගබඩා,
සිංගල්ටන්. මොනිටර් මොඩියුල rubygems.org වෙත ගෙන ගොස් නැත
නිරීක්ෂකයා,
කාලය හමාරයි,
ට්රේසර්,
උරි,
yaml, ruby-core සමඟ පමණක් යවනු ලැබේ. - Ruby ගොඩනැගීමට දැන් C99 ප්‍රමිතියට සහය දක්වන C සම්පාදකයක් අවශ්‍ය වේ.
මූලාශ්රය: opennet.ru