Après un an de développement libération , un langage de programmation orienté objet dynamique qui est très efficace dans le développement de programmes et intègre les meilleures fonctionnalités de Perl, Java, Python, Smalltalk, Eiffel, Ada et Lisp. Le code du projet est distribué sous les licences BSD (« BSDL à 2 clauses ») et « Ruby », qui fait référence à la dernière version de la licence GPL et est entièrement compatible avec la GPLv3. Ruby 2.7 est la septième version majeure à être produite dans le cadre d'un processus de développement planifié qui comprend la mise de côté d'un an pour les améliorations de fonctionnalités et une version de correctif de 2 à 3 mois.
principal :
- Expérimental correspondance de modèle () pour itérer sur l'objet donné et attribuer une valeur s'il existe une correspondance de modèle.
cas [0, [1, 2, 3]] dans [a, [b, *c]] pa #=> 0
pb #=> 1
pc #=> [2, 3] fincas {a : 0, b : 1}
dans{a:0,x:1}
: inaccessible
dans {a : 0, b : var}
p var #=> 1
fin - Le shell de calculs interactifs irb (REPL, Read-Eval-Print-Loop) a désormais la possibilité d'édition multi-lignes, implémentée à l'aide d'une librairie compatible readline écrit en Ruby. La prise en charge de rdoc a été intégrée, ce qui permet de visualiser les informations de référence sur les classes, modules et méthodes spécifiés dans irb. La mise en surbrillance colorée des lignes avec le code affiché via Binding#irb et les résultats de l'inspection des objets de la classe de base est fournie.
- Ajout d'un ramasse-miettes compact (Compaction GC) qui peut effectuer la défragmentation d'une région de mémoire, résolvant les problèmes de ralentissement des performances et d'augmentation de la consommation de mémoire en raison de la fragmentation de la mémoire qui se produit lors du fonctionnement de certaines applications Ruby multithread. Pour emballer des objets sur le tas Méthode GC.compact pour réduire le nombre de pages mémoire utilisées et optimiser le tas pour les opérations
CoW (copie sur écriture). - préparer à séparer les arguments en fonction de la position dans la liste ("def foo(a,b,c)") et des mots-clés ("def foo(key: val)"). La conversion automatique des arguments basée sur les mots-clés et la position est obsolète et ne sera pas prise en charge dans la branche Ruby 3.0. En particulier, il est devenu obsolète d'utiliser le dernier argument comme paramètres de mot-clé, de passer des arguments basés sur des mots-clés comme dernier paramètre de hachage et de diviser le dernier argument en paramètres de position et de mot-clé.
def foo(clé : 42); fin; foo({clé : 42}) #warned
def foo(**kw); fin; foo({clé : 42}) #warned
def foo(clé : 42); fin; foo(**{touche : 42}) # OK
def foo(**kw); fin; foo(**{touche : 42}) # OKdef foo(h, **kw); fin; foo(clé : 42) #warned
def foo(h, clé : 42); fin; foo(clé : 42) #warned
def foo(h, **kw); fin; toto({clé : 42}) # OK
def foo(h, clé : 42); fin; foo({clé : 42}) # OKdef foo(h={}, clé : 42); fin; foo("key" => 43, key : 42) #warned
def foo(h={}, clé : 42); fin; foo({"key" => 43, key: 42}) # averti
def foo(h={}, clé : 42); fin; toto({"key" => 43}, key : 42) # OKdef foo(opt={}); fin; foo( touche : 42 ) # OK
def foo(h, **nil); fin; foo(clé : 1) # ArgumentError
def foo(h, **nil); fin; foo(**{key : 1}) # ArgumentError
def foo(h, **nil); fin; foo("str" => 1) # ArgumentError
def foo(h, **nil); fin; foo({clé : 1}) # OK
def foo(h, **nil); fin; foo({"str" => 1}) # OKh = {} ; def foo(*a) fin ; foo(**h) # [] h = {} ; def foo(a) fin ; foo(**h) # {} et avertissement
h = {} ; def foo(*a) fin ; toto(h) # [{}] h = {} ; def foo(a) fin ; foo(h) # {} - en utilisant des noms de variables numérotés par défaut pour les paramètres de bloc.
[1, 2, 3].each { met @1 } # comme [1, 2, 3].each { |i| met je }
- Prise en charge expérimentale des plages sans valeur initiale.
ary[..3] # identique à ary[0..3] rel.where(ventes : ..100)
- Ajout de la méthode Enumerable#tally qui compte le nombre de fois que chaque élément se produit.
["a", "b", "c", "b"].tally
#=> {"a"=>1, "b"=>2, "c"=>1} - Appel de méthode privée autorisé avec le littéral "self"
deffoo
fin
privé :foo
auto.foo - Ajout de la méthode Enumerator::Lazy#eager pour générer une énumération régulière à partir d'une énumération paresseuse (Enumerator::Lazy).
a = %w(foo bar baz)
e = a.lazy.map {|x| x.upcase }.map {|x| x + "!" }.désireux
p e.class #=> Enumérateur
e.map {|x| x + "?" } #=> ["FOO !?", "BAR !?", "BAZ !?"] - Le développement d'un compilateur JIT expérimental s'est poursuivi, ce qui peut améliorer considérablement les performances des applications en langage Ruby. Le compilateur JIT proposé dans Ruby écrit d'abord du code C sur le disque, après quoi il appelle un compilateur C externe pour générer des instructions machine (GCC, Clang et Microsoft VC++ sont pris en charge). La nouvelle version implémente une méthode de déploiement en ligne si nécessaire, application sélective des modes d'optimisation lors de la compilation, la valeur par défaut de "--jit-min-calls" passe de 5 à 10000, et "--jit-max-cache" de 1000 à 100.
- Amélioration des performances de CGI.escapeHTML, Monitor et MonitorMixin.
- Module#name, true.to_s, false.to_s et nil.to_s garantissent qu'une chaîne est retournée qui est inchangée pour l'objet spécifié.
- La taille des fichiers binaires générés par la méthode RubyVM ::InstructionSequence#to_binary a été réduite ;
- Versions mises à jour des composants intégrés, y compris
Bundler 2.1.2, RubyGems 3.1.2,
Racc 1.4.15,
CSV 3.1.2, REXML 3.2.3,
RSS 0.2.8,
Analyseur de chaîne 1.0.3 ; - Les bibliothèques sont passées de la distribution de base aux packages de gemmes externes
CMath ( gemme cmath ),
Scanf (scanf gemme),
Coquillage (joyau coquillage),
Synchroniseur (bijou de synchronisation),
ThreadsWait (joyau d'attente),
E2MM (joyau e2mmap). - Les modules stdlib par défaut sont publiés sur rubygems.org :
référence,
cgi,
déléguer,
getoptlong,
pop net,
réseau smtp,
ouvert3,
pstore,
singleton. Modules de surveillance non déplacés vers rubygems.org
observateur,
temps libre,
traceur,
haine,
yaml, qui ne sont livrés qu'avec ruby-core. - La construction de Ruby nécessite désormais un compilateur C prenant en charge la norme C99.
Source: opennet.ru