Dopo un anno di sviluppo rilascio , un linguaggio di programmazione orientato agli oggetti dinamico, caratterizzato da un'elevata efficienza nello sviluppo di software e che incorpora le migliori caratteristiche di Perl, Java, Python, Smalltalk, Eiffel, Ada e Lisp. Il codice del progetto è distribuito sotto licenze BSD ("2-clause BSDL") e "Ruby", che fa riferimento all'ultima versione della licenza GPL ed è completamente compatibile con GPLv3. Ruby 2.7 è il settimo rilascio significativo, preparato nel contesto di un processo di sviluppo pianificato che prevede un anno per la preparazione di miglioramenti funzionali e rilasci correttivi ogni 2-3 mesi.
Principali :
- Sperimentale corrispondenze con il campione (), che consente di esaminare un oggetto specificato e di assegnare un valore in caso di corrispondenza con il campione.
case [0, [1, 2, 3]]
in [a, [b, *c]]
p a #=> 0
p b #=> 1
p c #=> [2, 3]
endcase {a: 0, b: 1}
in {a: 0, x: 1}
:unreachable
in {a: 0, b: var}
p var #=> 1
end - Nell'ambiente di calcolo interattivo irb (REPL, Read-Eval-Print-Loop) è stata aggiunta la possibilità di modifica su più righe, implementata tramite una libreria compatibile con readline , scritta in Ruby. È integrato il supporto per rdoc, che consente di visualizzare in irb la documentazione relativa a classi, moduli e metodi specificati. È garantita la colorazione del codice delle stringhe, visualizzate tramite Binding#irb e dei risultati dell'ispezione degli oggetti delle classi di base.
- È stato aggiunto un garbage collector di compressione (Compaction GC), che può eseguire la deframmentazione dell'area di memoria, risolvendo problemi di riduzione delle prestazioni e aumento del consumo di memoria dovuti alla frammentazione della memoria, che si verifica durante l'esecuzione di alcune applicazioni Ruby multithread. Per impacchettare gli oggetti nello heap il metodo GC.compact, che consente di ridurre il numero di pagine di memoria utilizzate e ottimizzare lo heap per le operazioni
CoW (copy-on-write). - preparazione alla separazione degli argomenti, definiti in base alla posizione nell'elenco («def foo(a,b,c)») e alle parole chiave («def foo(key: val)»). La conversione automatica degli argomenti basata su parole chiave e posizione è dichiarata obsoleta e non sarà supportata nella versione Ruby 3.0. In particolare, è dichiarato obsoleto l'uso dell'ultimo argomento come parametri di parola chiave, il passaggio di argomenti basati su parole chiave come ultimo parametro di hash e la separazione dell'ultimo argomento in parametri posizionali e di parola chiave.
def foo(key: 42); end; foo({key: 42}) # avviso
def foo(**kw); end; foo({key: 42}) # avviso
def foo(key: 42); end; foo(**{key: 42}) # OK
def foo(**kw); end; foo(**{key: 42}) # OKdef foo(h, **kw); end; foo(key: 42) # avviso
def foo(h, key: 42); end; foo(key: 42) # avviso
def foo(h, **kw); end; foo({key: 42}) # OK
def foo(h, key: 42); end; foo({key: 42}) # OKdef foo(h={}, key: 42); end; foo(«key» => 43, key: 42) # avviso
def foo(h={}, key: 42); end; foo({«key» => 43, key: 42}) # avviso
def foo(h={}, key: 42); end; foo({«key» => 43}, key: 42) # OKdef foo(opt={}); end; foo( key: 42 ) # OK
def foo(h, **nil); end; foo(key: 1) # ArgumentError
def foo(h, **nil); end; foo(**{key: 1}) # ArgumentError
def foo(h, **nil); end; foo(«str» => 1) # ArgumentError
def foo(h, **nil); end; foo({key: 1}) # OK
def foo(h, **nil); end; foo({«str» => 1}) # OKh = {}; def foo(*a) a end; foo(**h) # []
h = {}; def foo(a) a end; foo(**h) # {} e avviso
h = {}; def foo(*a) a end; foo(h) # [{}]
h = {}; def foo(a) a end; foo(h) # {} - utilizzo di nomi variabili numerati per impostazione predefinita per i parametri del blocco.
[1, 2, 3].each { puts @1 } # come equivalente a [1, 2, 3].each { |i| puts i }
- Supporto sperimentale per gli intervalli senza valore iniziale.
ary[..3] # equivalente a ary[0..3]
rel.where(sales: ..100) - Aggiunto il metodo Enumerable#tally, che conta quante volte appare ogni elemento.
[«a», «b», «c», «b»].tally
#=> {«a»=>1, «b»=>2, «c»=>1} - Consentito il richiamo di un metodo privato con il letterale «self»
def foo
end
private :foo
self.foo - Aggiunto il metodo Enumerator::Lazy#eager per generare un enumerazione normale da un enumerazione «pigra» (Enumerator::Lazy).
a = %w(foo bar baz)
e = a.lazy.map {|x| x.upcase }.map {|x| x + «!» }.eager
p e.class #=> Enumerator
p e.map {|x| x + «?» } #=> [«FOO!?», «BAR!?», «BAZ!?»] - È proseguito lo sviluppo del compilatore JIT sperimentale, che consente un notevole aumento delle prestazioni delle applicazioni scritte in Ruby. Il compilatore JIT proposto in Ruby inizialmente scrive il codice in C su disco e poi chiama un compilatore C esterno per generare istruzioni macchina (è supportata la chiamata a GCC, Clang e Microsoft VC++). Nella nuova versione è stato implementato un metodo per il deployment inline quando necessario, assicurando un'applicazione selettiva dei modi di ottimizzazione durante la compilazione, il valore predefinito di "—jit-min-calls" è stato aumentato da 5 a 10000, e "—jit-max-cache" da 1000 a 100.
- È stata migliorata la performance di CGI.escapeHTML, Monitor e MonitorMixin.
- In Module#name, true.to_s, false.to_s e nil.to_s è garantito il ritorno di una stringa invariata per l'oggetto specificato.
- Ridotto il dimensionamento dei file binari generati dal metodo RubyVM::InstructionSequence#to_binary;
- Aggiornate le versioni dei componenti integrati, comprese
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; - Dalla fornitura di base sono stati estratti in pacchetti gem esterni le librerie
CMath (gem cmath),
Scanf (gem scanf),
Shell (gem shell),
Synchronizer (gem sync),
ThreadsWait (gem thwait),
E2MM (gem e2mmap). - Pubblicati su rubygems.org i moduli stdlib forniti per impostazione predefinita:
benchmark,
cgi,
delegate,
getoptlong,
net-pop,
net-smtp,
open3,
pstore,
singleton. Non trasferiti a rubygems.org i moduli monitor
observer,
timeout,
tracer,
uri,
yaml, che sono forniti solo in ruby-core. - Per compilare Ruby ora è necessario un compilatore C compatibile con lo standard C99.
Fonte: opennet.ru
