Nei in jier fan ûntwikkeling frijlitte , in dynamyske objekt-rjochte programmeartaal dy't tige effisjint is yn programma-ûntwikkeling en omfettet de bêste funksjes fan Perl, Java, Python, Smalltalk, Eiffel, Ada en Lisp. De projektkoade wurdt ferspraat ûnder de BSD ("2-klausule BSDL") en "Ruby" lisinsjes, dy't ferwiist nei de lêste ferzje fan 'e GPL-lisinsje en is folslein kompatibel mei GPLv3. Ruby 2.7 is de sânde grutte release dy't wurdt produsearre as ûnderdiel fan in pland ûntwikkelingsproses dat omfettet it ynstellen fan in jier foar funksjeferbetterings en in 2-3 moanne patch release.
haad :
- eksperiminteel patroan oerienkommende () om it opjûne objekt te iterearjen en in wearde ta te jaan as d'r in patroanmatch is.
gefal [0, [1, 2, 3]] yn [a, [b, *c]] pa #=> 0
pb #=> 1
pc #=> [2, 3] eingefal {a: 0, b: 1}
yn {a:0,x:1}
: ûnberikber
yn {a: 0, b: var}
p var #=> 1
ein - De shell fan ynteraktive berekkeningen irb (REPL, Read-Eval-Print-Loop) hat no de mooglikheid fan multi-line bewurkjen, ymplementearre mei in readline-kompatible bibleteek skreaun yn Ruby. Stipe foar rdoc is yntegreare, wêrtroch referinsjeynformaasje oer oantsjutte klassen, modules en metoaden yn irb kin wurde besjen. Kleurde markearring fan rigels mei koade werjûn fia Binding#irb en resultaten fan ynspeksje fan basisklasseobjekten wurdt foarsjoen.
- Tafoege in kompakte garbage collector (Compaction GC) dat kin defragmentearje in regio fan ûnthâld, oplosse de problemen fan trage prestaasjes en ferhege ûnthâld konsumpsje fanwege ûnthâld fragmintaasje dy't optreedt tidens de wurking fan guon multi-threaded Ruby applikaasjes. Om objekten op 'e heap te pakken GC.compact metoade te ferminderjen it oantal ûnthâld siden brûkt en optimalisearjen fan de heap foar operaasjes
CoW (copy-on-write). - tariede op it skieden fan arguminten basearre op posysje yn 'e list ("def foo(a,b,c)") en kaaiwurden ("def foo(key: val)"). Automatyske argumintkonverzje basearre op kaaiwurden en posysje is ôfkard en sil net wurde stipe yn 'e Ruby 3.0-tûke. Benammen it is ôfkard om it lêste argumint te brûken as kaaiwurdparameters, om op kaaiwurden basearre arguminten troch te jaan as de lêste hashparameter, en it lêste argumint te splitsen yn posisjonele en kaaiwurdparameters.
def foo (kaai: 42); ein; foo({kaai: 42}) #warskôge
def foo(**kw); ein; foo({kaai: 42}) #warskôge
def foo (kaai: 42); ein; foo(**{key: 42}) # OK
def foo(**kw); ein; foo(**{key: 42}) # OKdef foo(h, **kw); ein; foo (kaai: 42) #warskôge
def foo(h, kaai: 42); ein; foo (kaai: 42) #warskôge
def foo(h, **kw); ein; foo({key: 42}) # OK
def foo(h, kaai: 42); ein; foo({key: 42}) # OKdef foo(h={}, key: 42); ein; foo("key" => 43, key: 42) #warned
def foo(h={}, key: 42); ein; foo({"key" => 43, key: 42}) # warskôge
def foo(h={}, key: 42); ein; foo({"key" => 43}, key: 42) # OKdef foo(opt={}); ein; foo (kaai: 42) # OK
def foo(h, **nul); ein; foo (kaai: 1) # ArgumentError
def foo(h, **nul); ein; foo(**{key: 1}) # ArgumentError
def foo(h, **nul); ein; foo("str"=> 1) # ArgumentError
def foo(h, **nul); ein; foo({key: 1}) # OK
def foo(h, **nul); ein; foo({"str"=> 1}) # OKh = {}; def foo(*a) ein; foo(**h) # [] h = {}; def foo(a) ein; foo(**h) # {} en warskôging
h = {}; def foo(*a) ein; foo(h) # [{}] h = {}; def foo(a) ein; foo(h) # {} - mei help fan nûmere standert fariabele nammen foar blok parameters.
[1, 2, 3].each { set @1 } # like [1, 2, 3].each { |i| set ik}
- Eksperimintele stipe foar berik mei gjin begjinwearde.
ary[..3] # itselde as ary[0..3] rel.where(ferkeap: ..100)
- De Enumerable#tally-metoade tafoege, dy't telt hoefolle kearen elk elemint foarkomt.
["a", "b", "c", "b"].tally
#=> {"a"=>1, "b"=>2, "c"=>1} - Private metoade oprop tastien mei "sels" letterlik
deffoo
ein
privee: foo
self.foo - Enumerator tafoege :: Lazy#eager metoade om reguliere enumeraasje te generearjen fan loai (Enumerator :: Lazy) enumeration.
a = %w(foo bar baz)
e = a.lazy.map {|x| x.upcase }.map {|x| x + "!" }.eager
p e.class #=> Enumerator
e.map {|x| x + "?" } #=> ["FOO!?", "BAR!?", "BAZ!?"] - De ûntwikkeling fan in eksperimintele JIT-kompiler is trochgien, wat de prestaasjes fan applikaasjes yn 'e Ruby-taal signifikant kin ferbetterje. De JIT-kompilator foarsteld yn Ruby skriuwt earst C-koade op skiif, wêrnei't it in eksterne C-kompiler ropt om masineynstruksjes te generearjen (GCC, Clang en Microsoft VC ++ wurde stipe). De nije ferzje ymplementearret in metoade foar ynline ynset as it nedich is, selektive tapassing fan optimisaasjemodi tidens kompilaasje, de standertwearde fan "--jit-min-calls" wurdt ferhege fan 5 nei 10000, en "--jit-max-cache" fan 1000 oant 100.
- Ferbettere prestaasjes fan CGI.escapeHTML, Monitor en MonitorMixin.
- Module#name, true.to_s, false.to_s, en nil.to_s soargje derfoar dat in tekenrige wurdt weromjûn dy't net feroare is foar it opjûne objekt.
- De grutte fan binêre triemmen oanmakke troch de RubyVM :: InstructionSequence#to_binary metoade is fermindere;
- Bywurke ferzjes fan ynboude komponinten, ynklusyf
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; - Bibleteken ferhuze fan basisdistribúsje nei eksterne gem pakketten
CMath (cmath gem),
Scanf (scanf gem),
Shell (shell gem)
Synchronizer (syngronisaasje gem),
ThreadsWait (thwait gem),
E2MM (e2mmap gem). - De standert stdlib-modules wurde publisearre op rubygems.org:
benchmark,
cgi,
ôffurdige,
getoptlong,
net pop,
net smtp,
iepen 3,
pstore,
singleton. Monitor modules net ferpleatst nei rubygems.org
waarnimmer,
skoft,
tracer
uri,
yaml, dy't allinnich wurde ferstjoerd mei ruby-core. - Ruby bouwen fereasket no in C-kompiler dy't de C99-standert stipet.
Boarne: opennet.ru