ECMAScript 2025: As Novas Features do JavaScript Que Você Precisa Conhecer
Olá HaWkers, a atualização anual do JavaScript está aqui e traz consigo uma das maiores coleções de novas funcionalidades dos últimos anos. O ECMAScript 2025 inclui recursos que desenvolvedores vêm pedindo há muito tempo, desde métodos nativos para manipulação de iteradores até melhorias significativas em Sets e Promises.
Você já sentiu que precisava de uma biblioteca externa para fazer operações simples com iteradores? Ou que a API de Set do JavaScript era limitada demais? O ES2025 resolve essas dores de forma elegante e nativa.
Iterator Helpers: A Estrela do ES2025
A principal adição do ECMAScript 2025 é o novo objeto Iterator com seus métodos funcionais. Agora você pode encadear operações como map, filter, take e reduce diretamente em iteradores.
Por Que Isso É Revolucionário
Antes do ES2025, trabalhar com iteradores era verboso e frequentemente exigia conversão para arrays:
// Antes do ES2025 - Precisava converter para Array
function* gerarNumeros(limite) {
for (let i = 0; i < limite; i++) {
yield i;
}
}
// Conversão desnecessária para usar map/filter
const resultado = [...gerarNumeros(1000)]
.filter(n => n % 2 === 0)
.map(n => n * 2)
.slice(0, 10);O problema? Você aloca memória para 1000 elementos quando só precisa de 10. Com Iterator Helpers, a avaliação é preguiçosa (lazy):
// ES2025 - Avaliação preguiçosa nativa
function* gerarNumeros(limite) {
for (let i = 0; i < limite; i++) {
yield i;
}
}
const resultado = gerarNumeros(1000)
.filter(n => n % 2 === 0)
.map(n => n * 2)
.take(10)
.toArray();
// Só processa os elementos necessários!Métodos Disponíveis no Iterator
O ES2025 adiciona diversos métodos ao protótipo de Iterator:
// map - Transforma cada elemento
const dobrados = [1, 2, 3].values().map(x => x * 2).toArray();
// [2, 4, 6]
// filter - Filtra elementos
const pares = [1, 2, 3, 4, 5].values().filter(x => x % 2 === 0).toArray();
// [2, 4]
// take - Pega os primeiros N elementos
const primeiros = [1, 2, 3, 4, 5].values().take(3).toArray();
// [1, 2, 3]
// drop - Pula os primeiros N elementos
const ultimos = [1, 2, 3, 4, 5].values().drop(2).toArray();
// [3, 4, 5]
// flatMap - Map que achata o resultado
const achatado = [[1, 2], [3, 4]].values()
.flatMap(arr => arr.values())
.toArray();
// [1, 2, 3, 4]
// reduce - Reduz para um único valor
const soma = [1, 2, 3, 4].values().reduce((acc, val) => acc + val, 0);
// 10
// forEach - Executa uma ação para cada elemento
[1, 2, 3].values().forEach(x => console.log(x));
// some - Verifica se algum elemento satisfaz condição
const temPar = [1, 3, 5, 6].values().some(x => x % 2 === 0);
// true
// every - Verifica se todos satisfazem condição
const todosPares = [2, 4, 6].values().every(x => x % 2 === 0);
// true
// find - Encontra primeiro elemento que satisfaz condição
const primeiroPar = [1, 3, 4, 6].values().find(x => x % 2 === 0);
// 4Encadeamento Poderoso
O verdadeiro poder está no encadeamento de operações:
// Pipeline complexo com avaliação preguiçosa
function* gerarDadosUsuarios() {
let id = 1;
while (true) {
yield {
id: id++,
nome: `Usuario ${id}`,
ativo: Math.random() > 0.5,
idade: Math.floor(Math.random() * 60) + 18
};
}
}
const usuariosProcessados = gerarDadosUsuarios()
.filter(u => u.ativo) // Apenas ativos
.filter(u => u.idade >= 25) // Maiores de 25
.map(u => ({ // Transforma o objeto
...u,
categoria: u.idade > 40 ? 'senior' : 'junior'
}))
.take(50) // Pega apenas 50
.toArray();
// Mesmo com gerador infinito, só processa o necessário!Novos Métodos de Set
Finalmente o JavaScript tem operações de conjuntos nativas! O ES2025 adiciona métodos que desenvolvedores sempre precisaram.
Union, Intersection e Difference
const setA = new Set([1, 2, 3, 4]);
const setB = new Set([3, 4, 5, 6]);
// union - Todos os elementos de ambos
const uniao = setA.union(setB);
// Set {1, 2, 3, 4, 5, 6}
// intersection - Elementos em comum
const intersecao = setA.intersection(setB);
// Set {3, 4}
// difference - Elementos em A mas não em B
const diferenca = setA.difference(setB);
// Set {1, 2}
// symmetricDifference - Elementos exclusivos de cada um
const difSimetrica = setA.symmetricDifference(setB);
// Set {1, 2, 5, 6}Métodos de Verificação
const pequeno = new Set([1, 2]);
const grande = new Set([1, 2, 3, 4, 5]);
const separado = new Set([6, 7, 8]);
// isSubsetOf - Verifica se é subconjunto
pequeno.isSubsetOf(grande); // true
// isSupersetOf - Verifica se é superconjunto
grande.isSupersetOf(pequeno); // true
// isDisjointFrom - Verifica se não tem elementos em comum
pequeno.isDisjointFrom(separado); // trueCaso de Uso Prático
// Gestão de permissões com Sets
const permissoesAdmin = new Set(['criar', 'ler', 'atualizar', 'deletar', 'gerenciar']);
const permissoesEditor = new Set(['criar', 'ler', 'atualizar']);
const permissoesUsuario = new Set(['ler']);
function verificarAcesso(permissoesRequeridas, permissoesDoUsuario) {
// Todas as permissões requeridas devem estar nas do usuário
return permissoesRequeridas.isSubsetOf(permissoesDoUsuario);
}
function listarPermissoesFaltantes(requeridas, atuais) {
return requeridas.difference(atuais);
}
const requeridas = new Set(['criar', 'ler']);
console.log(verificarAcesso(requeridas, permissoesUsuario)); // false
console.log(listarPermissoesFaltantes(requeridas, permissoesUsuario));
// Set {'criar'}Promise.try: Simplificando Chains
O novo método Promise.try permite iniciar uma Promise chain de forma mais limpa, capturando tanto erros síncronos quanto assíncronos.
O Problema Que Resolve
// Antes do ES2025 - Erros síncronos escapam
function processarDados(input) {
// Se esta linha lançar erro, não é capturado
const validado = validarSync(input);
return buscarDados(validado);
}
// Precisávamos fazer isso:
function processarDadosSeguro(input) {
return Promise.resolve().then(() => {
const validado = validarSync(input);
return buscarDados(validado);
});
}// ES2025 - Promise.try captura tudo
function processarDados(input) {
return Promise.try(() => {
const validado = validarSync(input); // Erro síncrono capturado
return buscarDados(validado); // Erro assíncrono capturado
});
}
// Uso
processarDados(dados)
.then(resultado => console.log(resultado))
.catch(erro => console.error('Erro capturado:', erro));Comparação Direta
// Sem Promise.try
async function exemploAntigo(callback) {
try {
// callback pode lançar erro síncrono
return await Promise.resolve(callback());
} catch (e) {
throw e;
}
}
// Com Promise.try
function exemploNovo(callback) {
return Promise.try(callback);
}
// Ambos fazem o mesmo, mas Promise.try é mais concisoFloat16Array: Novo Tipo de Array Tipado
Para desenvolvedores trabalhando com machine learning e gráficos, o ES2025 introduz o Float16Array.
// Float16 usa metade da memória de Float32
const float16 = new Float16Array([1.5, 2.5, 3.5]);
const float32 = new Float32Array([1.5, 2.5, 3.5]);
console.log(float16.BYTES_PER_ELEMENT); // 2
console.log(float32.BYTES_PER_ELEMENT); // 4
// Útil para tensores em ML onde precisão extrema não é necessária
const tensorGrande = new Float16Array(1000000);
// Usa ~2MB em vez de ~4MBCaso de Uso em WebGL
// Dados de vértices com Float16 economizam memória GPU
const vertices = new Float16Array([
// x, y, z, u, v (posição + textura)
-1.0, -1.0, 0.0, 0.0, 0.0,
1.0, -1.0, 0.0, 1.0, 0.0,
1.0, 1.0, 0.0, 1.0, 1.0,
-1.0, 1.0, 0.0, 0.0, 1.0,
]);
// Upload para GPU
gl.bufferData(gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW);Regex Escaping
O ES2025 adiciona um método nativo para escapar caracteres especiais em expressões regulares.
// Antes - Precisava de função manual
function escapeRegex(string) {
return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}
// ES2025 - Método nativo
const userInput = "Preço: $10.00 (desconto?)";
const pattern = RegExp.escape(userInput);
// "Preço:\\$10\\.00\\(desconto\\?\\)"
const regex = new RegExp(pattern);Uso Prático em Busca
function criarBuscador(termo) {
const termoEscapado = RegExp.escape(termo);
return new RegExp(termoEscapado, 'gi');
}
const texto = "O preço é $50.00 (cinquenta dólares)";
const busca = criarBuscador("$50.00");
console.log(texto.match(busca)); // ["$50.00"]Duplicate Named Capture Groups
Agora você pode usar o mesmo nome de grupo de captura em diferentes partes de uma expressão regular alternativa.
// Antes - Erro: grupo duplicado
// const regex = /(?<year>\d{4})|(?<year>\d{2})/; // SyntaxError
// ES2025 - Permitido quando em alternativas
const regex = /(?<year>\d{4})-(?<month>\d{2})|(?<month>\d{2})\/(?<year>\d{2})/;
// Funciona para diferentes formatos de data
"2025-12".match(regex).groups; // { year: "2025", month: "12" }
"12/25".match(regex).groups; // { year: "25", month: "12" }Parser de Datas Flexível
const dataFlexivel = /^(?:(?<ano>\d{4})-(?<mes>\d{2})-(?<dia>\d{2})|(?<dia>\d{2})\/(?<mes>\d{2})\/(?<ano>\d{4}))$/;
function parsearData(str) {
const match = str.match(dataFlexivel);
if (!match) return null;
const { ano, mes, dia } = match.groups;
return new Date(parseInt(ano), parseInt(mes) - 1, parseInt(dia));
}
parsearData("2025-12-14"); // Date objeto
parsearData("14/12/2025"); // Date objeto (mesmo resultado)Suporte nos Navegadores
As novas features do ES2025 estão sendo implementadas gradualmente. Aqui está o status atual:
| Feature | Chrome | Firefox | Safari | Node.js |
|---|---|---|---|---|
| Iterator Helpers | 122+ | 131+ | 17.4+ | 22+ |
| Set Methods | 122+ | 127+ | 17.0+ | 22+ |
| Promise.try | Em desenvolvimento | Em desenvolvimento | Em desenvolvimento | 22+ |
| Float16Array | 124+ | Em desenvolvimento | Em desenvolvimento | 22+ |
| RegExp.escape | Em desenvolvimento | Em desenvolvimento | Em desenvolvimento | Em desenvolvimento |
Para usar as features antes do suporte universal, considere transpiladores e polyfills como core-js.
Conclusão
O ECMAScript 2025 traz melhorias significativas que tornam o JavaScript mais expressivo e poderoso. Os Iterator Helpers sozinhos representam uma das maiores adições à linguagem em anos, permitindo código mais limpo e eficiente.
Se você trabalha com JavaScript, comece a experimentar essas features em projetos pessoais e fique preparado para usá-las em produção conforme o suporte dos navegadores se expande.
Se você quer continuar atualizando seus conhecimentos em JavaScript, recomendo que dê uma olhada em outro artigo: Descobrindo o Poder do Async/Await em JavaScript onde você vai aprofundar seus conhecimentos em programação assíncrona.
Bora pra cima! 🦅
📚 Quer Aprofundar Seus Conhecimentos em JavaScript?
Este artigo cobriu as novas features do ECMAScript 2025, mas há muito mais para explorar no mundo do JavaScript moderno.
Desenvolvedores que investem em conhecimento sólido e estruturado tendem a ter mais oportunidades no mercado.
Material de Estudo Completo
Se você quer dominar JavaScript do básico ao avançado, preparei um guia completo:
Opções de investimento:
- 1x de R$9,90 no cartão
- ou R$9,90 à vista
💡 Material atualizado com as melhores práticas do mercado