Benutzerdefinierte JavaScript-Funktion zum Sammeln

JavaScript ist eine High-Level-Programmiersprache, die zum Schreiben von Webanwendungen verwendet wird. Ihre leistungsstarken Fähigkeiten und ihr breites Einsatzspektrum haben sie zu einem unverzichtbaren Werkzeug in der Webentwicklung gemacht. In JavaScript sind benutzerdefinierte Funktionen eine sehr wichtige Technologie, die es uns ermöglicht, Funktionen entsprechend unseren eigenen Anforderungen zu schreiben und aufzurufen. In diesem Artikel stellen wir vor, wie Sie eine benutzerdefinierte JavaScript-Funktion zum Sammeln verwenden.

Was ist Akkumulation?

Addition ist die Addition aller Zahlen in einer Zahlenfolge. Wenn wir zum Beispiel die Zahlenfolge 1, 2, 3, 4, 5 haben, dann ist das Gesamtergebnis 15 (also 1 + 2 + 3 + 4 + 5).

Wie verwende ich benutzerdefinierte JavaScript-Funktionen zum Akkumulieren?

Um benutzerdefinierte JavaScript-Funktionen zum Akkumulieren zu verwenden, müssen wir Variablen, Schleifen und bedingte Anweisungen verwenden.

Hier ist ein einfachstes Akkumulierungsprogramm:

function sum(arr) {
  var s = 0;
  for (var i = 0; i < arr.length; i++) {
    s += arr[i];
  }
  return s;
}

var arr = [1, 2, 3, 4, 5];
console.log(sum(arr)); // 15

Lassen Sie uns dieses Programm Schritt für Schritt aufschlüsseln:

1. Zuerst definieren wir eine Funktion namens sum, die einen Parameter arr annimmt. Diese Funktion gibt eine Zahl zurück, die die Summe der Zahlenfolge ist.
2. Wir verwenden eine Variable s, um das akkumulierte Ergebnis zu speichern und es auf 0 zu initialisieren. Hier verwenden wir das Schlüsselwort var, um Variablen zu deklarieren. Das Schlüsselwort var gibt an, dass s eine lokale Variable ist, auf die nur in der aktuellen Funktion zugegriffen und diese verwendet werden kann. Wenn wir eine Variable außerhalb einer Funktion definieren, wird sie zu einer globalen Variablen und kann überall im Programm verwendet werden.
3. Als nächstes verwenden wir eine Schleife, um jedes Element in der Zahlenfolge zu durchlaufen. Die Schleifenvariable i wird auf 0 initialisiert und jedes Mal um 1 erhöht, bis i gleich arr.length ist.
4. In der Schleife verwenden wir s += arr[i], um den Wert des aktuellen Elements zum akkumulierten Ergebnis zu addieren. Dies ist eine einfache Abkürzung, die s = s + arr[i] entspricht.
5. Abschließend verwenden wir die return s-Anweisung, um das akkumulierte Ergebnis zurückzugeben.

Wir können es testen, indem wir die Summenfunktion aufrufen und eine Zahlenfolge übergeben. In diesem Beispiel definieren wir eine Zahlenfolge arr = [1, 2, 3, 4, 5] und verwenden die Funktion console.log, um das kumulative Ergebnis auszugeben.

Das obige Programm ist die grundlegendste Form einer benutzerdefinierten JavaScript-Funktion zur Akkumulation. Allerdings lässt es einiges zu wünschen übrig.

Fehlerbehandlung

Das vorherige Programm geht davon aus, dass die Eingabedaten korrekt und gültig sind, und führt Berechnungen direkt durch. In realen Anwendungen ist es jedoch wahrscheinlich, dass wir auf falsche Eingabedaten oder andere Fehler stoßen.

Um ein robusteres Programm zu schreiben, müssen wir einen Fehlerbehandlungsmechanismus hinzufügen. Hier ist ein verbessertes Akkumulierungsprogramm:

function sum(arr) {
  if (!Array.isArray(arr)) {
    throw new TypeError('sum() expects an array as parameter.');
  }
  var s = 0;
  for (var i = 0; i < arr.length; i++) {
    if (typeof arr[i] !== 'number') {
      throw new TypeError('sum() expects an array of numbers.');
    }
    s += arr[i];
  }
  return s;
}

var arr = [1, 2, 3, 4, 5];
console.log(sum(arr)); // 15
console.log(sum('12345')); // TypeError: sum() expects an array as parameter.
console.log(sum([1, '2', 3, 4])); // TypeError: sum() expects an array of numbers.

In dieser Version haben wir zwei Fehlerbehandlungsbedingungen hinzugefügt:

1. Wenn der übergebene Parameter kein Array ist, werfen wir einen TypeError (TypeError) aus.
2. Wir geben auch einen Typfehler aus, wenn das Array Elemente enthält, die keine Zahlen sind.

Die Fehlerbehandlung kann die Robustheit und Zuverlässigkeit des Programms erheblich verbessern und sicherstellen, dass unsere Funktionen unter unerwarteten Umständen korrekt ausgeführt werden können.

Funktionssignatur

Bei der Programmierung bezieht sich die Funktionssignatur auf den Namen, die Parameter und den Rückgabewerttyp der Funktion. Die Bestimmung von Funktionssignaturen kann uns helfen, Funktionen leichter zu verstehen und zu nutzen.

Die Funktionssignatur sollte Folgendes enthalten:

1. Funktionsname: Dies sollte eine Textzeichenfolge sein, die das Verhalten der Funktion beschreibt. Beispielsweise beschreibt der obige Funktionsname sum sein Verhalten sehr gut.
2. Parameter: Dies sollte eine Textzeichenfolge sein, die die Eingabe in die Funktion beschreibt. Für die Akkumulationsfunktion benötigen wir nur einen Array-Parameter arr.
3. Rückgabewerttyp: Dies sollte eine Textzeichenfolge sein, die den Rückgabewerttyp der Funktion beschreibt. Für die Akkumulationsfunktion erwarten wir, dass sie eine Zahl zurückgibt.

Für die Akkumulationsfunktion können wir ihre Funktion wie folgt signieren:

sum(arr: Array) => Number

Dies zeigt an, dass die Summenfunktion ein Array als Parameter erfordert und als Ergebnis eine Zahl zurückgibt.

Funktionen höherer Ordnung

In JavaScript ist eine Funktion höherer Ordnung eine Funktion, die eine Funktion als Eingabe akzeptiert oder eine Funktion als Ausgabe zurückgibt. Wir können Funktionen höherer Ordnung verwenden, um allgemeine Operationen zu kapseln und sie auf verschiedene Datentypen oder Bedingungen anzuwenden.

Zum Beispiel können wir eine allgemeine Kartenfunktion schreiben, die eine Operation auf jedes Element in einem beliebigen Array anwenden kann. Sehen wir uns an, wie man diese Funktion schreibt:

function map(arr, f) {
  if (!Array.isArray(arr)) {
    throw new TypeError('map() expects an array as parameter.');
  }
  if (typeof f !== 'function') {
    throw new TypeError('map() expects a function as second parameter.');
  }
  var result = [];
  for (var i = 0; i < arr.length; i++) {
    result.push(f(arr[i]));
  }
  return result;
}

var arr = [1, 2, 3, 4, 5];
console.log(map(arr, x => 2 * x)); // [2, 4, 6, 8, 10]

var words = ['JavaScript', 'is', 'awesome'];
console.log(map(words, w => w.toUpperCase())); // ['JAVASCRIPT', 'IS', 'AWESOME']

Diese Funktion benötigt zwei Parameter: ein Array arr und eine Funktion f. Die Funktion f wird auf jedes Element im Array angewendet und gibt das berechnete Ergebnis zurück.

Wir können die Map-Funktion verwenden, um verschiedene Operationen anzuwenden, z. B. die Multiplikation auf jedes Element im Zahlenarray und die Umwandlung in Großbuchstaben auf jedes Element im String-Array. Da es sich bei der Kartenfunktion um eine allgemeine Operation handelt, müssen wir sie nur einmal definieren und in mehreren Szenarien verwenden.

Zusammenfassung:

Durch die Einleitung dieses Artikels haben wir gelernt, wie man benutzerdefinierte JavaScript-Funktionen zum Sammeln verwendet. Wir haben gelernt, wie man mit Fehlern umgeht, Funktionssignaturen definiert und Funktionen höherer Ordnung verwendet. Benutzerdefinierte JavaScript-Funktionen sind sehr flexibel und leistungsstark und ermöglichen es uns, Funktionen entsprechend unseren eigenen Anforderungen zu schreiben und aufzurufen, wodurch die Wiederholbarkeit und Wartbarkeit des Codes verbessert wird.

Das obige ist der detaillierte Inhalt vonBenutzerdefinierte JavaScript-Funktion zum Sammeln. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!