Despois dun ano de desenvolvemento liberación , unha linguaxe de programación dinámica orientada a obxectos que é altamente eficiente no desenvolvemento de programas e que incorpora as mellores características de Perl, Java, Python, Smalltalk, Eiffel, Ada e Lisp. O código do proxecto distribúese baixo as licenzas BSD ("BSDL de dúas cláusulas") e "Ruby", que fai referencia á última versión da licenza GPL e é totalmente compatible con GPLv2. Ruby 3 é a sétima versión principal que se produce como parte dun proceso de desenvolvemento planificado que inclúe reservar un ano para mellorar as funcións e un lanzamento de parche de 2.7-2 meses.
O principal :
- experimental coincidencia de patróns () para iterar sobre o obxecto indicado e asignar un valor se hai unha coincidencia de 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}
: inalcanzable
en {a: 0, b: var}
p var # => 1
final - O shell de cálculos interactivos irb (REPL, Read-Eval-Print-Loop) agora ten a posibilidade de editar varias liñas, implementada mediante unha biblioteca compatible con readline escrito en rubí. Integrouse o soporte para rdoc, que permite ver información de referencia sobre clases, módulos e métodos especificados en irb. Ofrécese un resaltado de cor das liñas co código mostrado a través de Binding#irb e os resultados da inspección de obxectos de clase base.
- Engadiuse un colector de lixo compacto (Compaction GC) que pode desfragmentar unha rexión de memoria, resolvendo os problemas de rendemento lento e aumento do consumo de memoria debido á fragmentación da memoria que se produce durante o funcionamento dalgunhas aplicacións Ruby multiproceso. Para empaquetar obxectos no montón Método GC.compact para reducir o número de páxinas de memoria utilizadas e optimizar o montón para as operacións
CoW (copia sobre escritura). - preparándose para separar argumentos en función da posición na lista ("def foo(a,b,c)") e palabras clave ("def foo(key: val)"). A conversión automática de argumentos baseada en palabras clave e posición quedou en desuso e non se admitirá na rama Ruby 3.0. En particular, quedou en desuso utilizar o último argumento como parámetros de palabras clave, pasar argumentos baseados en palabras clave como último parámetro hash e dividir o último argumento en parámetros posicionais e de palabras clave.
def foo (clave: 42); fin; foo({clave: 42}) #advertido
def foo(**kw); fin; foo({clave: 42}) #advertido
def foo (clave: 42); fin; foo(**{clave: 42}) # Aceptar
def foo(**kw); fin; foo(**{clave: 42}) # Aceptardef foo(h, **kw); fin; foo (clave: 42) #avisado
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("key" => 43, clave: 42) #advertido
def foo(h={}, clave: 42); fin; foo({"key" => 43, clave: 42}) # avisado
def foo(h={}, clave: 42); fin; foo({"key" => 43}, clave: 42) # Aceptardef foo(opt={}); fin; foo(clave: 42) # Aceptar
def foo(h, **nil); fin; foo(clave: 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({clave: 1}) # Aceptar
def foo(h, **nil); fin; foo({"str" => 1}) # Aceptarh = {}; def foo(*a) end; foo(**h) # [] h = {}; def foo(a) end; foo(**h) # {} e aviso
h = {}; def foo(*a) end; foo(h) # [{}] h = {}; def foo(a) end; foo(h) # {} - utilizando nomes de variables predeterminados numerados para os parámetros de bloque.
[1, 2, 3].cada { pon @1 } # como [1, 2, 3].cada { |i| pon eu}
- Soporte experimental para intervalos sen valor inicial.
ary[..3] # igual que ary[0..3] rel.where(vendas: ..100)
- Engadiuse o método Enumerable#tally, que conta cantas veces ocorre cada elemento.
["a", "b", "c", "b"].
#=> {"a" => 1, "b" => 2, "c" => 1} - Permítese a chamada de método privado con literal "self".
defoo
final
privado: foo
auto.foo - Engadiuse o método Enumerator::Lazy#eager para xerar unha enumeración regular a partir dun enumerador preguiceiro (Enumerator::Lazy).
a = %w(foo bar baz)
e = a.lazy.map {|x| x.maiúsculas }.mapa {|x| x + "!" }.Ansioso
p e.class #=> Enumerador
e.map {|x| x + "?" } #=> ["FOO!?", "BAR!?", "BAZ!?"] - Continuou o desenvolvemento dun compilador JIT experimental, que pode mellorar significativamente o rendemento das aplicacións na linguaxe Ruby. O compilador JIT proposto en Ruby escribe primeiro código C no disco, despois de que chama a un compilador C externo para xerar instrucións da máquina (admítense GCC, Clang e Microsoft VC ++). A nova versión implementa un método para a implantación en liña se é necesario, a aplicación selectiva de modos de optimización durante a compilación, o valor predeterminado de "--jit-min-calls" aumenta de 5 a 10000 e "--jit-max-cache" de 1000 a 100.
- Mellorouse o rendemento de CGI.escapeHTML, Monitor e MonitorMixin.
- Module#name, true.to_s, false.to_s e nil.to_s garanten que se devolve unha cadea sen cambios para o obxecto especificado.
- O tamaño dos ficheiros binarios xerados polo método RubyVM::InstructionSequence#to_binary reduciuse;
- Versións actualizadas de compoñentes integrados, incluíndo
Bundler 2.1.2, RubyGems 3.1.2,
Racc 1.4.15,
CSV 3.1.2, REXML 3.2.3,
RSS 0.2.8,
Escáner de cadeas 1.0.3; - As bibliotecas pasaron da distribución base a paquetes de xemas externas
CMath (xoia cmath),
Scanf (xoia de escaneo),
Shell (xoia de cuncha),
Sincronizador (gem de sincronización),
ThreadsWait (xoia de espera),
E2MM (xoia e2mmap). - Os módulos stdlib predeterminados publícanse en rubygems.org:
punto de referencia,
cgi,
delegado,
getoptlong,
pop net,
smtp net,
aberto 3,
pstore,
singleton. Os módulos de monitor non se moveron a rubygems.org
observador,
tempo de espera,
trazador,
uri,
yaml, que só se envían con núcleo de rubí. - Construír Ruby agora require un compilador C que admita o estándar C99.
Fonte: opennet.ru