Dopo un anno di sviluppo rilasciare , un linguaggio di programmazione dinamico e orientato agli oggetti che è altamente efficiente nello sviluppo di programmi e incorpora le migliori funzionalità di Perl, Java, Python, Smalltalk, Eiffel, Ada e Lisp. Il codice del progetto è distribuito sotto le licenze BSD ("BSDL a 2 clausole") e "Ruby", che si riferisce all'ultima versione della licenza GPL ed è completamente compatibile con GPLv3. Ruby 2.7 è la settima major release a seguito di un processo di sviluppo pianificato che impiega un anno per preparare miglioramenti funzionali e produce rilasci di manutenzione ogni 2-3 mesi.
Il principale :
- Sperimentale corrispondenza del modello () per scorrere l'oggetto specificato e assegnare un valore se esiste una corrispondenza del modello.
case [0, [1, 2, 3]] in [a, [b, *c]] pa #=> 0
pb #=> 1
pc #=> [2, 3] finecaso {a: 0, b: 1}
tra{a:0,x:1}
:non disponibile
in {a: 0, b: var}
pvar #=> 1
fine - La shell di calcoli interattivi irb (REPL, Read-Eval-Print-Loop) ora ha la possibilità di editing multilinea, implementato utilizzando una libreria compatibile con readline scritto in rubino. È stato integrato il supporto per rdoc, che consente di visualizzare informazioni di riferimento su classi, moduli e metodi specifici in irb. Viene fornita l'evidenziazione colorata delle linee con il codice mostrato tramite Binding#irb e i risultati dell'ispezione degli oggetti della classe base.
- Aggiunto un garbage collector compatto (Compaction GC) che può deframmentare una regione di memoria, risolvendo i problemi di prestazioni e consumo di memoria causati dalla frammentazione della memoria che si verifica in alcune applicazioni Ruby multi-thread. Per comprimere gli oggetti nell'heap Metodo GC.compact, che consente di ridurre il numero di pagine di memoria utilizzate e ottimizzare l'heap per le operazioni
CoW (copia su scrittura). - prepararsi a separare gli argomenti 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 è stata deprecata e non sarà supportata nel ramo Ruby 3.0. In particolare, è stato deprecato l'utilizzo dell'ultimo argomento come parametro di parola chiave, il passaggio di argomenti basati su parola chiave come ultimo parametro hash e la suddivisione dell'ultimo argomento in parametri posizionali e di parola chiave.
def foo(tasto: 42); FINE; foo({key: 42}) # avvisato
def foo(**kw); FINE; foo({key: 42}) #avvertito
def foo(tasto: 42); FINE; foo(**{tasto: 42}) # OK
def foo(**kw); FINE; foo(**{tasto: 42}) # OKdef foo(h, **kw); FINE; foo(tasto: 42) # avvisato
def foo(h, chiave: 42); FINE; foo(tasto: 42) # avvisato
def foo(h, **kw); FINE; foo({tasto: 42}) # OK
def foo(h, chiave: 42); FINE; foo({tasto: 42}) # OKdef foo(h={}, chiave: 42); FINE; foo("chiave" => 43, chiave: 42) #avvertito
def foo(h={}, chiave: 42); FINE; foo({"chiave" => 43, chiave: 42}) # avvisato
def foo(h={}, chiave: 42); FINE; foo({"chiave" => 43}, chiave: 42) # OKdef foo(opt={}); FINE; foo( tasto: 42 ) # OK
def foo(h, **nil); FINE; foo(chiave: 1) # ErroreArgomento
def foo(h, **nil); FINE; foo(**{chiave: 1}) # ErroreArgomento
def foo(h, **nil); FINE; foo("str" => 1) #ArgumentError
def foo(h, **nil); FINE; foo({chiave: 1}) # OK
def foo(h, **nil); FINE; foo({"str" => 1}) # OKh = {}; def foo(*a) una fine; foo(**h) # [] h = {}; def foo(a) una fine; foo(**h) # {} e avviso
h = {}; def foo(*a) fine; foo(h) # [{}] h = {}; def foo(a) fine; pippo(h) # {} - utilizzando nomi di variabili numerate per impostazione predefinita per i parametri del blocco.
[1, 2, 3].each { mette @1 } # come [1, 2, 3].each { |i| mette i }
- Supporto sperimentale per intervalli senza valore iniziale.
ary[..3] # uguale a ary[0..3] rel.where(vendite: ..100)
- Aggiunto il metodo Enumerable#tally, che conta il numero di volte in cui si verifica ciascun elemento.
["a", "b", "c", "b"].
#=> {“a”=>1, “b”=>2, “c”=>1} - È consentito chiamare un metodo privato con il "self" letterale
deffoo
fine
privato:foo
self.foo - Aggiunto il metodo Enumerator::Lazy#eager per generare un'enumerazione regolare dall'enumerazione lazy (Enumerator::Lazy).
a = %w(foo bar baz)
e = a.lazy.map {|x| x.upcase }.map {|x| x + "!" }.desideroso
p e.class #=> Enumeratore
p e.mappa {|x| x + "?" } #=> [“FOO!?”, “BAR!?”, “BAZ!?”] - È proseguito lo sviluppo di un compilatore JIT sperimentale in grado di migliorare significativamente le prestazioni delle applicazioni in linguaggio Ruby. Il compilatore JIT proposto in Ruby scrive prima il codice C su disco, dopodiché chiama un compilatore C esterno per generare istruzioni macchina (sono supportati GCC, Clang e Microsoft VC++). La nuova versione implementa un metodo per la distribuzione in linea se necessario, applicazione selettiva delle modalità di ottimizzazione durante la compilazione, il valore predefinito di "--jit-min-calls" è aumentato da 5 a 10000 e "--jit-max-cache" da 1000 a 100.
- Prestazioni migliorate di CGI.escapeHTML, Monitor e MonitorMixin.
- Module#name, true.to_s, false.to_s e nil.to_s assicurano che venga restituita una stringa invariata per l'oggetto specificato.
- La dimensione dei file binari generati dal metodo RubyVM::InstructionSequence#to_binary; è stata ridotta.
- Versioni aggiornate dei componenti integrati, inclusi
Bundler 2.1.2, RubyGems 3.1.2,
Raccolta 1.4.15,
CSV 3.1.2, REXML 3.2.3,
RSS0.2.8,
StringScanner 1.0.3; - Le librerie sono passate dalla distribuzione di base ai pacchetti gem esterni
CMath (gemma cmath),
Scanf (gemma scanf),
Conchiglia (gemma di conchiglia),
Sincronizzatore (gemma di sincronizzazione),
ThreadsWait (quella gemma),
E2MM (gemma e2mmap). - I moduli stdlib predefiniti sono pubblicati su rubygems.org:
prova delle prestazioni,
computer,
delegare,
getoptlong,
net-pop,
net-smtp
aperto3,
negozio,
singleton. Moduli di monitoraggio non spostati su rubygems.org
osservatore,
tempo scaduto,
tracciante,
odiare,
yaml, che sono forniti solo in ruby-core. - La creazione di Ruby ora richiede un compilatore C che supporti lo standard C99.
Fonte: opennet.ru