Funciones que todo desarrollador de JavaScript debe conocer en 2025

• JavaScript sigue evolucionando en 2025, y algunas funciones, aunque no son muy conocidas, resultan muy útiles
• Los nuevos métodos helper de Iterator funcionan de forma mucho más eficiente en memoria al transformar grandes volúmenes de datos
• Acceso desde el final de un arreglo con at(), uso sencillo de Promise.withResolvers() y structuredClone() para copias profundas
• Las operaciones de conjuntos para Set, las funciones tag para template strings y el uso de WeakMap/WeakSet siguen siendo aspectos que muchos desarrolladores pasan por alto

Métodos helper de Iterator

• Encadenar como en arr.filter().map() es ineficiente porque crea un nuevo arreglo en cada paso
• Puede mejorarse con encadenamiento basado en iteradores, como arr.values().drop(10).take(10).map(...).toArray()
• Métodos principales:
  • drop(): omite los primeros n elementos
  • take(): toma solo los primeros n elementos
  • filter(), map(), flatMap(): funcionan de forma similar a los métodos de arreglos
  • reduce(), some(), every(), find(): permiten probar condiciones y hacer cálculos acumulados
  • toArray(): convierte al arreglo final
• Safari comenzó a soportarlos desde el 31 de marzo de 2025, pero todavía no todos los navegadores los admiten

Array at()

• arr.at(n) es similar a arr[n], pero permite indexación negativa para acceder desde atrás
• Ejemplo: [10, 20, 30].at(-1) → 30
• Permite acceder al último elemento sin recurrir a formas incómodas como arr[arr.length - 1]

Promise.withResolvers()

• Forma anterior: guardar resolve/reject por fuera en new Promise((resolve, reject) => { ... })
• Ahora: const { promise, resolve, reject } = Promise.withResolvers() permite un uso más conciso e intuitivo

Uso de callbacks en String.replace()

• El segundo argumento de replace() y replaceAll() no solo acepta strings, sino también funciones callback
• Ejemplo: "X, X, X".replaceAll("X", (match, i) => match + i) → "X0, X3, X6"
• Permite hacer varias sustituciones de una sola vez → eficiente en rendimiento y memoria

Intercambio de variables (Swap)

• Forma tradicional: usar una variable temp
• Forma concisa: intercambiar variables con destructuring de arreglos usando [a, b] = [b, a]

structuredClone()

• En lugar de JSON.stringify() + JSON.parse(), ofrece copias profundas más precisas y eficientes
• Ventajas:
  • también soporta NaN, undefined, bigint, etc.
  • copia de forma segura incluso referencias circulares
  • mayor eficiencia en memoria y velocidad con objetos grandes

Tagged Template Literals

• Permiten parsear template strings con una función específica
• Son útiles para posprocesar strings dinámicos, como el escape de HTML
• Ejemplo:
  la función tag escapeHtml convierte <br> ${'<br>'} en <br> <br>

WeakMap / WeakSet

• Son similares a Map y Set normales, pero:
  • solo permiten objetos como claves (no valores primitivos)
  • se eliminan automáticamente cuando pasan a ser objetivo del GC
• Son adecuados cuando puede haber referencias circulares o para guardar metadatos de objetos sin efectos secundarios

Soporte para operaciones de conjuntos en Set

En JavaScript se agregaron nuevas operaciones lógicas para el objeto Set:

• difference(): diferencia (A - B)
• intersection(): intersección (A ∩ B)
• union(): unión (A ∪ B)
• symmetricDifference(): diferencia simétrica (A △ B)
• isDisjointFrom(): si no hay elementos en común
• isSubsetOf(): si es subconjunto
• isSupersetOf(): si es superconjunto

[wfedev]

Parece que se resolvió el problema de que, al hacer parsing de literales, hasta las variables salían como cadenas. Gracias por compartirlo.

[pompapa]

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

El ejemplo está mal. i contiene la posición de la coincidencia.
Por lo tanto, el valor resultante es "X0, X3, X6".

[xguru]

Vaya, es verdad. La IA generó mal el ejemplo. Ya lo corregí. ¡Gracias por la observación tan aguda!

[click]

values se siente como algo parecido a la Java Stream API, así que lo comparé y, si el tamaño del array es pequeño, hacer filter sin values resulta más rápido. Como está basado en iteradores, mientras más chaining haya, también parece que el enfoque de pasar una vez por values puede volverse más rápido. Para el benchmark, pueden consultar https://jsperf.app/dixutu.