Algorithmen hinter JavaScript-Array-Methoden

Algorithmen hinter JavaScript-Array-Methoden.

JavaScript-Arrays verfügen über verschiedene integrierte Methoden, die die Manipulation und den Abruf von Daten in einem Array ermöglichen. Hier ist eine Liste der aus Ihrer Gliederung extrahierten Array-Methoden:

1. concat()
2. join()
3. fill()
4. includes()
5. indexOf()
6. reverse()
7. sort()
8. spleißen()
9. at()
10. copyWithin()
11. flat()
12. Array.from()
13. findLastIndex()
14. forEach()
15. jeder()
16. Einträge()
17. Werte()
18. toReversed() (erstellt eine umgekehrte Kopie des Arrays, ohne das Original zu ändern)
19. toSorted() (erstellt eine sortierte Kopie des Arrays, ohne das Original zu ändern)
20. toSpliced() (erstellt ein neues Array mit hinzugefügten oder entfernten Elementen, ohne das Original zu ändern)
21. with() (gibt eine Kopie des Arrays zurück, wobei ein bestimmtes Element ersetzt wurde)
22. Array.fromAsync()
23. Array.of()
24. map()
25. flatMap()
26. reduce()
27. reduceRight()
28. einige()
29. find()
30. findIndex()
31. findLast()

Lassen Sie mich die allgemeinen Algorithmen aufschlüsseln, die für jede JavaScript-Array-Methode verwendet werden:

1. concat()

• Algorithmus: Lineares Anhängen/Zusammenführen
• Zeitkomplexität: O(n), wobei n die Gesamtlänge aller Arrays ist
• Verwendet intern die Iteration, um neue Arrays zu erstellen und Elemente zu kopieren

// concat()
Array.prototype.myConcat = function(...arrays) {
  const result = [...this];
  for (const arr of arrays) {
    for (const item of arr) {
      result.push(item);
    }
  }
  return result;
};

2. beitreten()

• Algorithmus: Lineare Durchquerung mit String-Verkettung
• Zeitkomplexität: O(n)
• Durchläuft Array-Elemente und erstellt eine Ergebniszeichenfolge

// join()
Array.prototype.myJoin = function(separator = ',') {
  let result = '';
  for (let i = 0; i 



<h3>
  
  
  3. fill()
</h3>

• Algorithmus: Lineare Durchquerung mit Zuweisung
• Zeitkomplexität: O(n)
• Einfache Iteration mit Wertzuweisung

// fill()
Array.prototype.myFill = function(value, start = 0, end = this.length) {
  for (let i = start; i 



<h3>
  
  
  4. Includes()
</h3>

• Algorithmus: Lineare Suche
• Zeitkomplexität: O(n)
• Sequentieller Scan, bis ein Element gefunden oder das Ende erreicht ist

// includes()
Array.prototype.myIncludes = function(searchElement, fromIndex = 0) {
  const startIndex = fromIndex >= 0 ? fromIndex : Math.max(0, this.length + fromIndex);
  for (let i = startIndex; i 



<h3>
  
  
  5. indexOf()
</h3>

• Algorithmus: Lineare Suche
• Zeitkomplexität: O(n)
• Sequentieller Scan vom Start bis zum Finden einer Übereinstimmung

// indexOf()
Array.prototype.myIndexOf = function(searchElement, fromIndex = 0) {
  const startIndex = fromIndex >= 0 ? fromIndex : Math.max(0, this.length + fromIndex);
  for (let i = startIndex; i 



<h3>
  
  
  6. reverse()
</h3>

• Algorithmus: Zwei-Zeiger-Swap
• Zeitkomplexität: O(n/2)
• Tauscht Elemente vom Anfang/Ende nach innen

// reverse()
Array.prototype.myReverse = function() {
  let left = 0;
  let right = this.length - 1;

  while (left 



<h3>
  
  
  7. sort()
</h3>

• Algorithmus: Typischerweise TimSort (Hybrid aus Zusammenführungssortierung und Einfügungssortierung)
• Zeitkomplexität: O(n log n)
• Moderne Browser verwenden adaptive Sortieralgorithmen

// sort()
Array.prototype.mySort = function(compareFn) {
  // Implementation of QuickSort for simplicity
  // Note: Actual JS engines typically use TimSort
  const quickSort = (arr, low, high) => {
    if (low  {
    const pivot = arr[high];
    let i = low - 1;

    for (let j = low; j 



<h3>
  
  
  8. splice()
</h3>

• Algorithmus: Lineare Array-Modifikation
• Zeitkomplexität: O(n)
• Verschiebt Elemente und ändert das Array direkt

// splice()
Array.prototype.mySplice = function(start, deleteCount, ...items) {
  const len = this.length;
  const actualStart = start  0) {
    // Moving elements right
    for (let i = len - 1; i >= actualStart + actualDeleteCount; i--) {
      this[i + shiftCount] = this[i];
    }
  } else if (shiftCount 



<h3>
  
  
  9. at()
</h3>

• Algorithmus: Direkter Indexzugriff
• Zeitkomplexität: O(1)
• Einfache Array-Indizierung mit Grenzprüfung

// at()
Array.prototype.myAt = function(index) {
  const actualIndex = index >= 0 ? index : this.length + index;
  return this[actualIndex];
};

10. copyWithin()

• Algorithmus: Speicherkopie blockieren
• Zeitkomplexität: O(n)
• Kopier- und Verschiebungsvorgänge im internen Speicher

// copyWithin()
Array.prototype.myCopyWithin = function(target, start = 0, end = this.length) {
  const len = this.length;
  let to = target 



<h3>
  
  
  11. flach()
</h3>

• Algorithmus: Rekursive Tiefendurchquerung
• Zeitkomplexität: O(n) für einzelne Ebene, O(d*n) für Tiefe d
• Reduziert verschachtelte Arrays rekursiv

// flat()
Array.prototype.myFlat = function(depth = 1) {
  const flatten = (arr, currentDepth) => {
    const result = [];
    for (const item of arr) {
      if (Array.isArray(item) && currentDepth 



<h3>
  
  
  12. Array.from()
</h3>

• Algorithmus: Iteration und Kopieren
• Zeitkomplexität: O(n)
• Erstellt ein neues Array aus iterierbar

// Array.from()
Array.myFrom = function(arrayLike, mapFn) {
  const result = [];
  for (let i = 0; i 



<h3>
  
  
  13. findLastIndex()
</h3>

• Algorithmus: Umgekehrte lineare Suche
• Zeitkomplexität: O(n)
• Sequentieller Scan vom Ende bis zum Finden einer Übereinstimmung

// findLastIndex()
Array.prototype.myFindLastIndex = function(predicate) {
  for (let i = this.length - 1; i >= 0; i--) {
    if (predicate(this[i], i, this)) return i;
  }
  return -1;
};

14. forEach()

• Algorithmus: Lineare Iteration
• Zeitkomplexität: O(n)
• Einfache Iteration mit Callback-Ausführung

// forEach()
Array.prototype.myForEach = function(callback) {
  for (let i = 0; i 



<h3>
  
  
  15. jeder()
</h3>

<p>Algorithmus: Linearer Kurzschlussscan<br>
Zeitkomplexität: O(n)<br>
Stoppt bei der ersten falschen Bedingung<br>
</p><pre class="brush:php;toolbar:false">// concat()
Array.prototype.myConcat = function(...arrays) {
  const result = [...this];
  for (const arr of arrays) {
    for (const item of arr) {
      result.push(item);
    }
  }
  return result;
};

16. Einträge()

• Algorithmus: Implementierung des Iteratorprotokolls
• Zeitkomplexität: O(1) für die Erstellung, O(n) für die vollständige Iteration
• Erstellt ein Iteratorobjekt

// join()
Array.prototype.myJoin = function(separator = ',') {
  let result = '';
  for (let i = 0; i 



<h3>
  
  
  17. Werte()
</h3>

• Algorithmus: Implementierung des Iteratorprotokolls
• Zeitkomplexität: O(1) für die Erstellung, O(n) für die vollständige Iteration
• Erstellt einen Iterator für Werte

// fill()
Array.prototype.myFill = function(value, start = 0, end = this.length) {
  for (let i = start; i 



<h3>
  
  
  18. toReversed()
</h3>

• Algorithmus: Kopieren mit umgekehrter Iteration
• Zeitkomplexität: O(n)
• Erstellt ein neues umgekehrtes Array

// includes()
Array.prototype.myIncludes = function(searchElement, fromIndex = 0) {
  const startIndex = fromIndex >= 0 ? fromIndex : Math.max(0, this.length + fromIndex);
  for (let i = startIndex; i 



<h3>
  
  
  19. toSorted()
</h3>

• Algorithmus: Kopieren, dann TimSort
• Zeitkomplexität: O(n log n)
• Erstellt eine sortierte Kopie mit der Standardsortierung

// indexOf()
Array.prototype.myIndexOf = function(searchElement, fromIndex = 0) {
  const startIndex = fromIndex >= 0 ? fromIndex : Math.max(0, this.length + fromIndex);
  for (let i = startIndex; i 



<h3>
  
  
  20. toSpliced()
</h3>

• Algorithmus: Kopieren mit Änderung
• Zeitkomplexität: O(n)
• Erstellt eine geänderte Kopie

// reverse()
Array.prototype.myReverse = function() {
  let left = 0;
  let right = this.length - 1;

  while (left 



<h3>
  
  
  21. mit()
</h3>

• Algorithmus: Flache Kopie mit einmaliger Änderung
• Zeitkomplexität: O(n)
• Erstellt eine Kopie mit einem geänderten Element

// sort()
Array.prototype.mySort = function(compareFn) {
  // Implementation of QuickSort for simplicity
  // Note: Actual JS engines typically use TimSort
  const quickSort = (arr, low, high) => {
    if (low  {
    const pivot = arr[high];
    let i = low - 1;

    for (let j = low; j 



<h3>
  
  
  22. Array.fromAsync()
</h3>

• Algorithmus: Asynchrone Iteration und Sammlung
• Zeitkomplexität: O(n) asynchrone Operationen
• Verarbeitet Versprechen und asynchrone Iterables

// splice()
Array.prototype.mySplice = function(start, deleteCount, ...items) {
  const len = this.length;
  const actualStart = start  0) {
    // Moving elements right
    for (let i = len - 1; i >= actualStart + actualDeleteCount; i--) {
      this[i + shiftCount] = this[i];
    }
  } else if (shiftCount 



<h3>
  
  
  23. Array.of()
</h3>

• Algorithmus: Direkte Array-Erstellung
• Zeitkomplexität: O(n)
• Erstellt ein Array aus Argumenten

// at()
Array.prototype.myAt = function(index) {
  const actualIndex = index >= 0 ? index : this.length + index;
  return this[actualIndex];
};

24. Karte()

• Algorithmus: Transformationsiteration
• Zeitkomplexität: O(n)
• Erstellt ein neues Array mit transformierten Elementen

// copyWithin()
Array.prototype.myCopyWithin = function(target, start = 0, end = this.length) {
  const len = this.length;
  let to = target 



<h3>
  
  
  25. flatMap()
</h3>

• Algorithmus: Karte abflachen
• Zeitkomplexität: O(n*m), wobei m die durchschnittliche Größe des zugeordneten Arrays ist
• Kombiniert Mapping und Flattening

// flat()
Array.prototype.myFlat = function(depth = 1) {
  const flatten = (arr, currentDepth) => {
    const result = [];
    for (const item of arr) {
      if (Array.isArray(item) && currentDepth 



<h3>
  
  
  26. Reduzieren()
</h3>

• Algorithmus: Lineare Akkumulation
• Zeitkomplexität: O(n)
• Sequentielle Akkumulation mit Rückruf

// Array.from()
Array.myFrom = function(arrayLike, mapFn) {
  const result = [];
  for (let i = 0; i 



<h3>
  
  
  27. ReduceRight()
</h3>

• Algorithmus: Umgekehrte lineare Akkumulation
• Zeitkomplexität: O(n)
• Akkumulation von rechts nach links

// findLastIndex()
Array.prototype.myFindLastIndex = function(predicate) {
  for (let i = this.length - 1; i >= 0; i--) {
    if (predicate(this[i], i, this)) return i;
  }
  return -1;
};

28. einige()

• Algorithmus: Linearer Kurzschlussscan
• Zeitkomplexität: O(n)
• Stoppt bei der ersten wahren Bedingung

// forEach()
Array.prototype.myForEach = function(callback) {
  for (let i = 0; i 



<h3>
  
  
  29. find()
</h3>

• Algorithmus: Lineare Suche
• Zeitkomplexität: O(n)
• Sequentieller Scan, bis die Bedingung erfüllt ist

// every()
Array.prototype.myEvery = function(predicate) {
  for (let i = 0; i 



<h3>
  
  
  30. findIndex()
</h3>

• Algorithmus: Lineare Suche
• Zeitkomplexität: O(n)
• Sequentieller Scan nach übereinstimmender Bedingung

// entries()
Array.prototype.myEntries = function() {
  let index = 0;
  const array = this;

  return {
    [Symbol.iterator]() {
      return this;
    },
    next() {
      if (index 



<h3>
  
  
  31. findLast()
</h3>

• Algorithmus: Umgekehrte lineare Suche
• Zeitkomplexität: O(n)
• Sequentieller Scan vom Ende

// concat()
Array.prototype.myConcat = function(...arrays) {
  const result = [...this];
  for (const arr of arrays) {
    for (const item of arr) {
      result.push(item);
    }
  }
  return result;
};

Ich habe vollständige Implementierungen aller 31 von Ihnen angeforderten Array-Methoden bereitgestellt.

? Vernetzen Sie sich mit mir auf LinkedIn:

Lassen Sie uns gemeinsam tiefer in die Welt des Software-Engineerings eintauchen! Ich teile regelmäßig Einblicke in JavaScript, TypeScript, Node.js, React, Next.js, Datenstrukturen, Algorithmen, Webentwicklung und vieles mehr. Egal, ob Sie Ihre Fähigkeiten verbessern oder an spannenden Themen zusammenarbeiten möchten, ich würde mich gerne mit Ihnen vernetzen und mit Ihnen wachsen.

Folge mir: Nozibul Islam

Das obige ist der detaillierte Inhalt vonAlgorithmen hinter JavaScript-Array-Methoden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!