Após um ano de desenvolvimento liberar , uma linguagem de programação dinâmica orientada a objetos que é altamente eficiente no desenvolvimento de programas e incorpora os melhores recursos de Perl, Java, Python, Smalltalk, Eiffel, Ada e Lisp. O código do projeto é distribuído sob as licenças BSD ("BSDL de 2 cláusulas") e "Ruby", que se refere à versão mais recente da licença GPL e é totalmente compatível com GPLv3. Ruby 2.7 é o sétimo lançamento principal a ser produzido como parte de um processo de desenvolvimento planejado que inclui reservar um ano para melhorias de recursos e um lançamento de patch de 2 a 3 meses.
O principal :
- Experimental correspondência de padrões () para iterar sobre o objeto fornecido e atribuir um valor se houver uma correspondência de padrão.
caso [0, [1, 2, 3]] em [a, [b, *c]] pa #=> 0
pb#=> 1
pc#=> [2, 3] fimcaso {a: 0, b: 1}
em{a:0,x:1}
:inacessível
em {a: 0, b: var}
var #=> 1
final - O shell de cálculos interativos irb (REPL, Read-Eval-Print-Loop) agora tem a possibilidade de edição multilinha, implementada usando uma biblioteca compatível com readline , escrito em Ruby. O suporte ao rdoc foi integrado, permitindo visualizar informações de referência sobre classes, módulos e métodos específicos no irb. Fornecido realce colorido de linhas de código mostradas por meio de Binding#irb e os resultados da inspeção de objetos de classe base.
- Adicionado um coletor de lixo compacto (Compaction GC) que pode desfragmentar uma região de memória, resolvendo os problemas de desempenho lento e aumento de consumo de memória devido à fragmentação de memória que ocorre durante a operação de alguns aplicativos Ruby multithread. Para empacotar objetos na pilha Método GC.compact para reduzir o número de páginas de memória usadas e otimizar o heap para operações
CoW (cópia na gravação). - preparando-se para separar argumentos com base na posição na lista ("def foo(a,b,c)") e palavras-chave ("def foo(key: val)"). A conversão automática de argumentos baseada em palavras-chave e posição foi descontinuada e não será suportada no branch Ruby 3.0. Em particular, foi descontinuado o uso do último argumento como parâmetros de palavras-chave, para passar argumentos baseados em palavras-chave como o último parâmetro hash e para dividir o último argumento em parâmetros posicionais e de palavras-chave.
def foo(chave: 42); fim; foo({chave: 42}) #avisado
def foo(**kw); fim; foo({chave: 42}) #avisado
def foo(chave: 42); fim; foo(**{chave: 42}) # OK
def foo(**kw); fim; foo(**{chave: 42}) # OKdef foo(h, **kw); fim; foo(chave: 42) #avisado
def foo(h, chave: 42); fim; foo(chave: 42) #avisado
def foo(h, **kw); fim; foo({chave: 42}) # OK
def foo(h, chave: 42); fim; foo({chave: 42}) # OKdef foo(h={}, chave: 42); fim; foo("chave" => 43, chave: 42) #avisado
def foo(h={}, chave: 42); fim; foo({"key" => 43, key: 42}) # avisado
def foo(h={}, chave: 42); fim; foo({"chave" => 43}, chave: 42) #OKdef foo(opt={}); fim; foo(tecla: 42) # OK
def foo(h, **nil); fim; foo(chave: 1) # ArgumentError
def foo(h, **nil); fim; foo(**{chave: 1}) # ArgumentError
def foo(h, **nil); fim; foo("str" => 1) # ArgumentError
def foo(h, **nil); fim; foo({chave: 1}) # OK
def foo(h, **nil); fim; foo({"str" => 1}) #OKh={}; def foo(*a) fim; foo(**h) # [] h = {}; def foo(a) fim; foo(**h) # {} e aviso
h={}; def foo(*a) fim; foo(h) # [{}] h = {}; def foo(a) fim; foo(h) # {} - usando nomes de variáveis numeradas por padrão para parâmetros de bloco.
[1, 2, 3].each { coloca @1 } # igual a [1, 2, 3].each { |i| coloca eu}
- Suporte experimental para intervalos sem valor inicial.
ary[..3] # igual a ary[0..3] rel.where(vendas: ..100)
- Adicionado o método Enumerable#tally, que conta quantas vezes cada elemento ocorre.
["a", "b", "c", "b"].tally
#=> {"a"=>1, "b"=>2, "c"=>1} - Chamada de método privado permitida com literal "self"
deffoo
final
privado: foo
self.foo - Adicionado o método Enumerator::Lazy#eager para gerar enumeração regular a partir de enumeração preguiçosa (Enumerator::Lazy).
a = %w(foo bar baz)
e = a.lazy.map {|x| x.upcase }.map {|x| x + "!" }.ansioso
p e.class #=> Enumerador
e.mapa {|x| x + "?" } #=> [“FOO!?”, “BAR!?”, “BAZ!?”] - O desenvolvimento de um compilador JIT experimental continuou, o que pode melhorar significativamente o desempenho de aplicações na linguagem Ruby. O compilador JIT proposto em Ruby primeiro grava o código C no disco e, em seguida, chama um compilador C externo para gerar instruções de máquina (GCC, Clang e Microsoft VC ++ são suportados). A nova versão implementa um método de implantação inline, se necessário, aplicação seletiva de modos de otimização durante a compilação, o valor padrão de "--jit-min-calls" é aumentado de 5 para 10000 e "--jit-max-cache" de 1000 a 100.
- Melhor desempenho de CGI.escapeHTML, Monitor e MonitorMixin.
- Module#name, true.to_s, false.to_s e nil.to_s garantem que uma string seja retornada inalterada para o objeto especificado.
- O tamanho dos arquivos binários gerados pelo método RubyVM::InstructionSequence#to_binary foi reduzido;
- Versões atualizadas de componentes integrados, incluindo
Bundler 2.1.2, RubyGems 3.1.2,
Corrida 1.4.15,
CSV 3.1.2, REXML 3.2.3,
RSS 0.2.8,
Scanner de cordas 1.0.3; - Bibliotecas movidas da distribuição básica para pacotes gem externos
CMath (gema cmath),
Scanf (gema scanf),
Concha (gema de concha)
Sincronizador (gem de sincronização),
ThreadsWait (gema thwait),
E2MM (gema e2mmap). - Os módulos stdlib padrão são publicados em rubygems.org:
de referência,
cgi,
delegar,
getoptlong,
rede pop,
smtp líquido,
aberto3,
loja,
solteiro. Monitore módulos não movidos para rubygems.org
observador,
tempo esgotado,
marcador,
ódio,
yaml, que são enviados apenas com ruby-core. - Construir Ruby agora requer um compilador C que suporte o padrão C99.
Fonte: opennet.ru