Vektorklasse in JavaScript hinzufügen

1. Vektorklasse mit einer for-Schleife in JavaScript hinzufügen
2. Vektorklasse mit Array.proyotype.map() in JavaScript hinzufügen
3. Vektorklasse mithilfe einer ES6-Klasse in JavaScript hinzufügen
4. Fügen Sie eine Vektorklasse hinzu, indem Sie die Array-Klasse in JavaScript erweitern

In diesem Tutorial lernen Sie, wie Sie zwei Vektoren in JavaScript mit verschiedenen Methoden hinzufügen.

Vektorklasse mit einer for-Schleife in JavaScript hinzufügen

Sie können die for-Schleife verwenden, um zwei Vektoren in JavaScript hinzuzufügen. In der Zwischenzeit sollten die Vektoren JavaScript-Arrays sein.

Definieren Sie eine Konstruktorfunktion, die die Addition ausführt und das Ergebnis zurückgibt, um loszulegen. Es ist am besten, die Additionsfunktion getrennt von der Konstruktorfunktion zu schreiben, um den Code sauber und in anderen Projekten wiederverwendbar zu machen.

Die Additionsfunktion sollte so funktionieren, dass der erste Vektor sie auf dem zweiten aufrufen kann.

Daher ist der erste Vektor der Anrufer und der zweite der Angerufene. Als Ergebnis sollte die Additionsfunktion wie folgt funktionieren:

1. Stellen Sie sicher, dass die Argumente Arrays gleicher Länge sind. Die Argumente sind der erste Vektor (der Anrufer) und das zweite Array (der Angerufene).
2. Konstruieren Sie ein leeres Array, um das Endergebnis der Vektoraddition zu speichern.
3. Durchlaufen Sie das Anrufer-Array.
4. Verwenden Sie den Schleifenindex, um das aufrufende Array und die aufgerufenen Array-Elemente hinzuzufügen.
5. Schieben Sie das Ergebnis in das leere Array, das in Schritt 1 erstellt wurde. Es ist also nicht mehr leer, da es das Ergebnis der Addition enthält.
6. Geben Sie eine neue Instanz der Konstruktorfunktion mit dem neuen Array zurück.
7. Wenn dabei etwas schief gelaufen ist, geben Sie einen Fehler zurück.

Der folgende Code ist die Implementierung dieser Schritte. Wir haben zusätzliche Überprüfungen implementiert, die sicherstellen, dass der Benutzer den richtigen Vektorwert übergibt.

Wir haben zwei Vektoren hinzugefügt, um die Vektoraddition zu testen, und das Ergebnis in der Konsole des Webbrowsers protokolliert.

Code:

function Vector(arg) {
  this.array = arg;
  this.add = add;
}

function add(called_array) {
  if (Array.isArray(this.array) && Array.isArray(called_array.array)) {
    if (this.array.length === called_array.array.length) {
      let result = [];
      for (let i = 0; i < this.array.length; i++) {
        if (typeof (this.array[i]) == 'number' &&
            typeof (called_array.array[i]) == 'number') {
          result.push(this.array[i] + called_array.array[i]);
        } else {
          result.push('Invalid vector value');
        }
      }
      return new Vector(result);
    } else {
      return new Vector('The vectors are not the same length.');
    }
  } else {
    return new Vector('One of your arguments or both of them is not an array.');
  }
}

let caller_array = new Vector([3, 5, 7]);
let called_array = new Vector([5, 2, 9]);

console.log(caller_array.add(called_array).array);

Ausgang:

Array(3) [ 8, 7, 16 ]

Vektorklasse mit Array.proyotype.map() in JavaScript hinzufügen

Das Hinzufügen von Vektoren mit Array.prototype.map() erfordert, dass die Vektoren selbst JavaScript-Arrays sind. Ähnlich wie im vorherigen Abschnitt sollte das erste Array der Aufrufer sein.

Das bedeutet, dass Sie eine Konstruktorfunktion definieren, die das Hinzufügen unterstützt. Wir werden die Funktion add() jedoch nicht getrennt von der Konstruktorfunktion definieren.

Dieses Mal machen wir die Funktion add() zu einem Teil des Prototyps der Konstruktorfunktion.

Die Funktion add() gibt eine neue Instanz der Konstruktorfunktion zurück. Das Argument dieser neuen Instanz ist jedoch das Ergebnis des Aufrufer-Arrays auf dem aufgerufenen Array unter Verwendung von Array.prototype.map() mit einer benutzerdefinierten Funktion.

Die benutzerdefinierte Funktion führt die Addition der Arrays durch.

Wir haben Array.prototype.map() verwendet, um die Vektoren im folgenden Code hinzuzufügen. Wir haben während des Prozesses überprüft, ob es sich bei den Argumenten um Arrays gleicher Länge handelt.

Ansonsten wirft der Code einen TypeError.

Code:

var Vector = function(arg) {
  this.array = arg;
};

Vector.prototype.add =
    function(called_array) {
  called_array = called_array.array;
  let caller_array = this.array;

  if (Array.isArray(caller_array) && Array.isArray(called_array)) {
    if (caller_array.length !== called_array.length) {
      throw new TypeError('Vectors have different length');
    }
  } else {
    return new Vector('One of your arguments or both of them is not an array.');
  }

  return new Vector(
      caller_array.map(function(caller_array_element, called_array_element) {
        if (typeof (caller_array_element) == 'number' &&
            typeof (called_array_element) == 'number') {
          return caller_array_element + called_array[called_array_element];
        } else {
          return 'Invalid Vector value';
        }
      }));
}

let caller_array = new Vector([9, 8, 5]);
let called_array = new Vector([2, 5, 8]);

console.log(caller_array.add(called_array).array);

Ausgang:

Array(3) [ 11, 13, 13 ]

Vektorklasse mithilfe einer ES6-Klasse in JavaScript hinzufügen

Die grundlegende Logik hinter der Verwendung einer ES6-Klasse zum Hinzufügen von Vektoren ist eine benutzerdefinierte add()-Funktion, die die Vektoren mithilfe einer for-Schleife hinzufügt und eine neue Instanz der ES6-Klasse zurückgibt. Stellen Sie vor dem Hinzufügen der Vektoren sicher, dass Sie sie in einem Array speichern.

Danach sollte das erste Array die Funktion add() auf dem zweiten Array aufrufen.

Wir haben eine ES6-Klasse im folgenden Code, die zwei Arrays mit einer add()-Funktion hinzufügt. Nach der Addition übergibt es das Ergebnis der Addition an eine neue Instanz der ES6-Klasse.

Code:

class Vector {
  constructor(arr) {
    this.arr = arr;
  }

  add(called_array) {
    let caller_array = called_array.arr;

    if (Array.isArray(this.arr) && Array.isArray(caller_array)) {
      if (this.arr.length === caller_array.length) {
        let result = [];
        for (let key in this.arr) {
          if (typeof (this.arr[key]) == 'number' &&
              typeof (caller_array[key]) == 'number') {
            result[key] = this.arr[key] + caller_array[key];
          } else {
            result[key] = 'Invalid Vector Value.';
          }
        }
        return new Vector(result);
      } else {
        return new Vector('The vectors are not the same length.');
      }
    } else {
      return new Vector(
          'One of your arguments or both of them is not an array.');
    }
  }
}

let caller_array = new Vector([3, 6, 0]);
let called_array = new Vector([1, 5, 0]);

console.log(caller_array.add(called_array).arr);

Ausgang:

Array(3) [ 4, 11, 0 ]

Fügen Sie eine Vektorklasse hinzu, indem Sie die Array-Klasse in JavaScript erweitern

Sie können eine Vektorklasse erstellen, die die native Array-Klasse von JavaScript erweitert. Die Vektorklasse sollte also eine Funktion implementieren, die die Vektoren hinzufügt.

Der erste Vektor kann die Funktion auf dem zweiten Vektor aufrufen. Als Ergebnis erhalten Sie das Ergebnis der Addition.

Im folgenden Code haben wir die native Array-Klasse erweitert und die Funktion map() verwendet, um das aufgerufene Array schrittweise zu durchlaufen. Dann können wir sein Element zum Aufrufer-Array hinzufügen und ein Ergebnis erzeugen.

Code:

class Vector extends Array {
  add(called_array) {
    if (this.length == called_array.length) {
      return this.map((caller_array_element, called_array_element) => {
        if (typeof (caller_array_element) == 'number' &&
            typeof (called_array_element) == 'number') {
          return caller_array_element + called_array[called_array_element];
        } else {
          return 'Invalid Vector value';
        };
      })
    } else {
      return 'The vectors are not the same length.';
    }
  }
}

let caller_array = new Vector(1, 2, 4);
let called_array = new Vector(3, 9, 20);

console.log(caller_array.add(called_array));

Ausgang:

Array(3) [ 4, 11, 24 ]