1. Utilice la desestructuración para intercambiar variables

let a = 1, b = 2;
[a, b] = [b, a];
console.log(a, b); // 2 1

Por qué: proporciona una forma clara y de una sola línea de intercambiar valores de variables sin una variable temporal.

2. Utilice literales de plantilla para la interpolación de cadenas

const name = "Alice";
console.log(`Hello, ${name}!`); // Hello, Alice!

Por qué: hace que la concatenación de cadenas sea más legible y menos propensa a errores que los métodos tradicionales.

3. Utilice el operador coalescente nulo (??) para los valores predeterminados

const value = null;
const defaultValue = value ?? "Default";
console.log(defaultValue); // "Default"

Por qué: proporciona una forma concisa de manejar valores nulos o indefinidos, distinguiéndolos de valores falsos como 0 o una cadena vacía.

4. Utilice encadenamiento opcional (?.) para acceder de forma segura a la propiedad

const obj = { nested: { property: "value" } };
console.log(obj?.nested?.property); // "value"
console.log(obj?.nonexistent?.property); // undefined

Por qué: evita errores al acceder a propiedades anidadas que podrían no existir, lo que reduce la necesidad de realizar comprobaciones detalladas.

5. Utilice el operador de extensión (...) para la manipulación de matrices

const arr1 = [1, 2, 3];
const arr2 = [4, 5, 6];
const combined = [...arr1, ...arr2];
console.log(combined); // [1, 2, 3, 4, 5, 6]

Por qué: simplifica las operaciones de matrices como combinar, copiar o agregar elementos, lo que hace que el código sea más conciso y legible.

6. Utilice Array.from() para crear matrices a partir de objetos similares a matrices

const arrayLike = { 0: "a", 1: "b", 2: "c", length: 3 };
const newArray = Array.from(arrayLike);
console.log(newArray); // ["a", "b", "c"]

Por qué: convierte fácilmente objetos similares a matrices o iterables en matrices verdaderas, lo que permite el uso de métodos de matriz.

7. Utilice Object.entries() para iterar objetos fácilmente

const obj = { a: 1, b: 2, c: 3 };
for (const [key, value] of Object.entries(obj)) {
  console.log(`${key}: ${value}`);
}

Por qué: proporciona una forma limpia de iterar sobre las claves y los valores de un objeto simultáneamente.

8. Utilice Array.prototype.flat() para aplanar matrices anidadas

const nestedArray = [1, [2, 3, [4, 5]]];
console.log(nestedArray.flat(2)); // [1, 2, 3, 4, 5]

Por qué: simplifica el trabajo con matrices anidadas aplanándolas a una profundidad específica.

9. Utilice async/await para obtener un código asincrónico más limpio

async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error('Error:', error);
  }
}

Por qué: hace que el código asíncrono se vea y se comporte más como código síncrono, lo que mejora la legibilidad y el manejo de errores.

10. Utilice Establecer para valores únicos en una matriz

const numbers = [1, 2, 2, 3, 4, 4, 5];
const uniqueNumbers = [...new Set(numbers)];
console.log(uniqueNumbers); // [1, 2, 3, 4, 5]

Por qué: proporciona una forma eficaz de eliminar duplicados de una matriz sin realizar bucles manuales.

11. Utilice Object.freeze() para crear objetos inmutables

const frozenObj = Object.freeze({ prop: 42 });
frozenObj.prop = 100; // Fails silently in non-strict mode
console.log(frozenObj.prop); // 42

Por qué: evita modificaciones en un objeto, lo que resulta útil para crear constantes o garantizar la integridad de los datos.

12. Utilice Array.prototype.reduce() para realizar potentes transformaciones de matrices

const numbers = [1, 2, 3, 4, 5];
const sum = numbers.reduce((acc, curr) => acc   curr, 0);
console.log(sum); // 15

Por qué: permite realizar operaciones complejas de matrices en una sola pasada, a menudo de manera más eficiente que los bucles.

13. Utilice el operador lógico AND (&&) para la ejecución condicional

const isTrue = true;
isTrue && console.log("This will be logged");

Por qué: proporciona una forma breve de ejecutar código solo si una condición es verdadera, sin una declaración if explícita.

14. Utilice Object.assign() para fusionar objetos

const obj1 = { a: 1, b: 2 };
const obj2 = { b: 3, c: 4 };
const merged = Object.assign({}, obj1, obj2);
console.log(merged); // { a: 1, b: 3, c: 4 }

Por qué: simplifica la combinación de objetos, lo que resulta útil para combinar objetos de configuración o crear copias de objetos con anulaciones.

15. Utilice Array.prototype.some() y Array.prototype.every() para array

checking
const numbers = [1, 2, 3, 4, 5];
console.log(numbers.some(n => n > 3)); // true
console.log(numbers.every(n => n > 0)); // true

Por qué: proporciona formas concisas de comprobar si alguno o todos los elementos de una matriz cumplen una condición, evitando bucles explícitos.

16. Utilice console.table() para un mejor registro de datos tabulares

const users = [
  { name: "John", age: 30 },
  { name: "Jane", age: 28 },
];
console.table(users);

Por qué: mejora la legibilidad de los datos registrados en formato tabular, especialmente útil para matrices de objetos.

17. Utilice Array.prototype.find() para obtener el primer elemento coincidente

const numbers = [1, 2, 3, 4, 5];
const found = numbers.find(n => n > 3);
console.log(found); // 4

Por qué: encuentra eficientemente el primer elemento de una matriz que satisface una condición y detiene la iteración una vez encontrado.

18. Utilice Object.keys(), Object.values() y Object.entries() para el objeto

manipulation
const obj = { a: 1, b: 2, c: 3 };
console.log(Object.keys(obj)); // ["a", "b", "c"]
console.log(Object.values(obj)); // [1, 2, 3]
console.log(Object.entries(obj)); // [["a", 1], ["b", 2], ["c", 3]]

Por qué: proporciona formas sencillas de extraer y trabajar con propiedades y valores de objetos, útiles para muchas operaciones de objetos.

19. Utilice la API Intl para la internacionalización

const number = 123456.789;
console.log(new Intl.NumberFormat('de-DE').format(number)); // 123.456,789

Por qué: simplifica el formato de números, fechas y cadenas de acuerdo con reglas específicas de la configuración regional sin implementación manual.

20. Utilice Array.prototype.flatMap() para mapear y aplanar en un solo paso

const sentences = ["Hello world", "How are you"];
const words = sentences.flatMap(sentence => sentence.split(" "));
console.log(words); // ["Hello", "world", "How", "are", "you"]

Por qué: combina operaciones de mapeo y aplanamiento de manera eficiente, lo que resulta útil para transformaciones que producen resultados anidados.