9 postagens marcadas com "ES2020"

'Atomics.wait' e 'Atomics.notify' são primitivas de sincronização de baixo nível úteis para implementar mutexes e outros meios de sincronização. No entanto, como 'Atomics.wait' é bloqueador, não é possível chamá-lo na thread principal (tentar fazer isso dispara um 'TypeError').

A proposta de coalescência nula (??) adiciona um novo operador de curto-circuito destinado a lidar com valores padrão.

Você pode já estar familiarizado com os outros operadores de curto-circuito && e ||. Ambos lidam com valores “truthy” e “falsy”. Imagine o exemplo de código lhs && rhs. Se lhs (lido como, lado esquerdo) for falsy, a expressão avalia para lhs. Caso contrário, avalia para rhs (lido como, lado direito). O oposto é verdadeiro para o exemplo de código lhs || rhs. Se lhs for truthy, a expressão avalia para lhs. Caso contrário, avalia para rhs.

Cadeias longas de acessos a propriedades em JavaScript podem ser propensas a erros, já que qualquer uma delas pode ser avaliada como null ou undefined (também conhecidos como valores “nulos”). Verificar a existência de propriedade em cada etapa facilmente se transforma em uma estrutura profundamente aninhada de instruções if ou uma condição if longa que replica a cadeia de acesso à propriedade:

Se você já escreveu JavaScript para uso em um navegador web antes, pode ter usado window para acessar o this global. No Node.js, você pode ter usado global. Se você escreveu um código que deve funcionar em qualquer um dos ambientes, pode ter detectado qual deles está disponível e usado isso - mas a lista de identificadores a verificar cresce com o número de ambientes e casos de uso que você deseja suportar. Isso foge do controle rapidamente:

Desde a introdução de promises no ES2015, o JavaScript suporta exatamente dois combinadores de promise: os métodos estáticos Promise.all e Promise.race.

Duas novas propostas estão atualmente passando pelo processo de padronização: Promise.allSettled e Promise.any. Com essas adições, haverá um total de quatro combinadores de promise no JavaScript, cada um possibilitando diferentes casos de uso.

É comum aplicar repetidamente a mesma expressão regular em uma string para obter todas as correspondências. Até certo ponto, isso já é possível hoje usando o método String#match.

Neste exemplo, encontramos todas as palavras que consistem apenas em dígitos hexadecimais e, em seguida, registramos cada correspondência:

const string = 'Números hex mágicos: DEADBEEF CAFE';
const regex = /\b\p{ASCII_Hex_Digit}+\b/gu;
for (const match of string.match(regex)) {
  console.log(match);
}

// Saída:
//
// 'DEADBEEF'
// 'CAFE'

No entanto, isso só fornece os substrings que correspondem. Normalmente, você não quer apenas os substrings, mas também informações adicionais, como o índice de cada substring ou os grupos de captura dentro de cada correspondência.

Já é possível alcançar isso escrevendo seu próprio loop e rastreando os objetos de correspondência você mesmo, mas é um pouco chato e não muito prático:

const string = 'Números hex mágicos: DEADBEEF CAFE';
const regex = /\b\p{ASCII_Hex_Digit}+\b/gu;
let match;
while (match = regex.exec(string)) {
  console.log(match);
}

// Saída:
//
// [ 'DEADBEEF', índice: 19, entrada: 'Números hex mágicos: DEADBEEF CAFE' ]
// [ 'CAFE',     índice: 28, entrada: 'Números hex mágicos: DEADBEEF CAFE' ]

A nova API String#matchAll torna isso mais fácil do que nunca: agora você pode escrever um simples loop for-of para obter todos os objetos de correspondência.

const string = 'Números hex mágicos: DEADBEEF CAFE';
const regex = /\b\p{ASCII_Hex_Digit}+\b/gu;
for (const match of string.matchAll(regex)) {
  console.log(match);
}

// Saída:
//
// [ 'DEADBEEF', índice: 19, entrada: 'Números hex mágicos: DEADBEEF CAFE' ]
// [ 'CAFE',     índice: 28, entrada: 'Números hex mágicos: DEADBEEF CAFE' ]

String#matchAll é especialmente útil para expressões regulares com grupos de captura. Ele fornece todas as informações para cada correspondência individual, incluindo os grupos de captura.

const string = 'Repositórios favoritos do GitHub: tc39/ecma262 v8/v8.dev';
const regex = /\b(?<owner>[a-z0-9]+)\/(?<repo>[a-z0-9\.]+)\b/g;
for (const match of string.matchAll(regex)) {
  console.log(`${match[0]} em ${match.index} com '${match.input}'`);
  console.log(`→ proprietário: ${match.groups.owner}`);
  console.log(`→ repositório: ${match.groups.repo}`);
}

Em módulos JavaScript, já era possível usar a seguinte sintaxe:

import * as utils from './utils.mjs';

No entanto, não existia uma sintaxe export simétrica… até agora:

export * as utils from './utils.mjs';

Isso é equivalente ao seguinte:

import * as utils from './utils.mjs';
export { utils };

BigInts são um novo tipo numérico em JavaScript que pode representar inteiros com precisão arbitrária. Com BigInts, você pode armazenar e operar com segurança em grandes inteiros, mesmo além do limite seguro de inteiros para Numbers. Este artigo explora alguns casos de uso e explica a nova funcionalidade no Chrome 67 comparando BigInts com Numbers em JavaScript.

Importação Dinâmica import() introduz uma nova forma semelhante a uma função de import que desbloqueia novas capacidades em comparação com a importação estática. Este artigo compara os dois e oferece uma visão geral do que há de novo.