Live Coding

Wie prüft man, ob ein JavaScript-Objekt leer ist?

Erklärung: Ein Objekt ist leer, wenn es keine eigenen aufzählbaren Eigenschaften besitzt. Wir können Object.keys(obj) verwenden, welches ein Array der eigenen aufzählbaren Eigenschaftsnamen eines gegebenen Objekts zurückgibt. Wenn die Länge dieses Arrays 0 ist, ist das Objekt leer.

function isEmpty(obj) {
  return Object.keys(obj).length === 0;
}

console.log(isEmpty({})); // true
console.log(isEmpty({ a: 1 })); // false

Schreiben Sie eine Funktion, die einen gegebenen String umkehrt.

Erklärung: Der einfachste Weg ist, den String in ein Array von Zeichen umzuwandeln, die integrierte reverse()-Methode für Arrays zu verwenden und dann die Zeichen wieder zu einem String zusammenzufügen.

function reverseString(str) {
  return str.split('').reverse().join('');
}

console.log(reverseString('hello')); // 'olleh'

Schreiben Sie eine Funktion, die prüft, ob ein gegebener String ein Palindrom ist.

Erklärung: Ein Palindrom ist ein Wort oder eine Phrase, die sich vorwärts und rückwärts gleich liest. Wir können dies prüfen, indem wir den String umkehren (ignorieren Sie Groß-/Kleinschreibung und nicht-alphanumerische Zeichen für eine robustere Prüfung, aber hier führen wir eine einfache Prüfung durch) und ihn mit dem Original vergleichen.

function isPalindrome(str) {
  const reversed = str.split('').reverse().join('');
  return str === reversed;
}

console.log(isPalindrome('racecar')); // true
console.log(isPalindrome('hello')); // false

Schreiben Sie eine Funktion, die die größte Zahl in einem Array von Zahlen findet.

Erklärung: Sie können das Array durchlaufen und die bisher gefundene größte Zahl verfolgen. Alternativ können Sie die Math.max()-Funktion zusammen mit dem Spread-Syntax (...) verwenden, um Array-Elemente als Argumente zu übergeben.

function findMaxNumber(arr) {
  if (arr.length === 0) return undefined; // Oder einen Fehler werfen
  return Math.max(...arr);
}

console.log(findMaxNumber([1, 5, 2, 9, 3])); // 9

Schreiben Sie ein Programm, das Zahlen von 1 bis n ausgibt. Aber für Vielfache von drei geben Sie 'Fizz' anstelle der Zahl aus und für Vielfache von fünf 'Buzz'. Für Zahlen, die Vielfache von drei und fünf sind, geben Sie 'FizzBuzz' aus.

Erklärung: Dieses klassische Problem testet grundlegende Schleifen- und Bedingungslogik. Sie müssen von 1 bis n iterieren und den Modulo-Operator (%) verwenden, um die Teilbarkeit durch 3 und 5 zu prüfen.

function fizzBuzz(n) {
  for (let i = 1; i <= n; i++) {
    if (i % 3 === 0 && i % 5 === 0) {
      console.log('FizzBuzz');
    } else if (i % 3 === 0) {
      console.log('Fizz');
    } else if (i % 5 === 0) {
      console.log('Buzz');
    } else {
      console.log(i);
    }
  }
}

fizzBuzz(15);

Schreiben Sie eine Funktion, die doppelte Elemente aus einem Array entfernt.

Erklärung: Eine moderne und prägnante Methode, dies zu erreichen, ist die Verwendung eines Set. Sets speichern nur eindeutige Werte. Sie können das Array in ein Set und dann wieder in ein Array umwandeln.

function removeDuplicates(arr) {
  return [...new Set(arr)];
}

console.log(removeDuplicates([1, 2, 2, 3, 4, 4, 5])); // [1, 2, 3, 4, 5]

Schreiben Sie eine Funktion, die prüft, ob zwei Strings Anagramme voneinander sind.

Erklärung: Anagramme sind Wörter, die durch Umordnen der Buchstaben eines anderen gebildet werden. Um dies zu prüfen, können wir die Strings bereinigen, sortieren und vergleichen. Das Bereinigen umfasst das Entfernen von nicht-alphanumerischen Zeichen und das Umwandeln in eine konsistente Groß-/Kleinschreibung.

function isAnagram(str1, str2) {
  const clean = (str) => str.replace(/[^a-z0-9]/gi, '').toLowerCase();
  const sorted = (str) => clean(str).split('').sort().join('');
  
  return sorted(str1) === sorted(str2);
}

console.log(isAnagram('listen', 'silent')); // true
console.log(isAnagram('hello', 'world')); // false

Schreiben Sie eine Funktion zur Berechnung der Fakultät einer nicht-negativen ganzen Zahl.

Erklärung: Die Fakultät (n!) einer Zahl ist das Produkt aller positiven ganzen Zahlen kleiner oder gleich n. Wir können dies iterativ berechnen, indem wir die Zahlen von 1 bis n multiplizieren.

function factorial(n) {
  if (n < 0) return undefined; // Fakultät ist für negative Zahlen nicht definiert
  if (n === 0) return 1;
  let result = 1;
  for (let i = 1; i <= n; i++) {
    result *= i;
  }
  return result;
}

console.log(factorial(5)); // 120

Schreiben Sie eine Funktion, die die Summe aller Zahlen in einem Array zurückgibt.

Erklärung: Sie können die reduce-Methode verwenden, die ideal zum Akkumulieren eines einzelnen Wertes aus einem Array ist. Sie nimmt eine Callback-Funktion und einen Anfangswert (0 für die Summation) entgegen.

function sumArray(arr) {
  return arr.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
}

console.log(sumArray([1, 2, 3, 4])); // 10

Schreiben Sie eine Funktion, die ein verschachteltes Array 'flachklopft'. Der Einfachheit halber wird nur eine Ebene der Verschachtelung angenommen.

Erklärung: Für eine einzelne Ebene der Verschachtelung können Sie Array.prototype.concat() mit dem Spread-Operator oder die flat()-Methode (ES2019) verwenden.

function flattenArray(arr) {
  // Verwendung von flat() (einfacher, wenn ES2019+ in Ordnung ist)
  // return arr.flat();

  // Verwendung von reduce und concat
  return arr.reduce((acc, val) => acc.concat(val), []);
}

console.log(flattenArray([1, [2, 3], 4, [5]])); // [1, 2, 3, 4, 5]

Schreiben Sie eine Funktion, die die Anzahl der Vokale (a, e, i, o, u) in einem gegebenen String zählt.

Erklärung: Durchlaufen Sie den String (ohne Berücksichtigung der Groß-/Kleinschreibung) und prüfen Sie, ob jedes Zeichen ein Vokal ist. Führen Sie einen Zähler.

function countVowels(str) {
  const vowels = 'aeiou';
  let count = 0;
  for (let char of str.toLowerCase()) {
    if (vowels.includes(char)) {
      count++;
    }
  }
  return count;
}

console.log(countVowels('Hello World')); // 3

Schreiben Sie eine Funktion, die einen Satz in Titel-Großschreibung umwandelt (der erste Buchstabe jedes Wortes wird großgeschrieben).

Erklärung: Teilen Sie den Satz in Wörter auf, durchlaufen Sie dann jedes Wort, machen Sie den ersten Buchstaben groß und den Rest klein. Fügen Sie schließlich die Wörter wieder zusammen.

function titleCase(str) {
  return str.toLowerCase().split(' ').map(word => {
    return word.charAt(0).toUpperCase() + word.slice(1);
  }).join(' ');
}

console.log(titleCase('i am a little tea pot')); // 'I Am A Little Tea Pot'

Gegeben ist ein Array von Ganzzahlen nums und eine Ganzzahl target. Geben Sie die Indizes der beiden Zahlen zurück, die sich zu target addieren.

Erklärung: Ein gängiger Ansatz ist die Verwendung einer Hash-Map (oder eines JavaScript-Objekts), um Zahlen und ihre Indizes während der Iteration zu speichern. Prüfen Sie für jede Zahl, ob target - aktuelle_zahl in der Map existiert.

function twoSum(nums, target) {
  const map = {};
  for (let i = 0; i < nums.length; i++) {
    const complement = target - nums[i];
    if (map[complement] !== undefined) {
      return [map[complement], i];
    }
    map[nums[i]] = i;
  }
  return []; // Oder null, oder Fehler werfen, wenn keine Lösung
}

console.log(twoSum([2, 7, 11, 15], 9)); // [0, 1]

Erstellen Sie eine Funktion, die eine Zählfunktion zurückgibt. Jedes Mal, wenn die zurückgegebene Funktion aufgerufen wird, soll sie einen Zähler erhöhen und zurückgeben.

Erklärung: Dies demonstriert Closures. Die innere Funktion hat Zugriff auf die Variable count des Scopes der äußeren Funktion, auch nachdem die äußere Funktion ihre Ausführung beendet hat.

function createCounter() {
  let count = 0;
  return function() {
    count++;
    return count;
  };
}

const counter1 = createCounter();
console.log(counter1()); // 1
console.log(counter1()); // 2
const counter2 = createCounter();
console.log(counter2()); // 1

Schreiben Sie eine Funktion, die den ersten nicht-wiederholenden Charakter in einem String findet.

Erklärung: Sie können eine Hash-Map verwenden, um die Zeichenhäufigkeiten zu zählen. Iterieren Sie zuerst durch den String, um die Häufigkeits-Map zu erstellen. Iterieren Sie dann erneut durch den String und geben Sie das erste Zeichen mit einer Häufigkeit von 1 zurück.

function firstNonRepeatingChar(str) {
  const charCount = {};
  for (const char of str) {
    charCount[char] = (charCount[char] || 0) + 1;
  }
  for (const char of str) {
    if (charCount[char] === 1) {
      return char;
    }
  }
  return null; // Oder ein Indikator, wenn sich alle wiederholen
}

console.log(firstNonRepeatingChar('aabbcdeeff')); // 'c'
console.log(firstNonRepeatingChar('swiss')); // 'w'

Schreiben Sie eine Funktion, die ein Array in Gruppen einer angegebenen Größe aufteilt.

Erklärung: Iterieren Sie durch das Array, nehmen Sie Scheiben der angegebenen Größe und fügen Sie diese in ein neues Array ein. Behandeln Sie den Fall, dass der letzte Chunk kleiner sein könnte.

function chunkArray(arr, size) {
  const chunked = [];
  let index = 0;
  while (index < arr.length) {
    chunked.push(arr.slice(index, index + size));
    index += size;
  }
  return chunked;
}

console.log(chunkArray([1, 2, 3, 4, 5, 6, 7], 3)); // [[1, 2, 3], [4, 5, 6], [7]]

Schreiben Sie eine Funktion, die bestimmt, ob eine gegebene Zahl eine Primzahl ist.

Erklärung: Eine Primzahl ist eine natürliche Zahl größer als 1, die keine positiven Teiler außer 1 und sich selbst hat. Iterieren Sie von 2 bis zur Quadratwurzel der Zahl und prüfen Sie auf Teilbarkeit. Behandeln Sie Randfälle wie 1 und 2.

function isPrime(num) {
  if (num <= 1) return false;
  if (num <= 3) return true;

  if (num % 2 === 0 || num % 3 === 0) return false;

  for (let i = 5; i * i <= num; i = i + 6) {
    if (num % i === 0 || num % (i + 2) === 0) return false;
  }

  return true;
}

console.log(isPrime(7)); // true
console.log(isPrime(10)); // false

Schreiben Sie eine Funktion, die das längste Wort in einem Satz findet.

Erklärung: Teilen Sie den String in ein Array von Wörtern auf. Iterieren Sie dann durch das Array und verfolgen Sie das bisher längste gefundene Wort (oder dessen Länge).

function findLongestWord(str) {
  const words = str.split(' ');
  let longestWord = '';
  for (const word of words) {
    // Wörter bei Bedarf bereinigen (z.B. Satzzeichen entfernen)
    if (word.length > longestWord.length) {
      longestWord = word;
    }
  }
  return longestWord;
}

console.log(findLongestWord('The quick brown fox jumped over the lazy dog')); // 'jumped'

Implementieren Sie Ihre eigene Version der Funktion Array.prototype.map.

Erklärung: Die map-Funktion nimmt einen Callback entgegen und erstellt ein neues Array, indem sie den Callback auf jedes Element des ursprünglichen Arrays anwendet. Ihre Funktion sollte das Array durchlaufen und das neue Array aufbauen.

function myMap(arr, callback) {
  const mappedArray = [];
  for (let i = 0; i < arr.length; i++) {
    mappedArray.push(callback(arr[i], i, arr));
  }
  return mappedArray;
}

const numbers = [1, 4, 9];
const roots = myMap(numbers, Math.sqrt);
console.log(roots); // [1, 2, 3]

Implementieren Sie Ihre eigene Version der Funktion Array.prototype.filter.

Erklärung: Die filter-Funktion nimmt einen Callback entgegen und erstellt ein neues Array mit allen Elementen, die den vom bereitgestellten Callback implementierten Test bestehen.

function myFilter(arr, callback) {
  const filteredArray = [];
  for (let i = 0; i < arr.length; i++) {
    if (callback(arr[i], i, arr)) {
        filteredArray.push(arr[i]);
    }
  }
  return filteredArray;
}

const words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];
const result = myFilter(words, word => word.length > 6);
console.log(result); // ['exuberant', 'destruction', 'present']

Implementieren Sie Ihre eigene Version der Funktion Array.prototype.reduce.

Erklärung: Die reduce-Funktion führt eine vom Benutzer bereitgestellte 'Reducer'-Callback-Funktion auf jedem Element des Arrays aus und übergibt den Rückgabewert der Berechnung des vorhergehenden Elements. Das Endergebnis der Ausführung des Reducers über alle Elemente des Arrays ist ein einzelner Wert. Behandeln Sie das Argument für den Anfangswert.

function myReduce(arr, callback, initialValue) {
  let accumulator = initialValue;
  let startIndex = 0;

  if (initialValue === undefined) {
      if (arr.length === 0) throw new TypeError('Reduce of empty array with no initial value');
      accumulator = arr[0];
      startIndex = 1;
  }

  for (let i = startIndex; i < arr.length; i++) {
    accumulator = callback(accumulator, arr[i], i, arr);
  }
  return accumulator;
}

const array1 = [1, 2, 3, 4];
const sum = myReduce(array1, (acc, curr) => acc + curr, 0);
console.log(sum); // 10

Implementieren Sie eine Fibonacci-Funktion unter Verwendung von Memoization zur Leistungsoptimierung.

Erklärung: Die Fibonacci-Sequenz beinhaltet wiederholte Berechnungen. Memoization speichert die Ergebnisse teurer Funktionsaufrufe und gibt das zwischengespeicherte Ergebnis zurück, wenn dieselben Eingaben erneut auftreten.

function memoizedFib() {
  const cache = {};

  function fib(n) {
    if (n in cache) {
      return cache[n];
    }
    if (n <= 1) {
      return n;
    }
    const result = fib(n - 1) + fib(n - 2);
    cache[n] = result;
    return result;
  }
  return fib;
}

const fibonacci = memoizedFib();
console.log(fibonacci(10)); // 55
console.log(fibonacci(40)); // 102334155 (viel schneller als nicht-memoisiert)

Schreiben Sie eine Funktion, die prüft, ob ein String, der Klammern {}[]() enthält, ausgewogen ist.

Erklärung: Verwenden Sie einen Stack. Wenn Sie eine öffnende Klammer finden, legen Sie sie auf den Stack. Wenn Sie eine schließende Klammer finden, prüfen Sie, ob der Stack leer ist oder ob das oberste Element die passende öffnende Klammer ist. Wenn es übereinstimmt, nehmen Sie es vom Stack. Wenn nicht, oder wenn der Stack leer ist, ist es unausgewogen. Am Ende bedeutet ein leerer Stack ausgewogen.

function isBalanced(str) {
  const stack = [];
  const map = { '(': ')', '{': '}', '[': ']' };

  for (let char of str) {
    if (map[char]) {
      stack.push(char);
    } else if (Object.values(map).includes(char)) {
      if (stack.length === 0) return false;
      const lastOpen = stack.pop();
      if (map[lastOpen] !== char) return false;
    }
  }
  return stack.length === 0;
}

console.log(isBalanced('({[]})')); // true
console.log(isBalanced('([)]')); // false

Implementieren Sie eine Warteschlange-Datenstruktur mit den Methoden enqueue (hinten hinzufügen) und dequeue (vorne entfernen).

Erklärung: Eine Warteschlange folgt dem First-In, First-Out (FIFO)-Prinzip. Ein Array kann verwendet werden, wobei push für enqueue und shift für dequeue dient.

class Queue {
  constructor() {
    this.items = [];
  }

  enqueue(element) {
    this.items.push(element);
  }

  dequeue() {
    if (this.isEmpty()) return 'Underflow';
    return this.items.shift();
  }

  front() {
    if (this.isEmpty()) return 'No elements in Queue';
    return this.items[0];
  }

  isEmpty() {
    return this.items.length === 0;
  }
}

const q = new Queue();
q.enqueue(10);
q.enqueue(20);
console.log(q.dequeue()); // 10
console.log(q.front()); // 20

Implementieren Sie eine Stack-Datenstruktur mit den Methoden push (oben hinzufügen) und pop (oben entfernen).

Erklärung: Ein Stack folgt dem Last-In, First-Out (LIFO)-Prinzip. Ein Array kann verwendet werden, mit den Methoden push und pop.

class Stack {
  constructor() {
    this.items = [];
  }

  push(element) {
    this.items.push(element);
  }

  pop() {
    if (this.isEmpty()) return 'Underflow';
    return this.items.pop();
  }

  peek() {
    return this.items[this.items.length - 1];
  }

  isEmpty() {
    return this.items.length === 0;
  }
}

const s = new Stack();
s.push(10);
s.push(20);
console.log(s.pop()); // 20
console.log(s.peek()); // 10

Gegeben ist ein Array, das n verschiedene Zahlen aus 0, 1, 2, ..., n enthält. Finden Sie die Zahl, die im Array fehlt.

Erklärung: Die Summe der Zahlen von 0 bis n kann mit der Formel n*(n+1)/2 berechnet werden. Die tatsächliche Summe der Array-Elemente kann berechnet werden. Die Differenz zwischen diesen beiden Summen ist die fehlende Zahl.

function findMissingNumber(nums) {
  const n = nums.length;
  const expectedSum = n * (n + 1) / 2;
  const actualSum = nums.reduce((sum, num) => sum + num, 0);
  return expectedSum - actualSum;
}

console.log(findMissingNumber([3, 0, 1])); // 2
console.log(findMissingNumber([9, 6, 4, 2, 3, 5, 7, 0, 1])); // 8

Implementieren Sie eine Debounce-Funktion. Debouncing stellt sicher, dass eine Funktion erst wieder aufgerufen wird, nachdem eine bestimmte Zeit verstrichen ist, ohne dass sie aufgerufen wurde.

Erklärung: Verwenden Sie setTimeout und clearTimeout. Jedes Mal, wenn die Debounce-Funktion aufgerufen wird, löschen Sie den vorherigen Timeout und setzen einen neuen. Der tatsächliche Funktionsaufruf erfolgt erst, wenn der Timeout abgeschlossen ist.

function debounce(func, delay) {
  let timeoutId;
  return function(...args) {
    clearTimeout(timeoutId);
    timeoutId = setTimeout(() => {
      func.apply(this, args);
    }, delay);
  };
}

// Beispielverwendung:
const sayHello = () => console.log('Hello!');
const debouncedHello = debounce(sayHello, 1000);
debouncedHello(); // Aufruf nach 1 Sek. (wenn nicht erneut aufgerufen)
debouncedHello(); // Setzt Timer zurück
debouncedHello(); // Setzt Timer zurück, wird tatsächlich 1 Sek. nach diesem Aufruf ausgeführt.

Implementieren Sie eine Throttle-Funktion. Throttling stellt sicher, dass eine Funktion höchstens einmal in einem bestimmten Zeitintervall aufgerufen wird.

Erklärung: Verwenden Sie ein Flag, um anzuzeigen, ob ein Aufruf erlaubt ist. Wenn aufgerufen, falls erlaubt, führen Sie die Funktion aus, setzen Sie das Flag auf false und verwenden Sie setTimeout, um das Flag nach dem Intervall zurückzusetzen.

function throttle(func, limit) {
  let inThrottle = false;
  return function(...args) {
    if (!inThrottle) {
      func.apply(this, args);
      inThrottle = true;
      setTimeout(() => inThrottle = false, limit);
    }
  };
}

// Beispielverwendung:
const logScroll = () => console.log('Scrolling...');
const throttledScroll = throttle(logScroll, 1000);
// window.addEventListener('scroll', throttledScroll); // Wird höchstens einmal pro Sekunde protokolliert.

Schreiben Sie eine Funktion, die eine Funktion mit zwei Argumenten nimmt und eine Curried-Version davon zurückgibt.

Erklärung: Currying transformiert eine Funktion mit mehreren Argumenten in eine Sequenz von Funktionen, die jeweils ein einzelnes Argument nehmen. f(a, b) wird zu f(a)(b).

function curry(fn) {
  return function(a) {
    return function(b) {
      return fn(a, b);
    };
  };
}

function add(a, b) {
  return a + b;
}

const curriedAdd = curry(add);
const add5 = curriedAdd(5);
console.log(add5(3)); // 8
console.log(curriedAdd(10)(20)); // 30

Schreiben Sie eine Funktion, die eine tiefe Klonierung eines JavaScript-Objekts durchführt.

Erklärung: Ein flacher Klon kopiert nur die Eigenschaften der obersten Ebene. Ein tiefer Klon kopiert rekursiv alle Eigenschaften, einschließlich verschachtelter Objekte und Arrays. Eine einfache Methode (mit Einschränkungen, z.B. behandelt keine Funktionen, Daten, Regex gut) ist die Verwendung von JSON.parse(JSON.stringify(obj)). Ein rekursiver Ansatz ist robuster.

function deepClone(obj) {
  // Einfache Version (mit Einschränkungen)
  try {
      return JSON.parse(JSON.stringify(obj));
  } catch (e) {
      console.error("Klonen fehlgeschlagen:", e);
      return null;
  }
  
  // Robustere rekursive (Basispiel):
  /*
  if (obj === null || typeof obj !== 'object') {
      return obj;
  }
  let clone = Array.isArray(obj) ? [] : {};
  for (let key in obj) {
      if (Object.prototype.hasOwnProperty.call(obj, key)) {
          clone[key] = deepClone(obj[key]);
      }
  }
  return clone;
  */
}

const original = { a: 1, b: { c: 2 } };
const cloned = deepClone(original);
cloned.b.c = 3;
console.log(original.b.c); // 2 (beweist, dass es ein tiefer Klon ist)
console.log(cloned.b.c); // 3

Wie erhält man ein Array von Schlüsseln aus einem Objekt?

Erklärung: Verwenden Sie Object.keys(obj).

function getKeys(obj) {
  return Object.keys(obj);
}
console.log(getKeys({a: 1, b: 2})); // ['a', 'b']

Wie erhält man ein Array von Werten aus einem Objekt?

Erklärung: Verwenden Sie Object.values(obj).

function getValues(obj) {
  return Object.values(obj);
}
console.log(getValues({a: 1, b: 2})); // [1, 2]

Wie prüft man, ob ein Array einen bestimmten Wert enthält?

Erklärung: Verwenden Sie Array.prototype.includes(value).

function checkIncludes(arr, val) {
  return arr.includes(val);
}
console.log(checkIncludes([1, 2, 3], 2)); // true

Wie führt man zwei Arrays zu einem zusammen?

Erklärung: Verwenden Sie den Spread-Syntax (...) oder Array.prototype.concat().

function mergeArrays(arr1, arr2) {
  return [...arr1, ...arr2];
}
console.log(mergeArrays([1, 2], [3, 4])); // [1, 2, 3, 4]

Worauf bezieht sich this im globalen Geltungsbereich in einem Browser?

Erklärung: Im globalen Ausführungskontext (außerhalb jeder Funktion) bezieht sich this auf das globale Objekt, welches in Webbrowsern window ist.

console.log(this === window); // true (in einer Browserumgebung)

Worauf bezieht sich this, wenn es innerhalb einer Objektmethode verwendet wird?

Erklärung: Wenn eine Funktion als Methode eines Objekts aufgerufen wird, bezieht sich this auf das Objekt, für das die Methode aufgerufen wird.

const myObject = {
  prop: 'Hello',
  greet() {
    return this.prop;
  }
};
console.log(myObject.greet()); // 'Hello'

Wie handhaben Arrow-Funktionen this?

Erklärung: Arrow-Funktionen haben keinen eigenen this-Kontext. Stattdessen erben sie this aus dem umgebenden (lexikalischen) Geltungsbereich, in dem sie definiert sind.

function MyClass() {
  this.value = 42;
  setTimeout(() => {
    console.log(this.value); // Gibt 42 aus, weil 'this' geerbt wird
  }, 100);
}
new MyClass();

Was sind die Hauptunterschiede zwischen let, const und var?

Erklärung: var ist funktionsgebunden und wird 'gehoben' (hoisted). let und const sind blockgebunden und werden ebenfalls 'gehoben', befinden sich aber bis zur Deklaration in einer 'temporal dead zone'. const muss initialisiert werden und kann nicht neu zugewiesen werden.

function scopeTest() {
  var a = 1;
  let b = 2;
  const c = 3;
  if (true) {
    var a = 10; // Neu deklariert und beeinflusst das äußere 'a'
    let b = 20; // Neues 'b' innerhalb des Blocks
    // const c = 30; // Wäre ein neues 'c'
    console.log(a, b, c); // 10, 20, 3
  }
  console.log(a, b, c); // 10, 2, 3
}
scopeTest();

Erklären Sie, was ein Promise in JavaScript ist.

Erklärung: Ein Promise ist ein Objekt, das die eventuelle Vollendung (oder das Scheitern) einer asynchronen Operation und ihren Ergebniswert darstellt. Es kann sich in einem von drei Zuständen befinden: ausstehend (pending), erfüllt (fulfilled) oder abgelehnt (rejected).

const myPromise = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve('Success!');
    // reject('Error!');
  }, 1000);
});

myPromise
  .then(result => console.log(result))
  .catch(error => console.error(error));

Wie vereinfachen async und await die Arbeit mit Promises?

Erklärung: async/await bietet syntaktischen Zucker über Promises, wodurch asynchroner Code ein wenig mehr wie synchroner Code aussieht und sich verhält. Eine async-Funktion gibt immer ein Promise zurück, und await pausiert die Ausführung, bis ein Promise sich entschieden hat.

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function run() {
  console.log('Starting...');
  await delay(1000);
  console.log('Waited 1 second.');
  await delay(500);
  console.log('Waited another 0.5 seconds.');
  return 'Finished!';
}

run().then(console.log);

Wie wandelt man einen String in eine Zahl um?

Erklärung: Verwenden Sie parseInt(), parseFloat() oder den unären Plusoperator (+).

const str = '123.45';
console.log(parseInt(str)); // 123
console.log(parseFloat(str)); // 123.45
console.log(+str); // 123.45

Wie wandelt man eine Zahl in einen String um?

Erklärung: Verwenden Sie String(), number.toString() oder String-Konkatenation.

const num = 123;
console.log(String(num)); // '123'
console.log(num.toString()); // '123'
console.log('' + num); // '123'

Was macht JSON.stringify?

Erklärung: Es konvertiert ein JavaScript-Objekt oder einen Wert in einen JSON-String.

const obj = { name: 'Alice', age: 30 };
const jsonString = JSON.stringify(obj);
console.log(jsonString); // '{"name":"Alice","age":30}'

Was macht JSON.parse?

Erklärung: Es parst einen JSON-String und konstruiert den JavaScript-Wert oder das Objekt, das durch den String beschrieben wird.

const jsonString = '{"name":"Alice","age":30}';
const obj = JSON.parse(jsonString);
console.log(obj.name); // 'Alice'

Wie wird der Spread-Operator mit Arrays verwendet?

Erklärung: Er ermöglicht es, ein iterierbares Objekt (wie ein Array) an Stellen zu erweitern, an denen null oder mehr Argumente oder Elemente erwartet werden. Nützlich zum Kopieren, Zusammenführen und Hinzufügen von Elementen.

const arr1 = [1, 2];
const arr2 = [3, 4];
const combined = [...arr1, ...arr2]; // [1, 2, 3, 4]
const copy = [...arr1]; // [1, 2]

Wie wird der Spread-Operator mit Objekten verwendet?

Erklärung: Er ermöglicht das Kopieren und Zusammenführen von Objekteigenschaften.

const obj1 = { a: 1, b: 2 };
const obj2 = { b: 3, c: 4 };
const merged = { ...obj1, ...obj2 }; // { a: 1, b: 3, c: 4 }
const copy = { ...obj1 }; // { a: 1, b: 2 }

Erklären Sie Array-Destrukturierung mit einem Beispiel.

Erklärung: Es ist eine Syntax, die es ermöglicht, Werte aus Arrays in einzelne Variablen zu entpacken.

const [a, b] = [10, 20];
console.log(a); // 10
console.log(b); // 20

const [x, , z] = [1, 2, 3];
console.log(z); // 3

Erklären Sie Objekt-Destrukturierung mit einem Beispiel.

Erklärung: Es ermöglicht, Eigenschaften von Objekten in einzelne Variablen zu entpacken.

const person = { name: 'Bob', age: 25 };
const { name, age } = person;
console.log(name); // 'Bob'
console.log(age); // 25

const { name: personName } = person;
console.log(personName); // 'Bob'

Wie könnten Sie eine grundlegende Version von Function.prototype.call implementieren?

Erklärung: call ruft eine Funktion mit einem angegebenen this-Wert und einzeln bereitgestellten Argumenten auf. Sie können die Funktion an den this-Kontext anhängen, sie aufrufen und dann wieder entfernen.

Function.prototype.myCall = function(context, ...args) {
  context = context || window;
  const uniqueId = Symbol(); // Verwenden Sie einen eindeutigen Schlüssel
  context[uniqueId] = this;
  const result = context[uniqueId](...args);
  delete context[uniqueId];
  return result;
}

function greet(greeting, punctuation) {
  console.log(`${greeting}, ${this.name}${punctuation}`);
}

greet.myCall({ name: 'Charlie' }, 'Hi', '!'); // Hi, Charlie!

Wie könnten Sie eine grundlegende Version von Function.prototype.apply implementieren?

Erklärung: apply ähnelt call, akzeptiert aber Argumente als Array.

Function.prototype.myApply = function(context, argsArray) {
  context = context || window;
  const uniqueId = Symbol();
  context[uniqueId] = this;
  const result = context[uniqueId](...(argsArray || []));
  delete context[uniqueId];
  return result;
}

function greet(greeting, punctuation) {
  console.log(`${greeting}, ${this.name}${punctuation}`);
}

greet.myApply({ name: 'David' }, ['Hello', '.']); // Hello, David.

Erklären Sie kurz den JavaScript Event Loop.

Erklärung: JavaScript ist Single-Threaded, erreicht aber Konkurrenz durch die Verwendung eines Event Loops. Der Call Stack verarbeitet synchronen Code. Web APIs verarbeiten asynchrone Operationen (wie setTimeout, fetch). Wenn eine asynchrone Operation abgeschlossen ist, wird ihr Callback in die Callback-Queue (oder Microtask-Queue für Promises) verschoben. Der Event Loop prüft ständig, ob der Call Stack leer ist; wenn ja, verschiebt er den nächsten Callback aus der Queue in den Stack zur Ausführung.

console.log('Start');

setTimeout(() => {
  console.log('Timeout Callback'); // Geht in die Callback-Queue
}, 0);

Promise.resolve().then(() => {
  console.log('Promise Resolved'); // Geht in die Microtask-Queue
});

console.log('End');

// Ausgabereihenfolge: Start, End, Promise Resolved, Timeout Callback
// (Microtasks laufen vor Macrotasks/Callbacks)

Implementieren Sie eine binäre Suchfunktion für ein sortiertes Array.

Erklärung: Die binäre Suche findet ein Element in einem sortierten Array effizient, indem sie das Suchintervall wiederholt halbiert. Wenn der Wert des Suchschlüssels kleiner ist als das Element in der Mitte des Intervalls, wird das Intervall auf die untere Hälfte eingeengt. Andernfalls wird es auf die obere Hälfte eingeengt. Dies geschieht, bis der Wert gefunden ist oder das Intervall leer ist.

function binarySearch(sortedArray, key) {
  let start = 0;
  let end = sortedArray.length - 1;

  while (start <= end) {
    let middle = Math.floor((start + end) / 2);

    if (sortedArray[middle] === key) {
      return middle; // Gefunden
    } else if (sortedArray[middle] < key) {
      start = middle + 1; // Rechte Hälfte durchsuchen
    } else {
      end = middle - 1; // Linke Hälfte durchsuchen
    }
  }
  return -1; // Nicht gefunden
}

console.log(binarySearch([1, 3, 5, 7, 9, 11], 7)); // 3
console.log(binarySearch([1, 3, 5, 7, 9, 11], 2)); // -1

Implementieren Sie den Merge Sort Algorithmus.

Erklärung: Merge Sort ist ein Divide-and-Conquer-Algorithmus. Er teilt das Eingabearray in zwei Hälften, ruft sich selbst für die beiden Hälften auf und führt dann die beiden sortierten Hälften zusammen. Die Merge-Funktion ist entscheidend; sie kombiniert zwei sortierte Teil-Arrays zu einem sortierten Array.

function mergeSort(arr) {
  if (arr.length <= 1) return arr;

  const mid = Math.floor(arr.length / 2);
  const left = mergeSort(arr.slice(0, mid));
  const right = mergeSort(arr.slice(mid));

  return merge(left, right);
}

function merge(left, right) {
  let result = [];
  let leftIndex = 0;
  let rightIndex = 0;

  while (leftIndex < left.length && rightIndex < right.length) {
    if (left[leftIndex] < right[rightIndex]) {
      result.push(left[leftIndex]);
      leftIndex++;
    } else {
      result.push(right[rightIndex]);
      rightIndex++;
    }
  }

  return result.concat(left.slice(leftIndex)).concat(right.slice(rightIndex));
}

console.log(mergeSort([38, 27, 43, 3, 9, 82, 10])); // [3, 9, 10, 27, 38, 43, 82]

Implementieren Sie den Quick Sort Algorithmus.

Erklärung: Quick Sort ist ebenfalls ein Divide-and-Conquer-Algorithmus. Er wählt ein Element als Pivot und partitioniert das gegebene Array um den gewählten Pivot. Elemente, die kleiner als der Pivot sind, gehen nach links, und Elemente, die größer sind, gehen nach rechts. Anschließend werden die Teil-Arrays rekursiv sortiert.

function quickSort(arr) {
  if (arr.length <= 1) return arr;

  const pivot = arr[arr.length - 1];
  const left = [];
  const right = [];

  for (let i = 0; i < arr.length - 1; i++) {
    if (arr[i] < pivot) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }

  return [...quickSort(left), pivot, ...quickSort(right)];
}

console.log(quickSort([10, 8, 2, 1, 6, 3, 9, 4, 7, 5])); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Implementieren Sie den Bubble Sort Algorithmus.

Erklärung: Bubble Sort ist ein einfacher Sortieralgorithmus, der wiederholt die Liste durchläuft, benachbarte Elemente vergleicht und sie vertauscht, wenn sie in der falschen Reihenfolge sind. Der Durchlauf durch die Liste wird wiederholt, bis die Liste sortiert ist.

function bubbleSort(arr) {
  let n = arr.length;
  let swapped;
  do {
    swapped = false;
    for (let i = 0; i < n - 1; i++) {
      if (arr[i] > arr[i + 1]) {
        [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]]; // Vertauschen
        swapped = true;
      }
    }
    n--; // Optimierung: letztes Element ist bereits an Ort und Stelle
  } while (swapped);
  return arr;
}

console.log(bubbleSort([64, 34, 25, 12, 22, 11, 90])); // [11, 12, 22, 25, 34, 64, 90]

Gegeben ist ein String. Finden Sie die Länge der längsten Unterzeichenkette ohne sich wiederholende Zeichen.

Erklärung: Verwenden Sie die 'Sliding Window'-Technik. Verwalten Sie ein Fenster (Unterzeichenkette) und einen Satz von Zeichen in diesem Fenster. Erweitern Sie das Fenster, indem Sie den rechten Zeiger bewegen. Wenn ein sich wiederholendes Zeichen gefunden wird, verkleinern Sie das Fenster von links, bis das sich wiederholende Zeichen entfernt ist.

function lengthOfLongestSubstring(s) {
  let maxLength = 0;
  let start = 0;
  const charMap = {};

  for (let end = 0; end < s.length; end++) {
    const char = s[end];
    if (charMap[char] >= start) {
        start = charMap[char] + 1;
    }
    charMap[char] = end;
    maxLength = Math.max(maxLength, end - start + 1);
  }
  return maxLength;
}

console.log(lengthOfLongestSubstring('abcabcbb')); // 3 ('abc')
console.log(lengthOfLongestSubstring('bbbbb')); // 1 ('b')
console.log(lengthOfLongestSubstring('pwwkew')); // 3 ('wke')

Implementieren Sie eine einfach verkettete Liste mit add- und print-Methoden.

Erklärung: Eine verkettete Liste ist eine lineare Datenstruktur, bei der Elemente nicht an zusammenhängenden Speicheradressen gespeichert werden. Jedes Element (Knoten) zeigt auf das nächste. Sie benötigen eine Node-Klasse und eine LinkedList-Klasse, um den Kopf und das Hinzufügen neuer Knoten zu verwalten.

class Node {
  constructor(data, next = null) {
    this.data = data;
    this.next = next;
  }
}

class LinkedList {
  constructor() {
    this.head = null;
  }

  add(data) {
    const newNode = new Node(data);
    if (!this.head) {
      this.head = newNode;
    } else {
      let current = this.head;
      while (current.next) {
        current = current.next;
      }
      current.next = newNode;
    }
  }

  print() {
    let current = this.head;
    let list = '';
    while (current) {
      list += current.data + ' -> ';
      current = current.next;
    }
    console.log(list + 'null');
  }
}

const list = new LinkedList();
list.add(10);
list.add(20);
list.add(30);
list.print(); // 10 -> 20 -> 30 -> null

Implementieren Sie einen Binären Suchbaum mit insert- und find-Methoden.

Erklärung: Ein BST ist eine knotenbasierte binäre Baumdatenstruktur, die folgende Eigenschaften hat: Der linke Unterbaum eines Knotens enthält nur Knoten mit Schlüsseln, die kleiner sind als der Schlüssel des Knotens. Der rechte Unterbaum eines Knotens enthält nur Knoten mit Schlüsseln, die größer sind als der Schlüssel des Knotens. Beide Unterbäume müssen ebenfalls binäre Suchbäume sein.

class Node {
  constructor(data) {
    this.data = data;
    this.left = null;
    this.right = null;
  }
}

class BST {
  constructor() {
    this.root = null;
  }

  insert(data) {
    const newNode = new Node(data);
    if (!this.root) {
      this.root = newNode;
      return;
    }
    this._insertNode(this.root, newNode);
  }

  _insertNode(node, newNode) {
    if (newNode.data < node.data) {
      if (!node.left) node.left = newNode;
      else this._insertNode(node.left, newNode);
    } else {
      if (!node.right) node.right = newNode;
      else this._insertNode(node.right, newNode);
    }
  }

  find(data) {
    return this._findNode(this.root, data);
  }

  _findNode(node, data) {
    if (!node) return null;
    if (data < node.data) return this._findNode(node.left, data);
    else if (data > node.data) return this._findNode(node.right, data);
    else return node;
  }
}

const bst = new BST();
bst.insert(10);
bst.insert(5);
bst.insert(15);
bst.insert(7);
console.log(bst.find(7)); // Node { data: 7, left: null, right: null }
console.log(bst.find(12)); // null

Schreiben Sie eine Funktion, die ein Array um k Schritte nach rechts rotiert.

Erklärung: Das Rotieren eines Arrays bedeutet, seine Elemente zu verschieben. Bei einer Rechtsrotation wird das letzte Element zum ersten. Dies k-mal zu wiederholen, funktioniert, ist aber ineffizient. Eine bessere Methode ist die Verwendung von Array-Manipulationen oder die Berechnung der neuen Positionen.

function rotateArray(nums, k) {
  k = k % nums.length; // Behandelt Fälle, in denen k > Länge
  if (k === 0) return nums;

  const partToMove = nums.splice(nums.length - k);
  nums.unshift(...partToMove);
  return nums;
}

console.log(rotateArray([1, 2, 3, 4, 5, 6, 7], 3)); // [5, 6, 7, 1, 2, 3, 4]

Gegeben sind zwei Arrays. Schreiben Sie eine Funktion, die deren Schnittmenge (Elemente, die beiden gemeinsam sind) berechnet.

Erklärung: Ein guter Ansatz ist es, ein Array in ein Set zu konvertieren, um O(1) durchschnittliche Suchzeiten zu erzielen. Dann iterieren Sie durch das zweite Array und prüfen, ob jedes Element im Set existiert. Sammeln Sie die Übereinstimmungen.

function intersection(nums1, nums2) {
  const set1 = new Set(nums1);
  const resultSet = new Set();

  for (const num of nums2) {
    if (set1.has(num)) {
      resultSet.add(num);
    }
  }

  return [...resultSet];
}

console.log(intersection([1, 2, 2, 1], [2, 2])); // [2]
console.log(intersection([4, 9, 5], [9, 4, 9, 8, 4])); // [9, 4]

Gegeben ist ein Array von Strings. Gruppieren Sie Anagramme zusammen.

Erklärung: Der Schlüssel ist, eine eindeutige Signatur für jede Gruppe von Anagrammen zu finden. Eine gängige Methode ist, jedes Wort alphabetisch zu sortieren. Wörter, die denselben sortierten String ergeben, sind Anagramme. Verwenden Sie eine Hash-Map, bei der die Schlüssel sortierte Wörter und die Werte Arrays von Originalwörtern sind.

function groupAnagrams(strs) {
  const map = {};
  for (const str of strs) {
    const sortedStr = str.split('').sort().join('');
    if (!map[sortedStr]) {
      map[sortedStr] = [];
    }
    map[sortedStr].push(str);
  }
  return Object.values(map);
}

console.log(groupAnagrams(['eat', 'tea', 'tan', 'ate', 'nat', 'bat'])); 
// Ausgabe: [['eat', 'tea', 'ate'], ['tan', 'nat'], ['bat']]

Gegeben ist ein Array nums. Schreiben Sie eine Funktion, die alle 0en an das Ende des Arrays verschiebt, während die relative Reihenfolge der Nicht-Null-Elemente beibehalten wird.

Erklärung: Verwenden Sie einen 'Zwei-Zeiger'- oder 'Schneeball'-Ansatz. Ein Zeiger verfolgt die Position, an die das nächste Nicht-Null-Element gehen soll. Iterieren Sie durch das Array; wenn ein Element ungleich Null ist, platzieren Sie es an der Position des Zeigers und erhöhen Sie den Zeiger. Füllen Sie schließlich den Rest mit Nullen auf.

function moveZeroes(nums) {
  let nonZeroIndex = 0;

  // Verschieben Sie alle Nicht-Null-Elemente an den Anfang
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] !== 0) {
      nums[nonZeroIndex] = nums[i];
      nonZeroIndex++;
    }
  }

  // Füllen Sie den Rest mit Nullen auf
  for (let i = nonZeroIndex; i < nums.length; i++) {
    nums[i] = 0;
  }

  return nums;
}

console.log(moveZeroes([0, 1, 0, 3, 12])); // [1, 3, 12, 0, 0]

Gegeben ist ein Array von Ganzzahlen nums. Finden Sie das zusammenhängende Teilarray (das mindestens eine Zahl enthält), das die größte Summe hat, und geben Sie dessen Summe zurück.

Erklärung: Der Kadane-Algorithmus ist eine effiziente Methode zur Lösung dieses Problems. Iterieren Sie durch das Array und verfolgen Sie die currentMax-Summe, die an der aktuellen Position endet, und die bisher gefundene globalMax-Summe. Wenn currentMax negativ wird, setzen Sie es auf 0 zurück (oder besser gesagt, auf das aktuelle Element).

function maxSubArray(nums) {
  let globalMax = -Infinity;
  let currentMax = 0;

  for (let i = 0; i < nums.length; i++) {
    currentMax = Math.max(nums[i], currentMax + nums[i]);
    if (currentMax > globalMax) {
      globalMax = currentMax;
    }
  }
  return globalMax;
}

console.log(maxSubArray([-2, 1, -3, 4, -1, 2, 1, -5, 4])); // 6 (von [4, -1, 2, 1])