Eliminar un elemento de la matriz usando UnderscoreJS

Digamos que tengo este código

var arr = [{id: 1, nombre: 'a'}, {id: 2, nombre: 'b'}, {id: 3, nombre: 'c'}];

y quiero eliminar el elemento con id = 3 de la matriz. ¿Hay alguna manera de hacer esto sin empalmar? ¿Puedes usar algo de subrayado o algo así?

¡Gracias!

Simplemente usando JavaScript simple, esto ya ha sido respondido: eliminar objetos de la matriz por propiedad del objeto .

Usando underscore.js, puede combinar .findWherecon .without:

var arr = [{
  id: 1,
  name: 'a'
}, {
  id: 2,
  name: 'b'
}, {
  id: 3,
  name: 'c'
}];

//substract third
arr = _.without(arr, _.findWhere(arr, {
  id: 3
}));
console.log(arr);

<script src="https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.8.3/underscore-min.js"></script>

Sin embargo, dado que de todos modos está creando una nueva matriz en este caso, simplemente puede usar _.filterla Array.prototype.filterfunción nativa (tal como se muestra en la otra pregunta). Entonces solo iteraría sobre la matriz una vez en lugar de potencialmente dos veces como aquí.

Si desea modificar la matriz en el lugar , debe usarla .splice. Esto también se muestra en la otra pregunta y la anulación de puntaje no parece proporcionar ninguna función útil para eso.

Puedes usar el subrayado .filter

    var arr = [{
      id: 1,
      name: 'a'
    }, {
      id: 2,
      name: 'b'
    }, {
      id: 3,
      name: 'c'
    }];

    var filtered = _(arr).filter(function(item) {
         return item.id !== 3
    });

También se puede escribir como:

var filtered = arr.filter(function(item) {
    return item.id !== 3
});

var filtered = _.filter(arr, function(item) {
    return item.id !== 3
});

Comprobar violín

También puedes usar .reject

Usar subrayado _.reject():

arr = _.reject(arr, function(d){ return d.id === 3; });

El subrayado tiene un método _without () perfecto para eliminar un elemento de una matriz, especialmente si tiene el objeto para eliminar.

Devuelve una copia de la matriz con todas las instancias de los valores eliminados.

_.without(["bob", "sam", "fred"], "sam");

=> ["bob", "fred"]

Funciona también con objetos más complejos.

var bob = { Name: "Bob", Age: 35 };
var sam = { Name: "Sam", Age: 19 };
var fred = { Name: "Fred", Age: 50 };

var people = [bob, sam, fred]

_.without(people, sam);

=> [{ Name: "Bob", Age: 35 }, { Name: "Fred", Age: 50 }];

Si no tiene el elemento para eliminar, solo una propiedad del mismo, puede usarlo _.findWherey luego _.without.

Tenga cuidado si está filtrando cadenas y buscando filtros que no distingan entre mayúsculas y minúsculas. _.without () distingue entre mayúsculas y minúsculas. También puede usar _.reject () como se muestra a continuación.

var arr = ["test","test1","test2"];

var filtered = _.filter(arr, function(arrItem) {
    return arrItem.toLowerCase() !== "TEST".toLowerCase();
});
console.log(filtered);
// ["test1", "test2"]

var filtered1 = _.without(arr,"TEST");
console.log(filtered1);
// ["test", "test1", "test2"]

var filtered2 = _.reject(arr, function(arrItem){ 
    return arrItem.toLowerCase() === "TEST".toLowerCase();
});
console.log(filtered2);
// ["test1", "test2"]

Otras respuestas crean una nueva copia de la matriz, si desea modificar la matriz en su lugar puede usar:

arr.splice(_.findIndex(arr, { id: 3 }), 1);

Pero eso supone que el elemento siempre se encontrará dentro de la matriz (porque si no se encuentra, eliminará el último elemento). Para estar seguro, puede usar:

var index = _.findIndex(arr, { id: 3 });
if (index > -1) {
    arr.splice(index, 1);
}

u otra forma práctica:

_.omit(arr, _.findWhere(arr, {id: 3}));

mis 2 centavos

Use puede usar el método de JavaScript simpleArray#filter como este:

var arr = [{id:1,name:'a'},{id:2,name:'b'},{id:3,name:'c'}];

var filteredArr = arr.filter(obj => obj.id != 3);

console.log(filteredArr);

O, use Array#reducey Array#concatmétodos como este:

var arr = [{id:1,name:'a'},{id:2,name:'b'},{id:3,name:'c'}];

var reducedArr = arr.reduce((accumulator, currObj) => {
  return (currObj.id != 3) ? accumulator.concat(currObj) : accumulator;
}, []);

console.log(reducedArr);

NOTA:

• Ambos son enfoques funcionales puros ( es decir , no modifican la matriz existente).
• No, en este enfoque se requiere una biblioteca externa (Vanilla JavaScript es suficiente).

Solía ​​probar este método

_.filter(data, function(d) { return d.name != 'a' });

También puede haber mejores métodos, como las soluciones anteriores proporcionadas por los usuarios.

Mediante el uso de underscore.js

var arr = [{id:1,name:'a'},{id:2,name:'b'},{id:3,name:'c'}];

var resultArr = _.reject(arr,{id:3});

console.log(resultArr);

El resultado será :: [{id:1name:'a'},{id:2,name:'c'}]

Puede usar el método de rechazo de subrayado, a continuación devolverá una nueva matriz que no tendrá una matriz con una coincidencia particular

arr = _.reject(arr, function(objArr){ return objArr.id == 3; });