6 Möglichkeiten, die Maximal- und Minimalwerte eines Arrays in Javascript zu implementieren

Gegeben: Ein Array [1,8,5,4,3,9,2], schreiben Sie einen Algorithmus, um den Maximalwert 9 und den Minimalwert 1 des Arrays zu erhalten.

1. Erweitern Sie die Funktionen min() und max() durch die Prototype-Eigenschaft

Die Idee von Algorithmus 1 besteht darin, das Ergebnis zu finden, indem der erste Wert mit den nachfolgenden Werten in einer Schleife in den benutzerdefinierten Funktionen min() und max() verglichen wird und die Maximal- und Minimalwerte dynamisch aktualisiert werden.

        // Minimalwert Array.prototype.min = Funktion () {
            lass min = dies[0];
            lass len = diese.Länge;
            für (sei i = 1; i < len; i++) {
                wenn (dies[i] < min) min = dies[i]
            }
            Rückgabe min
        }
        // Maximalwert Array.prototype.max = Funktion () {
            sei max = dies[0];
            lass len = diese.Länge;
            für (sei i = 1; i < len; i++) {
                wenn (dies[i] > max) max = dies[i]
            }
            Rückgabewert max
        }
        // Ergebnis console.log(arr.min()); // 1
        konsole.log(arr.max()); // 9

2. Verwenden Sie die min()- und max()-Funktionen des Math-Objekts

Die Hauptidee von Algorithmus 2 besteht darin, den Ausführungshauptteil der Funktion durch die Funktion apply() zu ändern und das Array als Parameter an die Funktion apply() zu übergeben. Auf diese Weise kann das Array die Funktionen min() und max() des Math-Objekts direkt aufrufen, um den Rückgabewert zu erhalten.

        Array.min = Funktion(Array) {
            gibt Math.min.apply(Mathe, Array) zurück
        }
        // Maximalwert Array.max = Funktion (Array) {
            gibt Math.max.apply(Mathe, Array) zurück
        }
        // Ergebnis console.log(Array.min(arr)); // 1
        konsole.log(Array.max(arr)); // 9

3. Optimierung von Algorithmus 2

In Algorithmus 2 werden die Funktionen min() und max() als statische Funktionen des Typs Array verwendet, Kettenaufrufe werden jedoch nicht unterstützt. Zur Vereinfachung können wir Objektliterale verwenden.

        // Minimalwert Array.prototype.min = function() {
            gibt Math.min.apply({}, dies) zurück
        }
        // Maximalwert Array.prototype.max = Funktion () {
            gibt Math.max.apply({}, dies) zurück
        }
        // Ergebnis console.log(arr.min()); // 1
        konsole.log(arr.max()); // 9

Im Unterschied zu Algorithmus 2 können die Funktionen min() und max() während der Überprüfung direkt über das Array aufgerufen werden, da es sich bei ihnen um Instanzmethoden handelt.
Im obigen Algorithmuscode ist der erste an die Funktion apply() übergebene Wert {}, der tatsächlich das globale Objekt der aktuellen Ausführungsumgebung darstellt. Der zweite Parameter zeigt auf das Array, das verarbeitet werden muss.
Aufgrund der Besonderheit der Apply-Funktion wird der erste Parameter automatisch durch einen Zeiger auf das globale Objekt ersetzt, wenn es als null oder undefiniert angegeben wird, und der ursprüngliche Wert wird umbrochen. Daher können wir den ersten Parameter auch auf null setzen, undefiniert.

4. Verwenden der Funktion „reduce()“ des Array-Typs

Die Kernidee von Algorithmus 4 besteht darin, dass die Funktion „reduce()“ nicht den initialValue setzt, sondern direkt das erste Element des Arrays als ersten Parameter der Callback-Funktion verwendet und es der Reihe nach mit den nachfolgenden Werten vergleicht. Wenn der Maximalwert ermittelt werden muss, gibt der Akkumulator in jeder Runde den größeren Wert zurück; wenn der Minimalwert ermittelt werden muss, gibt der Akkumulator in jeder Runde den kleineren Wert zurück.

        // Minimalwert Array.prototype.min = Funktion () {
            gib dies zurück.reduce((pre, cur) => {
                returniere vor < aktuell ? vor : aktuell
            })
        }
        // Maximalwert Array.prototype.max = Funktion () {
            gib dies zurück.reduce((pre, cur) => {
                Rückgabe vor > aktuell? vor: aktuell
            })
        }
        // Ergebnis console.log(arr.min()); // 1
        konsole.log(arr.max()); // 9

5. Verwenden Sie die Funktion sort() vom Typ Array

Die Hauptidee von Algorithmus 5 besteht darin, das Array mithilfe der nativen sort()-Funktion des Arrays zu sortieren. Nachdem die Sortierung abgeschlossen ist, sind das erste und das letzte Element die minimalen und maximalen Elemente des Arrays.
Die Standardfunktion sort() sortiert in alphabetischer Reihenfolge und Zahlen werden als Zeichenfolgen behandelt. Beispielsweise wird die Zahl 18 als „18“ und die Zahl 6 als „6“ behandelt. Beim Sortieren basiert der Vergleich auf jedem Bit der Zeichenfolge. Da „1“ kleiner als „6“ ist, ist „11“ beim Sortieren kleiner als „6“. Bei Arrays numerischer Typen ist dies offensichtlich nicht sinnvoll. Wir müssen also eine benutzerdefinierte Sortierung durchführen.

        lass sortArr = arr.sort((a, b) => a - b)
        // Minimalwert sortArr[0]
        // Maximalwert sortArr[sortArr.length - 1]
        // Ergebnis console.log(sortArr[0]); // 1
        console.log(sortArr[sortArr.length - 1]); // 9

6. Verwenden Sie den Spread-Operator von ES6

        // Minimalwert Math.min(...arr)
        // Maximalwert Math.max(...arr)
        // Ergebnis console.log(Math.min(...arr)); // 1
        konsole.log(Math.max(...arr)); // 9

Damit ist dieser Artikel über 6 Möglichkeiten zur Implementierung von Maximal- und Minimalwerten eines Arrays in JavaScript abgeschlossen. Weitere relevante Inhalte zu Maximal- und Minimalwerten von JavaScript-Arrays finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den verwandten Artikeln weiter unten. Ich hoffe, Sie werden 123WORDPRESS.COM auch in Zukunft unterstützen!