1. Verwenden Sie Destrukturierung zum Austauschen von Variablen

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

Warum: Bietet eine saubere, einzeilige Möglichkeit zum Austauschen von Variablenwerten ohne eine temporäre Variable.

2. Verwenden Sie Vorlagenliterale für die String-Interpolation

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

Warum: Macht die Zeichenfolgenverkettung besser lesbar und weniger fehleranfällig als herkömmliche Methoden.

3. Verwenden Sie den Null-Koaleszenzoperator (??) für Standardwerte

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

Warum: Bietet eine präzise Möglichkeit, mit Null- oder undefinierten Werten umzugehen und von falschen Werten wie 0 oder einer leeren Zeichenfolge zu unterscheiden.

4. Verwenden Sie optionale Verkettung (?.) für sicheren Zugriff auf Eigenschaften

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

Warum: Verhindert Fehler beim Zugriff auf verschachtelte Eigenschaften, die möglicherweise nicht vorhanden sind, wodurch die Notwendigkeit ausführlicher Prüfungen verringert wird.

5. Verwenden Sie den Spread-Operator (...) für die Array-Manipulation

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

Warum: Vereinfacht Array-Vorgänge wie das Kombinieren, Kopieren oder Hinzufügen von Elementen und macht den Code prägnanter und lesbarer.

6. Verwenden Sie Array.from(), um Arrays aus arrayähnlichen Objekten zu erstellen

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

Warum: Konvertiert Array-ähnliche Objekte oder Iterables problemlos in echte Arrays und ermöglicht so die Verwendung von Array-Methoden.

7. Verwenden Sie Object.entries() für eine einfache Objektiteration

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

Warum: Bietet eine saubere Möglichkeit, gleichzeitig über Schlüssel und Werte eines Objekts zu iterieren.

8. Verwenden Sie Array.prototype.flat(), um verschachtelte Arrays zu reduzieren

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

Warum: Vereinfacht die Arbeit mit verschachtelten Arrays, indem diese auf eine bestimmte Tiefe reduziert werden.

9. Verwenden Sie async/await für saubereren asynchronen Code

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);
  }
}

Warum: Asynchroner Code sieht und verhält sich eher wie synchroner Code und verbessert so die Lesbarkeit und Fehlerbehandlung.

10. Verwenden Sie Set für eindeutige Werte in einem Array

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

Warum: Bietet eine effiziente Möglichkeit, Duplikate aus einem Array ohne manuelle Schleife zu entfernen.

11. Verwenden Sie Object.freeze(), um unveränderliche Objekte zu erstellen

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

Warum: Verhindert Änderungen an einem Objekt, nützlich zum Erstellen von Konstanten oder zum Sicherstellen der Datenintegrität.

12. Verwenden Sie Array.prototype.reduce() für leistungsstarke Array-Transformationen

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

Warum: Ermöglicht die Ausführung komplexer Array-Operationen in einem einzigen Durchgang, oft effizienter als Schleifen.

13. Verwenden Sie den logischen UND-Operator (&&) für die bedingte Ausführung

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

Warum: Bietet eine kurze Möglichkeit, Code nur dann auszuführen, wenn eine Bedingung wahr ist, ohne eine explizite if-Anweisung.

14. Verwenden Sie Object.assign(), um Objekte zusammenzuführen

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 }

Warum: Vereinfacht das Zusammenführen von Objekten, nützlich zum Kombinieren von Konfigurationsobjekten oder zum Erstellen von Objektkopien mit Überschreibungen.

15. Verwenden Sie Array.prototype.some() und Array.prototype.every() für 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

Warum: Bietet präzise Möglichkeiten, um zu überprüfen, ob einige oder alle Elemente in einem Array eine Bedingung erfüllen, und vermeidet so explizite Schleifen.

16. Verwenden Sie console.table() für eine bessere Protokollierung von Tabellendaten

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

Warum: Verbessert die Lesbarkeit protokollierter Daten im Tabellenformat, besonders nützlich für Arrays von Objekten.

17. Verwenden Sie Array.prototype.find(), um das erste passende Element zu erhalten

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

Warum: Findet effizient das erste Element in einem Array, das eine Bedingung erfüllt, und stoppt die Iteration, sobald es gefunden wird.

18. Verwenden Sie Object.keys(), Object.values() und Object.entries() für object

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]]

Warum: Bietet einfache Möglichkeiten zum Extrahieren und Arbeiten mit Objekteigenschaften und -werten, nützlich für viele Objektoperationen.

19. Verwenden Sie die Intl API für die Internationalisierung

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

Warum: Vereinfacht die Formatierung von Zahlen, Datumsangaben und Zeichenfolgen gemäß gebietsschemaspezifischen Regeln ohne manuelle Implementierung.

20. Verwenden Sie Array.prototype.flatMap() zum Zuordnen und Reduzieren in einem Schritt

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

Warum: Kombiniert Zuordnungs- und Reduzierungsvorgänge effizient, nützlich für Transformationen, die verschachtelte Ergebnisse erzeugen.