Después de un año de desarrollo relizar , un lenguaje de programación dinámico orientado a objetos que es altamente eficiente en el desarrollo de programas e incorpora las mejores características de Perl, Java, Python, Smalltalk, Eiffel, Ada y Lisp. El código del proyecto se distribuye bajo las licencias BSD (“BSDL de 2 cláusulas”) y “Ruby”, que hace referencia a la última versión de la licencia GPL y es totalmente compatible con GPLv3. Ruby 2.7 es la séptima versión importante después de un proceso de desarrollo planificado que lleva un año preparar mejoras funcionales y produce versiones de mantenimiento cada 2 o 3 meses.
El principal :
- Experimental la coincidencia de patrones (), que le permiten iterar sobre un objeto determinado y asignar un valor si coincide con el patrón.
caso [0, [1, 2, 3]] en [a, [b, *c]] pa #=> 0
pb#=> 1
pc #=> [2, 3] fincaso {a: 0, b: 1}
en {a: 0, x: 1}
:indisponible
en {a:0,b:var}
pvar#=> 1
final - El shell de cálculos interactivos irb (REPL, Read-Eval-Print-Loop) ahora presenta edición de varias líneas, implementada mediante una biblioteca compatible con readline. , escrito en Rubí. Se ha integrado el soporte de rdoc, lo que le permite ver información de referencia sobre clases, módulos y métodos específicos en irb. Se proporcionó resaltado de color de líneas de código mostradas a través de Binding#irb y los resultados de la inspección de objetos de clase base.
- Se agregó un recolector de basura compacto (Compaction GC) que puede desfragmentar una región de la memoria, resolviendo los problemas de rendimiento y consumo de memoria causados por la fragmentación de la memoria que ocurre en algunas aplicaciones Ruby multiproceso. Para empaquetar objetos en el montón Método GC.compact, que le permite reducir la cantidad de páginas de memoria utilizadas y optimizar el montón para las operaciones.
CoW (copia en escritura). - preparándose para separar argumentos según la posición de la lista (“def foo(a,b,c)”) y palabras clave (“def foo(key: val)”). La conversión automática de argumentos basada en palabras clave y posición ha quedado obsoleta y no será compatible con la rama Ruby 3.0. Específicamente, ha dejado de usarse el último argumento como parámetro de palabra clave, pasar argumentos basados en palabras clave como último parámetro hash y dividir el último argumento en parámetros posicionales y de palabra clave.
def foo(clave: 42); fin; foo({clave: 42}) # advertido
deffoo(**kw); fin; foo({clave: 42}) # advertido
def foo(clave: 42); fin; foo(**{clave: 42}) # Aceptar
deffoo(**kw); fin; foo(**{clave: 42}) # Aceptardef foo(h, **kw); fin; foo(clave: 42) # advertido
def foo(h, clave: 42); fin; foo(clave: 42) # advertido
def foo(h, **kw); fin; foo({clave: 42}) # Aceptar
def foo(h, clave: 42); fin; foo({clave: 42}) # Aceptardef foo(h={}, clave: 42); fin; foo("clave" => 43, clave: 42) # advertido
def foo(h={}, clave: 42); fin; foo({"clave" => 43, clave: 42}) # advertido
def foo(h={}, clave: 42); fin; foo({"clave" => 43}, clave: 42) # Aceptardef foo(opt={}); fin; foo (clave: 42) # Aceptar
def foo(h, **nulo); fin; foo(clave: 1) #ArgumentError
def foo(h, **nulo); fin; foo(**{clave: 1}) # ArgumentError
def foo(h, **nulo); fin; foo("str" => 1) # ArgumentError
def foo(h, **nulo); fin; foo({clave: 1}) # Aceptar
def foo(h, **nulo); fin; foo({"str" => 1}) # Aceptarh = {}; def foo(*a) un fin; foo(**h) # [] h = {}; def foo(a) un fin; foo(**h) # {} y advertencia
h = {}; def foo(*a) un fin; foo(h) # [{}] h = {}; def foo(a) un fin; foo(h) # {} - utilizando nombres de variables numerados de forma predeterminada para los parámetros de bloque.
[1, 2, 3].cada uno { pone @1 } # igual que [1, 2, 3].cada uno { |i| pone yo }
- Soporte experimental para rangos sin valor inicial.
ary[..3] # similar a ary[0..3] rel.where(ventas: ..100)
- Se agregó el método Enumerable#tally, que cuenta el número de veces que ocurre cada elemento.
["a", "b", "c", "b"].cuenta
#=> {“a”=>1, “b”=>2, “c”=>1} - Se permite llamar a un método privado con el literal "self"
definitivamente foo
final
privado: foo
yo.foo - Se agregó el método Enumerator::Lazy#eager para generar una enumeración regular a partir de un enumerador diferido (Enumerator::Lazy).
a = %w(foo barra baz)
e = a.lazy.map {|x| x.upcase }.map {|x| x + "!" }.ansioso
p e.class #=> Enumerador
p e.map {|x| x + "?" } #=> ["¡FOO!?", "¡BAR!?", "BAZ!?"] - Continuó el desarrollo de un compilador JIT experimental, que puede mejorar significativamente el rendimiento de las aplicaciones en el lenguaje Ruby. El compilador JIT de Ruby primero escribe código C en el disco y luego llama a un compilador C externo para generar instrucciones de máquina (admite llamadas a GCC, Clang y Microsoft VC ++). La nueva versión implementa un método para la implementación en línea si es necesario, se garantiza la aplicación selectiva de modos de optimización durante la compilación, el valor predeterminado de “--jit-min-calls” aumenta de 5 a 10000 y “--jit-max- caché” de 1000 a 100.
- Rendimiento mejorado de CGI.escapeHTML, Monitor y MonitorMixin.
- Module#name, true.to_s, false.to_s y nil.to_s garantizan que se devuelva una cadena sin cambios para el objeto especificado.
- Se ha reducido el tamaño de los archivos binarios generados por el método RubyVM::InstructionSequence#to_binary;.
- Versiones actualizadas de componentes integrados, incluidos
Paquete 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; - Las bibliotecas se han movido del paquete base a paquetes de gemas externos.
CMath (gema cmath),
Scanf (gema de escaneo),
Concha (gema de concha)
Sincronizador (gema de sincronización),
ThreadsWait (gema de espera),
E2MM (gema de mapa e2mm). - Los módulos stdlib predeterminados están publicados en rubygems.org:
punto de referencia,
cgi,
delegar,
obteneroptlong,
pop neto,
net-smtp
abierto3,
pstore,
único. módulos de monitor no movidos a rubygems.org
observador,
se acabó el tiempo,
trazador,
odio,
yaml, que sólo se suministran en ruby-core. - La creación de Ruby ahora requiere un compilador de C que admita el estándar C99.
Fuente: opennet.ru