Jeff Bruchado
Voltar para o Blog

ES2026: As Novidades do JavaScript Que Vao Resolver Suas Maiores Dores de Cabeca

Olá HaWkers, o ECMAScript 2026 está chegando com features que muitos desenvolvedores JavaScript esperavam há anos. Finalmente teremos soluções nativas para problemas que causam dor de cabeça há décadas, como manipulação de datas e encadeamento de iteradores.

Vamos explorar as principais novidades que vão mudar como escrevemos JavaScript.

Iterator Sequencing: Finalmente Concat Para Iteradores

Uma das adições mais esperadas é o Iterator.concat, que resolve um problema antigo de forma elegante.

O Problema Atual

Hoje, encadear iteradores requer código verboso:

// Jeito atual: usando generators
function* concatenateIterators(...iterators) {
  for (const iterator of iterators) {
    yield* iterator;
  }
}

const iter1 = [1, 2, 3].values();
const iter2 = [4, 5, 6].values();
const iter3 = [7, 8, 9].values();

const combined = concatenateIterators(iter1, iter2, iter3);

for (const value of combined) {
  console.log(value); // 1, 2, 3, 4, 5, 6, 7, 8, 9
}

A Solução ES2026

Com Iterator.concat, o mesmo código fica muito mais simples:

// ES2026: Iterator.concat
const iter1 = [1, 2, 3].values();
const iter2 = [4, 5, 6].values();
const iter3 = [7, 8, 9].values();

const combined = Iterator.concat(iter1, iter2, iter3);

for (const value of combined) {
  console.log(value); // 1, 2, 3, 4, 5, 6, 7, 8, 9
}

Casos de Uso Práticos

O Iterator.concat é especialmente útil em:

// Processamento de múltiplas fontes de dados
async function* fetchPages(urls) {
  for (const url of urls) {
    const response = await fetch(url);
    const data = await response.json();
    yield* data.items;
  }
}

// Combinando dados de múltiplas APIs
const apiEndpoints = ['/api/users', '/api/admins', '/api/guests'];
const allUsers = Iterator.concat(
  ...apiEndpoints.map(endpoint => fetchPages([endpoint]))
);

// Lazy evaluation mantida
for await (const user of allUsers) {
  processUser(user);
}

Temporal API: O Fim do Pesadelo com Datas

A Temporal API é provavelmente a adição mais aguardada do ES2026, substituindo o problemático objeto Date.

Problemas do Date Atual

O objeto Date do JavaScript tem limitações conhecidas:

// Problemas comuns com Date

// 1. Meses começam em 0 (confuso)
const date = new Date(2026, 0, 15); // Janeiro, não Fevereiro!

// 2. Mutabilidade perigosa
const original = new Date();
const modified = original;
modified.setMonth(5); // original também foi modificado!

// 3. Timezones são um pesadelo
const date1 = new Date('2026-01-15'); // Interpretação varia por timezone

// 4. Parsing inconsistente
new Date('2026-1-15');  // Pode falhar em alguns browsers
new Date('01/15/2026'); // Formato ambíguo

Temporal: A Solução Definitiva

A Temporal API resolve todos esses problemas:

// ES2026: Temporal API

// PlainDate - data sem timezone
const date = Temporal.PlainDate.from('2026-01-15');
console.log(date.month); // 1 (Janeiro é 1, não 0!)

// Imutabilidade garantida
const original = Temporal.PlainDate.from('2026-01-15');
const modified = original.add({ months: 1 });
console.log(original.toString());  // 2026-01-15 (não mudou)
console.log(modified.toString());  // 2026-02-15

// PlainDateTime - data e hora sem timezone
const datetime = Temporal.PlainDateTime.from('2026-01-15T14:30:00');
console.log(datetime.hour); // 14

// ZonedDateTime - com timezone explícito
const zonedDate = Temporal.ZonedDateTime.from({
  timeZone: 'America/Sao_Paulo',
  year: 2026,
  month: 1,
  day: 15,
  hour: 14,
  minute: 30
});

Operações com Datas Simplificadas

Cálculos que antes eram complexos ficam triviais:

// Diferença entre datas
const start = Temporal.PlainDate.from('2026-01-01');
const end = Temporal.PlainDate.from('2026-12-31');

const duration = start.until(end);
console.log(duration.days); // 364

// Adicionar/subtrair períodos
const date = Temporal.PlainDate.from('2026-01-15');

const nextWeek = date.add({ weeks: 1 });
const lastMonth = date.subtract({ months: 1 });
const nextYear = date.add({ years: 1 });

// Comparações diretas
const date1 = Temporal.PlainDate.from('2026-01-15');
const date2 = Temporal.PlainDate.from('2026-02-15');

console.log(Temporal.PlainDate.compare(date1, date2)); // -1 (date1 < date2)
console.log(date1.equals(date2)); // false

Duration: Representando Períodos de Tempo

A Temporal API também introduz Duration para representar períodos:

// Criando durações
const duration = Temporal.Duration.from({
  years: 1,
  months: 2,
  weeks: 3,
  days: 4,
  hours: 5,
  minutes: 6,
  seconds: 7
});

// Parsing de strings ISO 8601
const parsedDuration = Temporal.Duration.from('P1Y2M3DT4H5M6S');

// Operações com durações
const d1 = Temporal.Duration.from({ hours: 2, minutes: 30 });
const d2 = Temporal.Duration.from({ hours: 1, minutes: 45 });

const total = d1.add(d2);
console.log(total.hours, total.minutes); // 4, 15

// Aplicar duração a uma data
const date = Temporal.PlainDate.from('2026-01-15');
const futureDate = date.add(duration);

Melhorias em Math

O ES2026 também traz novas funções matemáticas:

Math.sumPrecise

Para somas de arrays com precisão numérica:

// Problema atual: perda de precisão em somas
const numbers = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0];
const sumNormal = numbers.reduce((a, b) => a + b, 0);
console.log(sumNormal); // 5.499999999999999 (impreciso!)

// ES2026: Math.sumPrecise
const sumPrecise = Math.sumPrecise(numbers);
console.log(sumPrecise); // 5.5 (correto!)

Casos de Uso

Especialmente útil em:

// Cálculos financeiros
const transactions = [
  { amount: 10.99 },
  { amount: 25.50 },
  { amount: 8.75 },
  { amount: 100.00 }
];

// Antes: poderia ter imprecisão
const totalOld = transactions.reduce((sum, t) => sum + t.amount, 0);

// ES2026: precisão garantida
const totalNew = Math.sumPrecise(transactions.map(t => t.amount));

Import Attributes: Controle Sobre Imports

Refinamento na sintaxe de import attributes:

// Import de JSON com type assertion
import data from './config.json' with { type: 'json' };

// Import de CSS modules
import styles from './styles.css' with { type: 'css' };

// Import condicional por ambiente
import config from './config.js' with {
  type: 'json',
  integrity: 'sha384-abc123...'
};

RegExp: Novas Flags e Métodos

Melhorias em expressões regulares:

// Flag 'v' para Unicode sets
const emoji = /[\p{Emoji}--\p{ASCII}]/v;

// Intersection e subtraction em character classes
const greekNotAlpha = /[\p{Script=Greek}&&\p{Letter}]/v;

// Named capture groups melhorados
const dateRegex = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
const match = '2026-01-15'.match(dateRegex);
console.log(match.groups.year);  // '2026'
console.log(match.groups.month); // '01'
console.log(match.groups.day);   // '15'

Suporte Atual dos Browsers

Status de implementação das features:

Iterator.concat

Browser Status
Chrome Disponível (flag)
Firefox Disponível
Safari Disponível
Node.js v22+

Temporal API

Browser Status
Chrome Em desenvolvimento
Firefox Em desenvolvimento
Safari Em desenvolvimento
Node.js Polyfill disponível

Como Usar Hoje

Mesmo antes do suporte completo, você pode usar essas features:

Polyfills Disponíveis

// Para Temporal API
import { Temporal } from '@js-temporal/polyfill';

const date = Temporal.PlainDate.from('2026-01-15');

// Para Iterator helpers
import 'core-js/proposals/iterator-helpers';

const combined = Iterator.concat([1, 2].values(), [3, 4].values());

TypeScript Support

// tsconfig.json
{
  "compilerOptions": {
    "lib": ["ES2026", "DOM"],
    "target": "ES2022"
  }
}

// Tipos disponíveis
const date: Temporal.PlainDate = Temporal.PlainDate.from('2026-01-15');
const duration: Temporal.Duration = date.until(
  Temporal.PlainDate.from('2026-12-31')
);

Preparando Seu Código

Recomendações para migração gradual:

Estratégia de Migração

Fase 1: Instalar polyfills

  • Adicionar @js-temporal/polyfill
  • Configurar bundler para tree-shaking

Fase 2: Novos códigos com Temporal

  • Usar Temporal em código novo
  • Manter Date em código legado

Fase 3: Migração gradual

  • Refatorar código crítico primeiro
  • Adicionar testes de regressão
  • Remover polyfills quando browsers suportarem

Coexistência com Date

// Converter entre Date e Temporal
const jsDate = new Date('2026-01-15T14:30:00Z');

// Date para Temporal
const instant = Temporal.Instant.from(jsDate.toISOString());
const zonedDate = instant.toZonedDateTimeISO('America/Sao_Paulo');

// Temporal para Date
const temporal = Temporal.PlainDateTime.from('2026-01-15T14:30:00');
const backToDate = new Date(temporal.toString());

Se você quer se manter atualizado sobre as tendências do JavaScript, recomendo que dê uma olhada em outro artigo: n8n Domina JavaScript Rising Stars 2025 onde você vai descobrir a ferramenta que conquistou a comunidade.

Bora pra cima! 🦅

Comentários (0)

Esse artigo ainda não possui comentários 😢. Seja o primeiro! 🚀🦅

Adicionar comentário