Agregar clase de vector en JavaScript

1. Agregar clase de vector usando un bucle for en JavaScript
2. Agregar clase de vector usando Array.proyotype.map() en JavaScript
3. Agregar clase de vector usando una clase ES6 en JavaScript
4. Agregar clase de vector extendiendo la clase de matriz en JavaScript

Este tutorial le enseñará cómo agregar dos vectores en JavaScript usando diferentes métodos.

Agregar clase de vector usando un bucle for en JavaScript

Puede usar el ciclo for para agregar dos vectores en JavaScript. Mientras tanto, los vectores deben ser matrices de JavaScript.

Defina una función constructora que realice la suma y devuelva el resultado para comenzar. Es mejor escribir la función de suma por separado de la función de constructor para que el código sea limpio y reutilizable en otros proyectos.

La función de suma debería funcionar para que el primer vector pueda llamarla en el segundo.

Por lo tanto, el primer vector es el que llama y el segundo es el que llama. Como resultado, la función de suma debería funcionar de la siguiente manera:

1. Asegúrese de que los argumentos sean matrices de la misma longitud. Los argumentos son el primer vector (el llamador) y la segunda matriz (el llamado).
2. Construya una matriz vacía para almacenar el resultado final de la suma de vectores.
3. Recorra la matriz de llamadas.
4. Use el índice de bucle para agregar la matriz de llamadas y los elementos de la matriz de llamadas.
5. Inserte el resultado en la matriz vacía creada en el Paso 1. Por lo tanto, ya no está vacía porque tiene el resultado de la suma.
6. Devuelva una nueva instancia de la función constructora con la nueva matriz.
7. Si algo salió mal en el camino, devuelva un error.

El siguiente código es la implementación de estos pasos. Hemos implementado comprobaciones adicionales que garantizan que el usuario pase el valor de vector correcto.

Agregamos dos vectores para probar la suma de vectores y registramos el resultado en la consola del navegador web.

Código:

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);

Producción :

Array(3) [ 8, 7, 16 ]

Agregar clase de vector usando Array.proyotype.map() en JavaScript

Agregar vectores usando Array.prototype.map() requiere que los vectores mismos sean matrices de JavaScript. Similar a la sección anterior, la primera matriz debe ser la persona que llama.

Esto significa que definirá una función constructora que ayudará a la adición. Sin embargo, no definiremos la función add() por separado de la función constructora.

Esta vez, haremos que la función add() forme parte del prototipo de la función constructora.

La función add() devolverá una nueva instancia de la función constructora. Sin embargo, el argumento de esta nueva instancia es el resultado de la matriz de llamada en la matriz llamada utilizando Array.prototype.map() con una función personalizada.

La función personalizada realiza la adición de las matrices.

Usamos Array.prototype.map() para agregar los vectores en el código a continuación. Verificamos si los argumentos eran matrices de la misma longitud durante el proceso.

Cualquier otra cosa que no sea eso, el código arroja un TypeError.

Código:

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);

Producción :

Array(3) [ 11, 13, 13 ]

Agregar clase de vector usando una clase ES6 en JavaScript

La lógica fundamental detrás del uso de una clase ES6 para agregar vectores es una función personalizada add(), que agrega los vectores usando un bucle for y devuelve una nueva instancia de la clase ES6. Antes de agregar los vectores, asegúrese de almacenarlos en una matriz.

Luego, la primera matriz debería llamar a la función add() en la segunda matriz.

Tenemos una clase ES6 en el siguiente código que agrega dos matrices usando una función add(). Después de la adición, pasa el resultado de la adición a una nueva instancia de la clase ES6.

Código:

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);

Producción :

Array(3) [ 4, 11, 0 ]

Agregar clase de vector extendiendo la clase de matriz en JavaScript

Puede crear una clase vectorial que amplíe la clase Array nativa de JavaScript. Entonces, la clase de vector debería implementar una función que agregue los vectores.

El primer vector puede llamar a la función en el segundo vector. Como resultado, obtendrá el resultado de la suma.

En el siguiente código, hemos extendido la clase Array nativa y usamos la función map() para recorrer la matriz llamada. Luego, podemos agregar su elemento a la matriz de llamadas y producir un resultado.

Código:

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));

Producción :

Array(3) [ 4, 11, 24 ]