tablas - obtener datos de una tabla html javascript

¿Cómo eliminar el elemento de la matriz por valor?

Question

¿Existe un método para eliminar un elemento de una matriz de JavaScript?

Dada una matriz:

var ary = [''three'', ''seven'', ''eleven''];

Me gustaría hacer algo como:

removeItem(''seven'', ary);

He buscado en splice() pero eso solo se elimina por el número de posición, mientras que necesito algo para eliminar un elemento por su valor.

Answer 1

// Editado gracias a MarcoCI por el consejo.

prueba esto:

function wantDelete(item, arr){
  for (var i=0;i<arr.length;i++){
    if (arr[i]==item){
      arr.splice(i,1); //this delete from the "i" index in the array to the "1" length
      break;
    }
  }  
}
var goodGuys=wantDelete(''bush'', [''obama'', ''bush'', ''clinton'']); //[''obama'', ''clinton'']

espero que esto te ayude

Answer 2

Aquí hay una versión que usa la función inArray de jQuery:

var index = $.inArray(item, array);
if (index != -1) {
    array.splice(index, 1);
}

Answer 3

ES6 camino.

let commentsWithoutDeletedArray = commentsArray.filter( (comment) => !(comment.Id === commentId));

Answer 4

Echa un vistazo de esta manera:

for(var i in array){
    if(array[i]==''seven''){
        array.splice(i,1);
        break;
    }
}

y en una función:

function removeItem(array, item){
    for(var i in array){
        if(array[i]==item){
            array.splice(i,1);
            break;
        }
    }
}

removeItem(array, ''seven'');

Answer 5

El truco consiste en recorrer la matriz desde el principio hasta el principio, para no desordenar los índices al eliminar elementos.

var deleteMe = function( arr, me ){
   var i = arr.length;
   while( i-- ) if(arr[i] === me ) arr.splice(i,1);
}

var arr = ["orange","red","black", "orange", "white" , "orange" ];

deleteMe( arr , "orange");

arr es ahora ["rojo", "negro", "blanco"]

Answer 6

Eliminación no destructiva:

function removeArrayValue(array, value)
{
    var thisArray = array.slice(0); // copy the array so method is non-destructive

    var idx = thisArray.indexOf(value); // initialise idx

    while(idx != -1)
    {
        thisArray.splice(idx, 1); // chop out element at idx

        idx = thisArray.indexOf(value); // look for next ocurrence of ''value''
    }

    return thisArray;
}

Answer 7

Eliminar todos los elementos coincidentes de la matriz (en lugar de solo el primero, ya que parece ser la respuesta más común aquí):

while ($.inArray(item, array) > -1) {
    array.splice( $.inArray(item, array), 1 );
}

Utilicé jQuery para el trabajo pesado, pero tienes la idea de querer ser nativo.

Answer 8

Esta puede ser una función global o un método de un objeto personalizado, si no se le permite agregar a los prototipos nativos. Elimina todos los elementos de la matriz que coinciden con cualquiera de los argumentos.

Array.prototype.remove = function() {
    var what, a = arguments, L = a.length, ax;
    while (L && this.length) {
        what = a[--L];
        while ((ax = this.indexOf(what)) !== -1) {
            this.splice(ax, 1);
        }
    }
    return this;
};

var ary = [''three'', ''seven'', ''eleven''];

ary.remove(''seven'');

/*  returned value: (Array)
three,eleven
*/

Para convertirlo en un

function removeA(arr) {
    var what, a = arguments, L = a.length, ax;
    while (L > 1 && arr.length) {
        what = a[--L];
        while ((ax= arr.indexOf(what)) !== -1) {
            arr.splice(ax, 1);
        }
    }
    return arr;
}
var ary = [''three'', ''seven'', ''eleven''];
removeA(ary, ''seven'');


/*  returned value: (Array)
three,eleven
*/

Y para cuidar de IE8 y más abajo.

if(!Array.prototype.indexOf) {
    Array.prototype.indexOf = function(what, i) {
        i = i || 0;
        var L = this.length;
        while (i < L) {
            if(this[i] === what) return i;
            ++i;
        }
        return -1;
    };
}

Answer 9

Intenté usar el método de función de jbaron anterior, pero encontré que necesitaba mantener la matriz original intacta para usarla más tarde, y crear una nueva matriz como esta:

var newArray = referenceArray;

aparentemente crea por referencia en lugar de por valor porque cuando quité un elemento de newArray, también se lo quitó a referenceArray. Así que decidí crear una nueva matriz cada vez como esta:

function newArrRemoveItem(array, item, newArray){
    for(var i = 0; i < array.length; i++) {
        if(array[i]!=item){
            newArray.push(array[i]);
        }
    }
}

Luego lo uso así en otra función:

var vesselID = record.get(''VesselID'');
var otherVessels = new Array();
newArrRemoveItem(vesselArr,vesselID,otherVessels);

Ahora el vesselArr permanece intacto, mientras que cada vez que ejecuto el código anterior, la matriz otherVessels incluye todos, excepto el último elemento vesselID.

Answer 10

Lo que buscas es filtro

developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

Esto te permitirá hacer lo siguiente:

var ary = [''three'', ''seven'', ''eleven''];
var aryWithoutSeven = ary.filter(function(value) { return value != ''seven'' });
console.log(aryWithoutSeven); // returns [''three'', ''eleven'']

Esto también se observó en este hilo en otra parte: https://.com/a/20827100/293492

Answer 11

Otra variación:

if (!Array.prototype.removeArr) {
    Array.prototype.removeArr = function(arr) {
        if(!Array.isArray(arr)) arr=[arr];//let''s be nice to people who put a non-array value here.. that could be me!
        var that = this;
        if(arr.length){
            var i=0;
            while(i<that.length){
                if(arr.indexOf(that[i])>-1){
                    that.splice(i,1);
                }else i++;
            }
        }
        return that;
    }
}

Es indexOf () dentro de un bucle de nuevo, pero suponiendo que la matriz a eliminar es pequeña en relación con la matriz a limpiar; cada eliminación acorta el bucle while.

Answer 12

Por favor, no use la variante con la delete : hace un agujero en la matriz, ya que no vuelve a indexar los elementos después del elemento eliminado.

> Array.prototype.remove=function(v){
...     delete this[this.indexOf(v)]
... };
[Function]
> var myarray=["3","24","55","2"];
undefined
> myarray.remove("55");
undefined
> myarray
[ ''3'', ''24'', , ''2'' ]

Answer 13

Puedes hacerlo de estas dos maneras:

var arr = ["1","2","3","4"] // we wanna delete number "3"

primero:

arr.indexOf(''3'') !== -1 && arr.splice(arr.indexOf(''3''), 1)

segundo (ES6):

arr = arr.filter(e => e !== ''3'')

Answer 14

Puedes lograr esto usando la función Lodash _.remove .

var array = [''three'', ''seven'', ''eleven''];
var evens = _.remove(array, function(e) {
  return e !== ''seven'';
});

console.log(evens);

<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/[email protected]/lodash.min.js"></script>

Answer 15

Puedes usar underscore.js . Realmente hace las cosas simples.

Por ejemplo, con esto:

var result = _.without([''three'',''seven'',''eleven''], ''seven'');

Y el result será [''three'',''eleven''] .

En tu caso el código que deberás escribir es:

ary = _.without(ary, ''seven'')

Reduce el código que escribes.

Answer 16

Puedes usar without o pull de Lodash :

const _ = require(''lodash'');
_.without([1, 2, 3, 2], 2); // -> [1, 3]

Answer 17

Puedes usar el método indexOf como este:

var index = array.indexOf(item);
if (index !== -1) array.splice(index, 1);

Nota : tendrás que cambiarlo para IE8 e inferior

var array = [1,2,3,4]
var item = 3

var index = array.indexOf(item);
if (index !== -1) array.splice(index, 1);

console.log(array)

Answer 18

Realmente, no puedo ver por qué esto no se puede resolver con

arr = arr.filter(value => value !== ''seven'');

O tal vez quieras usar vainilla JS

arr = arr.filter(function(value) { return value !== ''seven'' });

Answer 19

Si tiene valores únicos en su matriz y no importa el ordenamiento, puede usar Establecer y eliminar :

var mySet = new Set([''foo'']);
mySet.delete(''foo''); // Returns true.  Successfully removed.
mySet.has(''foo'');    // Returns false. The "foo" element is no longer present.

Answer 20

Un one-liner lo hará,

var ary = [''three'', ''seven'', ''eleven''];

// Remove item ''seven'' from array
var filteredAry = ary.filter(function(e) { return e !== ''seven'' })
//=> ["three", "eleven"]

// In ECMA6 (arrow function syntax):
var filteredAry = ary.filter(e => e !== ''seven'')

Esto hace uso de la función de filter en JS. Es compatible con IE9 y superior.

Lo que hace (desde el enlace doc)

filter () llama a una función de devolución de llamada proporcionada una vez para cada elemento de una matriz, y construye una nueva matriz de todos los valores para los que la devolución de llamada devuelve un valor que obliga a ser verdadero. la devolución de llamada se invoca solo para los índices de la matriz que tienen valores asignados; no se invoca para los índices que se han eliminado o que nunca se han asignado valores. Los elementos de la matriz que no pasan la prueba de devolución de llamada simplemente se omiten y no se incluyen en la nueva matriz.

Básicamente, esto es lo mismo que todos los demás for (var key in ary) { ... } solutions, excepto que el for in constructo es compatible a partir de IE6.

Básicamente, el filtro es un método de conveniencia que se ve mucho mejor (y es posible) en lugar de for in construct (AFAIK).

Answer 21

Una solución muy limpia que funciona en todos los navegadores y sin ningún marco es asignar una nueva matriz y simplemente devolverla sin el elemento que desea eliminar:

/**
 * @param {Array} array the original array with all items
 * @param {any} item the time you want to remove
 * @returns {Array} a new Array without the item
 */
var removeItemFromArray = function(array, item){
  /* assign a empty array */
  var tmp = [];
  /* loop over all array items */
  for(var index in array){
    if(array[index] !== item){
      /* push to temporary array if not like item */
      tmp.push(array[index]);
    }
  }
  /* return the temporary array */
  return tmp;
}

Answer 22

Usé la opción más votada y creé una función que limpiaría una matriz de palabras utilizando otra matriz de palabras no deseadas:

function cleanArrayOfSpecificTerms(array,unwantedTermsArray) {
  $.each(unwantedTermsArray, function( index, value ) {
    var index = array.indexOf(value);
    if (index > -1) {
      array.splice(index, 1);        
    }
  });
  return array;
}

Para usar, haga lo siguiente:

var notInclude = [''Not'',''No'',''First'',''Last'',''Prior'',''Next'', ''dogs'',''cats''];
var splitTerms = ["call", "log", "dogs", "cats", "topic", "change", "pricing"];

cleanArrayOfSpecificTerms(splitTerms,notInclude)

Answer 23

Variante de CoffeeScript + jQuery:

arrayRemoveItemByValue = (arr,value) ->
  r=$.inArray(value, arr)
  unless r==-1
    arr.splice(r,1)
  # return
  arr

console.log arrayRemoveItemByValue([''2'',''1'',''3''],''3'')

se elimina sólo uno, no todos.

Answer 24

Viendo que no hay uno bonito, aquí hay una función ES6 simple y reutilizable.

const removeArrayItem = (arr, itemToRemove) => {
  return arr.filter(item => item !== itemToRemove)
}

Uso:

const items = [''orange'', ''purple'', ''orange'', ''brown'', ''red'', ''orange'']
removeArrayItem(items, ''orange'')

Answer 25

indexOf es una opción, pero su implementación consiste básicamente en buscar el valor del arreglo completo, por lo que el tiempo de ejecución aumenta con el tamaño del arreglo. (así es en todos los navegadores, supongo, solo he comprobado Firefox).

No tengo un IE6 alrededor para verificarlo, pero lo llamaría una apuesta segura de que puedes verificar al menos un millón de elementos de matriz por segundo de esta manera en casi cualquier equipo cliente. Si [tamaño de matriz] * [búsquedas por segundo] puede crecer más de un millón, debería considerar una implementación diferente.

Básicamente, puedes usar un objeto para hacer un índice para tu matriz, así:

var index={''three'':0, ''seven'':1, ''eleven'':2};

Cualquier entorno de JavaScript sano creará un índice de búsqueda para dichos objetos, de modo que pueda traducir rápidamente una clave en un valor, sin importar cuántas propiedades tenga el objeto.

Este es solo el método básico. Dependiendo de su necesidad, puede combinar varios objetos y / o arreglos para hacer que los mismos datos se puedan buscar rápidamente para diferentes propiedades. Si especifica sus necesidades exactas, puedo sugerir una estructura de datos más específica.

Answer 26

//This function allows remove even array from array
var removeFromArr = function(arr, elem) { 
    var i, len = arr.length, new_arr = [],
    sort_fn = function (a, b) { return a - b; };
    for (i = 0; i < len; i += 1) {
        if (typeof elem === ''object'' && typeof arr[i] === ''object'') {
            if (arr[i].toString() === elem.toString()) {
                continue;
            } else {                    
                if (arr[i].sort(sort_fn).toString() === elem.sort(sort_fn).toString()) {
                    continue;
                }
            }
        }
        if (arr[i] !== elem) {
            new_arr.push(arr[i]);
        }
    }
    return new_arr;
}

Ejemplo de uso

var arr = [1, ''2'', [1 , 1] , ''abc'', 1, ''1'', 1];
removeFromArr(arr, 1);
//["2", [1, 1], "abc", "1"]

var arr = [[1, 2] , 2, ''a'', [2, 1], [1, 1, 2]];
removeFromArr(arr, [1,2]);
//[2, "a", [1, 1, 2]]

Answer 27

function removeFrmArr(array, element) {
  return array.filter(e => e !== element);
};
var exampleArray = [1,2,3,4,5];
removeFrmArr(a, 3);
// return value like this
//[1, 2, 4, 5]

Answer 28

let arr = [5, 15, 25, 30, 35];
console.log(arr); //result [5, 15, 25, 30, 35]
let index = arr.indexOf(30);

if (index > -1) {
   arr.splice(index, 1);
}
console.log(arr); //result [5, 15, 25, 35]

Answer 29

var index = array.indexOf(''item'');

if(index!=-1){

   array.splice(index, 1);
}

Answer 30

var remove = function(array, value) {
    var index = null;

    while ((index = array.indexOf(value)) !== -1)
        array.splice(index, 1);

    return array;
};