ECMAScript 2025: Os Novos Recursos do JavaScript que Você Precisa Conhecer
Olá HaWkers, a atualização anual do JavaScript chegou e traz mudanças significativas para nossa linguagem favorita. O ECMAScript 2025 foi oficialmente aprovado pelo TC39 e inclui recursos que vão transformar a forma como escrevemos código.
Você está pronto para explorar as novidades que tornarão seu código mais limpo, eficiente e expressivo? Vamos mergulhar em cada novo recurso com exemplos práticos.
O Objeto Iterator Nativo
A principal adição do ES2025 é o novo objeto Iterator com operadores funcionais nativos. Isso significa que agora podemos encadear operações em iteradores sem precisar converter para arrays.
Por Que Isso É Revolucionário
Antes, para aplicar transformações em iteradores, precisávamos convertê-los para arrays primeiro, consumindo memória desnecessariamente:
// Antes (ES2024 e anteriores)
const map = new Map([['a', 1], ['b', 2], ['c', 3]]);
const result = [...map.keys()]
.filter(key => key !== 'b')
.map(key => key.toUpperCase());
// Criava array intermediário na memóriaAgora, com os Iterator helpers:
// ES2025 - Iterator helpers nativos
const map = new Map([['a', 1], ['b', 2], ['c', 3]]);
const result = map.keys()
.filter(key => key !== 'b')
.map(key => key.toUpperCase())
.toArray();
// Processamento lazy, sem arrays intermediáriosMétodos Disponíveis nos Iterators
// Todos os novos métodos de Iterator
const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
// .map() - transforma cada elemento
const doubled = numbers.values()
.map(n => n * 2)
.toArray();
// [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
// .filter() - filtra elementos
const evens = numbers.values()
.filter(n => n % 2 === 0)
.toArray();
// [2, 4, 6, 8, 10]
// .take() - pega os primeiros N elementos
const firstThree = numbers.values()
.take(3)
.toArray();
// [1, 2, 3]
// .drop() - ignora os primeiros N elementos
const afterThree = numbers.values()
.drop(3)
.toArray();
// [4, 5, 6, 7, 8, 9, 10]
// .flatMap() - map + flatten
const nested = [[1, 2], [3, 4]];
const flat = nested.values()
.flatMap(arr => arr.values())
.toArray();
// [1, 2, 3, 4]Novos Métodos de Set
O ES2025 finalmente traz operações de conjunto que desenvolvedores pediam há anos. Agora podemos fazer união, interseção e diferença diretamente nos Sets.
const frontend = new Set(['React', 'Vue', 'Angular', 'Svelte']);
const popular = new Set(['React', 'Vue', 'Node', 'Express']);
// .union() - combina dois sets
const allTech = frontend.union(popular);
// Set {'React', 'Vue', 'Angular', 'Svelte', 'Node', 'Express'}
// .intersection() - elementos em comum
const frontendPopular = frontend.intersection(popular);
// Set {'React', 'Vue'}
// .difference() - elementos que estão em A mas não em B
const onlyFrontend = frontend.difference(popular);
// Set {'Angular', 'Svelte'}
// .symmetricDifference() - elementos exclusivos de cada set
const exclusive = frontend.symmetricDifference(popular);
// Set {'Angular', 'Svelte', 'Node', 'Express'}
// .isSubsetOf() - verifica se é subconjunto
const react = new Set(['React']);
console.log(react.isSubsetOf(frontend)); // true
// .isSupersetOf() - verifica se é superconjunto
console.log(frontend.isSupersetOf(react)); // true
// .isDisjointFrom() - verifica se não há interseção
const backend = new Set(['Python', 'Java', 'Go']);
console.log(frontend.isDisjointFrom(backend)); // trueAplicação Prática: Sistema de Permissões
// Sistema de permissões com Sets
const adminPermissions = new Set(['read', 'write', 'delete', 'admin']);
const userPermissions = new Set(['read', 'write']);
const guestPermissions = new Set(['read']);
function checkAccess(userPerms, requiredPerms) {
// Verifica se o usuário tem todas as permissões necessárias
return requiredPerms.isSubsetOf(userPerms);
}
const editPagePerms = new Set(['read', 'write']);
console.log(checkAccess(adminPermissions, editPagePerms)); // true
console.log(checkAccess(guestPermissions, editPagePerms)); // false
// Encontrar permissões que faltam
function missingPermissions(userPerms, requiredPerms) {
return requiredPerms.difference(userPerms);
}
console.log(missingPermissions(guestPermissions, editPagePerms));
// Set {'write'}Promise.try(): Simplificando Chains de Promises
O novo método Promise.try() resolve um problema comum: iniciar uma chain de Promises com código que pode ser síncrono ou assíncrono.
// Problema antes do ES2025
function processData(data) {
// Pode lançar erro síncrono
const parsed = JSON.parse(data);
return fetchAdditionalData(parsed.id);
}
// Antes: precisávamos envolver em Promise.resolve()
Promise.resolve()
.then(() => processData(userInput))
.then(result => console.log(result))
.catch(err => console.error(err));
// Ou usar async IIFE
(async () => {
try {
const result = await processData(userInput);
console.log(result);
} catch (err) {
console.error(err);
}
})();Com Promise.try():
// ES2025 - Promise.try()
Promise.try(() => processData(userInput))
.then(result => console.log(result))
.catch(err => console.error(err));
// Captura erros síncronos E assíncronos uniformementePor Que Isso Importa
// Exemplo real: processamento de configuração
function loadConfig(configPath) {
// validatePath pode lançar erro síncrono
const validPath = validatePath(configPath);
// readConfigFile retorna Promise
return readConfigFile(validPath);
}
// Promise.try garante que QUALQUER erro seja capturado
Promise.try(() => loadConfig('./config.json'))
.then(config => initializeApp(config))
.catch(err => {
// Captura tanto erros de validatePath quanto de readConfigFile
console.error('Falha ao carregar config:', err);
return loadDefaultConfig();
});Float16Array: Novo Tipo de Array Tipado
O ES2025 adiciona Float16Array, um array tipado para números de ponto flutuante de 16 bits. Isso é especialmente útil para aplicações de machine learning e processamento gráfico.
// Criando um Float16Array
const halfFloats = new Float16Array([1.5, 2.5, 3.5, 4.5]);
console.log(halfFloats); // Float16Array [1.5, 2.5, 3.5, 4.5]
console.log(halfFloats.BYTES_PER_ELEMENT); // 2
// Comparação de memória
const float32 = new Float32Array(1000); // 4KB
const float16 = new Float16Array(1000); // 2KB
// Metade da memória para o mesmo número de elementos
// Útil para WebGL e processamento de imagem
function processImageData(pixels) {
// Normaliza pixels para 0-1 com metade da memória
const normalized = new Float16Array(pixels.length);
for (let i = 0; i < pixels.length; i++) {
normalized[i] = pixels[i] / 255;
}
return normalized;
}Funções Auxiliares
// Novas funções globais para Float16
const value = 3.14159;
// Math.f16round() - arredonda para precisão de 16 bits
const rounded = Math.f16round(value);
console.log(rounded); // 3.140625 (precisão reduzida)
// DataView methods para Float16
const buffer = new ArrayBuffer(4);
const view = new DataView(buffer);
view.setFloat16(0, 3.14);
console.log(view.getFloat16(0)); // 3.140625Import de Módulos JSON Diretamente
Agora é possível importar arquivos JSON diretamente como módulos ES, sem necessidade de fetch ou require.
// ES2025 - Import direto de JSON
import config from './config.json' with { type: 'json' };
import translations from './i18n/pt-BR.json' with { type: 'json' };
console.log(config.apiUrl);
console.log(translations.welcome);
// Import dinâmico também funciona
const loadLocale = async (lang) => {
const messages = await import(`./i18n/${lang}.json`, {
with: { type: 'json' }
});
return messages.default;
};Melhorias em Regular Expressions
O ES2025 traz a flag /v para expressões regulares, permitindo operações de conjunto em classes de caracteres.
// Nova flag /v para operações de conjunto
const vogais = /[aeiou]/v;
const consoantes = /[a-z&&[^aeiou]]/v; // Interseção e subtração
// Subtração de conjuntos
const letrasExcetoVogais = /[[a-z]--[aeiou]]/v;
console.log(letrasExcetoVogais.test('b')); // true
console.log(letrasExcetoVogais.test('a')); // false
// União de conjuntos
const alfanumericos = /[[a-z][0-9]]/v;
console.log(alfanumericos.test('5')); // true
console.log(alfanumericos.test('x')); // true
// Suporte melhorado a Unicode
const emoji = /\p{Emoji}/v;
console.log(emoji.test('🚀')); // trueTabela Resumo das Novidades
| Recurso | Descrição | Caso de Uso |
|---|---|---|
| Iterator Helpers | Métodos funcionais em iteradores | Processamento lazy de dados |
| Set Methods | União, interseção, diferença | Lógica de conjuntos |
| Promise.try() | Inicia chains uniformemente | Error handling |
| Float16Array | Array de floats 16-bit | ML, WebGL, games |
| JSON Modules | Import direto de JSON | Configurações, i18n |
| RegExp /v flag | Operações de conjunto em regex | Validações complexas |
Como Usar Hoje
A maioria dos navegadores modernos já suporta grande parte dessas funcionalidades. Para ambientes que ainda não suportam, você pode usar:
// Verificar suporte
if (typeof Iterator !== 'undefined') {
// Usar Iterator helpers nativos
} else {
// Fallback ou polyfill
}
// Ou usar polyfills
// npm install core-js
import 'core-js/actual/iterator';
import 'core-js/actual/set';Conclusão
O ECMAScript 2025 representa uma evolução significativa do JavaScript, trazendo recursos que a comunidade pediu por anos. Os Iterator helpers e os novos métodos de Set são particularmente impactantes para quem trabalha com manipulação de dados.
Se você quer se aprofundar em JavaScript moderno, recomendo que dê uma olhada em outro artigo: Descobrindo o Poder do Async/Await em JavaScript onde você vai descobrir como dominar programação assíncrona.