Recursos que todo desenvolvedor JavaScript precisa conhecer em 2025

• O JavaScript continua evoluindo em 2025, e alguns recursos, embora pouco conhecidos, são extremamente úteis
• Os novos métodos auxiliares de Iterator funcionam de forma muito mais eficiente em memória ao transformar grandes volumes de dados
• Acesso ao fim de arrays com at(), uso simples de Promise.withResolvers(), cópia profunda com structuredClone() e mais
• Operações de conjunto para Set, funções de marcação para template strings e como usar WeakMap/WeakSet ainda passam despercebidos por muitos desenvolvedores

Métodos auxiliares de Iterator

• Encadear como em arr.filter().map() faz com que um novo array seja criado em cada etapa, o que é ineficiente
• Isso pode ser melhorado com encadeamento baseado em iteradores, como em arr.values().drop(10).take(10).map(...).toArray()
• Principais métodos:
  • drop(): ignora os primeiros n itens
  • take(): pega apenas os primeiros n itens
  • filter(), map(), flatMap(): funcionam de forma parecida com os métodos de array
  • reduce(), some(), every(), find(): oferecem suporte a testes condicionais e cálculos acumulados
  • toArray(): converte para um array final
• O Safari passou a oferecer suporte a partir de 31 de março de 2025, mas ainda não há suporte em todos os navegadores

Array at()

• arr.at(n) é semelhante a arr[n], mas permite indexação negativa para acessar a partir do fim
• Exemplo: [10, 20, 30].at(-1) → 30
• Permite acessar o último elemento sem precisar de algo inconveniente como arr[arr.length - 1]

Promise.withResolvers()

• Forma antiga: guardar resolve/reject do lado de fora em new Promise((resolve, reject) => { ... })
• Agora: const { promise, resolve, reject } = Promise.withResolvers() permite um uso mais conciso e intuitivo

Uso de callback em String.replace()

• O segundo argumento de replace() e replaceAll() aceita não só string, mas também uma função de callback
• Exemplo: "X, X, X".replaceAll("X", (match, i) => match + i) → "X0, X3, X6"
• Permite vários tipos de substituição de uma vez só → eficiente em termos de desempenho e memória

Troca de variáveis (Swap)

• Forma antiga: usar uma variável temp
• Forma concisa: [a, b] = [b, a], fazendo a troca de variáveis com destructuring de array

structuredClone()

• Em vez de JSON.stringify() + JSON.parse(), oferece cópia profunda mais precisa e eficiente
• Vantagens:
  • também suporta NaN, undefined, bigint etc.
  • copia referências circulares com segurança
  • para objetos grandes, oferece melhor eficiência de memória e velocidade

Tagged Template Literals

• Permitem fazer o parsing de template strings com uma função específica
• São úteis para pós-processamento dinâmico de strings, como escape de HTML
• Exemplo:
  a função tag escapeHtml transforma <br> ${'<br>'} em <br> <br>

WeakMap / WeakSet

• São parecidos com Map e Set comuns, mas:
  • aceitam apenas objetos como chave (não valores primitivos)
  • são removidos automaticamente quando viram alvo do GC
• São adequados quando há possibilidade de referência circular ou quando se quer armazenar metadados de objetos sem efeitos colaterais

Suporte a operações de conjunto em Set

No JavaScript, agora foram adicionadas diversas operações lógicas ao objeto Set:

• difference(): diferença (A - B)
• intersection(): interseção (A ∩ B)
• union(): união (A ∪ B)
• symmetricDifference(): diferença simétrica (A △ B)
• isDisjointFrom(): se não há elementos em comum
• isSubsetOf(): se é subconjunto
• isSupersetOf(): se é superconjunto

[wfedev]

Parece que o problema em que, ao fazer parsing de literais, até as variáveis saíam como string foi resolvido. Obrigado por compartilhar.

[pompapa]

Ex.: "X, X, X".replaceAll("X", (match, i) => match + i) → "X0, X1, X2"

O exemplo está incorreto. i contém a posição em que houve correspondência.
Portanto, o resultado é "X0, X3, X6".

[xguru]

Opa, é verdade. A IA acabou gerando o exemplo errado. Já corrigi. Obrigado pela observação perspicaz!

[click]

values passa uma sensação parecida com a Java Stream API, então comparei e, quando o tamanho do array é pequeno, fazer filter sem values é mais rápido. Como é baseado em iteradores, também faz sentido que, quanto mais chaining houver, mais rápido fique o método que passa por values uma vez. Para o benchmark, consulte https://jsperf.app/dixutu.