Egy év fejlesztés után kiadás , egy dinamikus objektum-orientált programozási nyelv, amely rendkívül hatékony a programfejlesztésben, és magában foglalja a Perl, Java, Python, Smalltalk, Eiffel, Ada és Lisp legjobb tulajdonságait. A projektkód a BSD ("2-clause BSDL") és a "Ruby" licencek alatt kerül terjesztésre, amelyek a GPL licenc legújabb verziójára utalnak, és teljes mértékben kompatibilisek a GPLv3-mal. A Ruby 2.7 a hetedik nagyobb kiadás, amely egy tervezett fejlesztési folyamat részeként készül, amely magában foglalja egy év elkülönítését a funkciók fejlesztésére és egy 2-3 hónapos patch kiadást.
A főbb :
- kísérleti minta illesztés ().
eset [0, [1, 2, 3]] in [a, [b, *c]] pa #=> 0
pb #=> 1
pc #=> [2, 3] végeeset {a: 0, b: 1}
in{a:0,x:1}
:elérhetetlen
in {a: 0, b: var}
p var #=> 1
végén - Az interaktív számítások irb (REPL, Read-Eval-Print-Loop) shellje immár többsoros szerkesztési lehetőséget is kínál, amelyet readline-kompatibilis könyvtár segítségével valósítanak meg Rubinnal írva. Az rdoc támogatása integrálva van, ami lehetővé teszi a referencia információk megtekintését a megadott osztályokról, modulokról és metódusokról az irb-ben. A sorok színes kiemelése a Binding#irb-n keresztül megjelenített kóddal és az alaposztályú objektumok vizsgálatának eredményei.
- Hozzáadott egy kompakt szemétgyűjtőt (Compaction GC), amely képes töredezettségmentesíteni a memória egy részét, megoldva a lassú teljesítmény és a megnövekedett memóriafelhasználás problémáit a memória töredezettsége miatt, amely egyes többszálas Ruby alkalmazások működése során jelentkezik. Tárgyak csomagolására a kupacra GC.compact módszer a felhasznált memóriaoldalak számának csökkentésére és a kupac optimalizálására a műveletekhez
CoW (másolás-írás). - felkészülés az argumentumok szétválasztására a listában elfoglalt pozíció ("def foo(a,b,c)") és a kulcsszavak ("def foo(key: val)" alapján). A kulcsszavakon és pozíción alapuló automatikus argumentumkonverzió elavult, és a Ruby 3.0 ág nem támogatja. Különösen az utolsó argumentum kulcsszóparaméterként való használata, a kulcsszóalapú argumentumok utolsó hash-paraméterként való átadása, valamint az utolsó argumentum pozíció- és kulcsszóparaméterekre való felosztása elavulttá vált.
def foo(kulcs: 42); vége; foo({kulcs: 42}) #warned
def foo(**kw); vége; foo({kulcs: 42}) #warned
def foo(kulcs: 42); vége; foo(**{kulcs: 42}) # OK
def foo(**kw); vége; foo(**{kulcs: 42}) # OKdef foo(h, **kw); vége; foo(kulcs: 42) #warned
def foo(h, kulcs: 42); vége; foo(kulcs: 42) #warned
def foo(h, **kw); vége; foo({kulcs: 42}) # OK
def foo(h, kulcs: 42); vége; foo({kulcs: 42}) # OKdef foo(h={}, kulcs: 42); vége; foo("kulcs" => 43, kulcs: 42) #warned
def foo(h={}, kulcs: 42); vége; foo({"kulcs" => 43, kulcs: 42}) # figyelmeztetve
def foo(h={}, kulcs: 42); vége; foo({"kulcs" => 43}, kulcs: 42) # OKdef foo(opt={}); vége; foo( kulcs: 42 ) # OK
def foo(h, **nil); vége; foo(kulcs: 1) # ArgumentError
def foo(h, **nil); vége; foo(**{kulcs: 1}) # ArgumentError
def foo(h, **nil); vége; foo("str" => 1) # ArgumentError
def foo(h, **nil); vége; foo({kulcs: 1}) # OK
def foo(h, **nil); vége; foo({"str" => 1}) # OKh = {}; def foo(*a) end; foo(**h) # [] h = {}; def foo(a) end; foo(**h) # {} és figyelmeztetés
h = {}; def foo(*a) end; foo(h) # [{}] h = {}; def foo(a) end; foo(h) # {} - számozott alapértelmezett változónevek használata blokkparaméterekhez.
[1, 2, 3].each { @1 } # like [1, 2, 3].each { |i| tesz én }
- Kísérleti támogatás a kezdeti érték nélküli tartományokhoz.
ary[..3] # ugyanaz, mint ary[0..3] rel.where(értékesítés: ..100)
- Hozzáadtuk az Enumerable#tally metódust, amely megszámolja, hogy az egyes elemek hányszor fordulnak elő.
["a", "b", "c", "b"].tally
#=> {"a"=>1, "b"=>2, "c"=>1} - Megengedett egy privát metódus meghívása a szó szerinti "én"-vel
def foo
végén
privát :foo
self.foo - Hozzáadott Enumerator::Lazy#buzgó módszer a lusta (Enumerator::Lazy) felsorolásból rendszeres felsorolás generálására.
a = %w(foo bar baz)
e = a.lusta.térkép {|x| x.upcase }.map {|x| x + "!" }.mohó
p e.class #=> Enumerator
e.map {|x| x + "?" } #=> ["FOO!?", "BÁR!?", "BAZ!?"] - Folytatódott egy kísérleti JIT fordító fejlesztése, amely jelentősen javíthatja a Ruby nyelvű alkalmazások teljesítményét. A Rubyban javasolt JIT fordító először C kódot ír a lemezre, majd hív egy külső C fordítót, hogy gépi utasításokat generáljon (a GCC, Clang és Microsoft VC ++ támogatott). Az új verzió szükség esetén beépített telepítési módszert valósít meg, az optimalizálási módok szelektív alkalmazását a fordítás során, a "--jit-min-calls" alapértelmezett értéke 5-ről 10000-re nő, és a "--jit-max-cache" 1000-től 100-ig.
- A CGI.escapeHTML, a Monitor és a MonitorMixin jobb teljesítménye.
- A modul#name, true.to_s, false.to_s és nil.to_s biztosítják, hogy a megadott objektumhoz változatlan karakterlánc kerüljön visszaadásra.
- A RubyVM::InstructionSequence#to_binary metódus által generált bináris fájlok mérete csökkent;
- A beépített komponensek frissített verziói, beleértve
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; - A könyvtárak az alapterjesztésről a külső drágakő csomagokba kerültek
CMath (cmath drágakő),
Scanf (scanf gem),
Shell (shell drágakő)
Szinkronizáló (sync gem),
ThreadsWait (thwait gem),
E2MM (e2mmap gem). - Az alapértelmezett stdlib modulok a rubygems.org webhelyen vannak közzétéve:
viszonyítási alap,
cgi,
küldött,
hosszúra nyúlik,
net pop,
net smtp,
nyitott 3,
pstore,
szingli. a monitormodulok nem kerültek át a rubygems.org oldalra
megfigyelő,
időtúllépés
nyomjelző,
gyűlöl,
yaml, amelyeket csak rubinmaggal szállítanak. - A Ruby felépítéséhez most olyan C fordítóra van szükség, amely támogatja a C99 szabványt.
Forrás: opennet.ru