Eliminar objeto de matriz usando JavaScript

¿Cómo puedo eliminar un objeto de una matriz? Deseo eliminar el objeto que incluye el nombre Kristiande someArray. Por ejemplo:

someArray = [{name:"Kristian", lines:"2,5,10"},
             {name:"John", lines:"1,19,26,96"}];

Quiero lograr:

someArray = [{name:"John", lines:"1,19,26,96"}];

Puede usar varios métodos para eliminar elementos de una matriz:

//1
someArray.shift(); // first element removed
//2
someArray = someArray.slice(1); // first element removed
//3
someArray.splice(0, 1); // first element removed
//4
someArray.pop(); // last element removed
//5
someArray = someArray.slice(0, a.length - 1); // last element removed
//6
someArray.length = someArray.length - 1; // last element removed

Si desea eliminar el elemento en la posición x, use:

someArray.splice(x, 1);

O

someArray = someArray.slice(0, x).concat(someArray.slice(-x));

Responda al comentario de @ chill182 : puede eliminar uno o más elementos de una matriz utilizando Array.filtero Array.splicecombinados con Array.findIndex(consulte MDN ), por ejemplo

// non destructive filter > noJohn = John removed, but someArray will not change
let someArray = getArray();
let noJohn = someArray.filter( el => el.name !== "John" ); 
log("non destructive filter > noJohn = ", format(noJohn));
log(`**someArray.length ${someArray.length}`);

// destructive filter/reassign John removed > someArray2 =
let someArray2 = getArray();
someArray2 = someArray2.filter( el => el.name !== "John" );
log("", "destructive filter/reassign John removed > someArray2 =", 
  format(someArray2));
log(`**someArray2.length ${someArray2.length}`);

// destructive splice /w findIndex Brian remains > someArray3 =
let someArray3 = getArray();
someArray3.splice(someArray3.findIndex(v => v.name === "Kristian"), 1);
someArray3.splice(someArray3.findIndex(v => v.name === "John"), 1);
log("", "destructive splice /w findIndex Brian remains > someArray3 =", 
  format(someArray3));
log(`**someArray3.length ${someArray3.length}`);

// Note: if you're not sure about the contents of your array, 
// you should check the results of findIndex first
let someArray4 = getArray();
const indx = someArray4.findIndex(v => v.name === "Michael");
someArray4.splice(indx, indx >= 0 ? 1 : 0);
log("", "check findIndex result first > someArray4 (nothing is removed) > ",
  format(someArray4));
log(`**someArray4.length (should still be 3) ${someArray4.length}`);

function format(obj) {
  return JSON.stringify(obj, null, " ");
}

function log(...txt) {
  document.querySelector("pre").textContent += `${txt.join("\n")}\n`
}

function getArray() {
  return [ {name: "Kristian", lines: "2,5,10"},
           {name: "John", lines: "1,19,26,96"},
           {name: "Brian", lines: "3,9,62,36"} ];
}

<pre>
**Results**

</pre>

Recomiendo usar lodash.js o sugar.js para tareas comunes como esta:

// lodash.js
someArray = _.reject(someArray, function(el) { return el.Name === "Kristian"; });

// sugar.js
someArray.remove(function(el) { return el.Name === "Kristian"; });

En la mayoría de los proyectos, es bastante útil tener un conjunto de métodos auxiliares proporcionados por bibliotecas como estas.

La solución limpia sería usar Array.filter:

var filtered = someArray.filter(function(el) { return el.Name != "Kristian"; }); 

El problema con esto es que no funciona en IE <9. Sin embargo, puede incluir código de una biblioteca de Javascript (por ejemplo, subrayado.js ) que implementa esto para cualquier navegador.

¿Qué tal esto?

$.each(someArray, function(i){
    if(someArray[i].name === 'Kristian') {
        someArray.splice(i,1);
        return false;
    }
});

Su "matriz" como se muestra es una sintaxis JavaScript no válida. Los corchetes {}son para objetos con pares de nombre / valor de propiedad, pero los corchetes []son para matrices, así:

someArray = [{name:"Kristian", lines:"2,5,10"}, {name:"John", lines:"1,19,26,96"}];

En ese caso, puede usar el .splice()método para eliminar un elemento. Para eliminar el primer elemento (índice 0), diga:

someArray.splice(0,1);

// someArray = [{name:"John", lines:"1,19,26,96"}];

Si no conoce el índice pero desea buscar en la matriz para encontrar el elemento con el nombre "Kristian" para eliminarlo, puede hacerlo:

for (var i =0; i < someArray.length; i++)
   if (someArray[i].name === "Kristian") {
      someArray.splice(i,1);
      break;
   }

EDITAR: Acabo de notar que su pregunta está etiquetada con "jQuery", por lo que puede probar el $.grep()método :

someArray = $.grep(someArray,
                   function(o,i) { return o.name === "Kristian"; },
                   true);

ES2015

let someArray = [
               {name:"Kristian", lines:"2,5,10"},
               {name:"John", lines:"1,19,26,96"},
               {name:"Kristian", lines:"2,58,160"},
               {name:"Felix", lines:"1,19,26,96"}
            ];

someArray = someArray.filter(person => person.name != 'John');

¡Eliminará a John !

Podrías usar array.filter ().

p.ej

        someArray = [{name:"Kristian", lines:"2,5,10"},
                     {name:"John", lines:"1,19,26,96"}];

        someArray = someArray.filter(function(returnableObjects){
               return returnableObjects.name !== 'Kristian';
        });

        //someArray will now be = [{name:"John", lines:"1,19,26,96"}];

Funciones de flecha:

someArray = someArray.filter(x => x.name !== 'Kristian')

He realizado una función dinámica que toma los objetos Matriz, Clave y valor y devuelve la misma matriz después de eliminar el objeto deseado:

function removeFunction (myObjects,prop,valu)
        {
             return myObjects.filter(function (val) {
              return val[prop] !== valu;
          });

        }

Ejemplo completo: DEMO

var obj = {
            "results": [
              {
                  "id": "460",
                  "name": "Widget 1",
                  "loc": "Shed"
              }, {
                  "id": "461",
                  "name": "Widget 2",
                  "loc": "Kitchen"
              }, {
                  "id": "462",
                  "name": "Widget 3",
                  "loc": "bath"
              }
            ]
            };


        function removeFunction (myObjects,prop,valu)
        {
             return myObjects.filter(function (val) {
              return val[prop] !== valu;
          });

        }


console.log(removeFunction(obj.results,"id","460"));

Esta es una función que me funciona:

function removeFromArray(array, value) {
    var idx = array.indexOf(value);
    if (idx !== -1) {
        array.splice(idx, 1);
    }
    return array;
}

También podrías intentar hacer algo como esto:

var myArray = [{'name': 'test'}, {'name':'test2'}];
var myObject = {'name': 'test'};
myArray.splice(myArray.indexOf(myObject),1);

someArray = jQuery.grep(someArray , function (value) {
        return value.name != 'Kristian';
});

Utilice la función de empalme en matrices. Especifique la posición del elemento de inicio y la longitud de la subsecuencia que desea eliminar.

someArray.splice(pos, 1);

Vote por UndercoreJS para un trabajo simple con matrices.

La función _.without () ayuda a eliminar un elemento:

 _.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
    => [2, 3, 4]

Con función de flecha ES 6

let someArray = [
                 {name:"Kristian", lines:"2,5,10"},
                 {name:"John", lines:"1,19,26,96"}
                ];
let arrayToRemove={name:"Kristian", lines:"2,5,10"};
someArray=someArray.filter((e)=>e.name !=arrayToRemove.name && e.lines!= arrayToRemove.lines)

La solución más simple sería crear un mapa que almacene los índices para cada objeto por nombre, de esta manera:

//adding to array
var newPerson = {name:"Kristian", lines:"2,5,10"}
someMap[ newPerson.name ] = someArray.length;
someArray.push( newPerson );

//deleting from the array
var index = someMap[ 'Kristian' ];
someArray.splice( index, 1 );

Aunque esto probablemente no sea tan apropiado para esta situación, descubrí el otro día que también puede usar la deletepalabra clave para eliminar un elemento de una matriz si no necesita alterar el tamaño de la matriz, por ejemplo

var myArray = [1,2,3];

delete myArray[1];

console.log(myArray[1]); //undefined

console.log(myArray.length); //3 - doesn't actually shrink the array down

Esta respuesta

for (var i =0; i < someArray.length; i++)
   if (someArray[i].name === "Kristian") {
      someArray.splice(i,1);
   }

no funciona para múltiples registros que cumplan la condición. Si tiene dos de estos registros consecutivos, solo se eliminará el primero y se saltará el otro. Tienes que usar:

for (var i = someArray.length - 1; i>= 0; i--)
   ...

en su lugar

Parece que hay un error en la sintaxis de su matriz, por lo que suponiendo que se refiere a una matriz en lugar de un objeto, Array.splice es su amigo aquí:

someArray = [{name:"Kristian", lines:"2,5,10"}, {name:"John", lines:"1,19,26,96"}];
someArray.splice(1,1)

Puede usar la función de mapa también.

someArray = [{name:"Kristian", lines:"2,5,10"},{name:"John",lines:"1,19,26,96"}];
newArray=[];
someArray.map(function(obj, index){
    if(obj.name !== "Kristian"){
       newArray.push(obj);
    }
});
someArray = newArray;
console.log(someArray);

También puedes usar some:

someArray = [{name:"Kristian", lines:"2,5,10"},
             {name:"John", lines:"1,19,26,96"}];

someArray.some(item => { 
    if(item.name === "Kristian") // Case sensitive, will only remove first instance
        someArray.splice(someArray.indexOf(item),1) 
})

Esto es lo que yo uso.

Array.prototype.delete = function(pos){
    this[pos] = undefined;
    var len = this.length - 1;
    for(var a = pos;a < this.length - 1;a++){
      this[a] = this[a+1];
    }
    this.pop();
  }

Entonces es tan simple como decir

var myArray = [1,2,3,4,5,6,7,8,9];
myArray.delete(3);

Reemplace cualquier número en lugar de tres. Después de la salida esperada debe ser:

console.log(myArray); //Expected output 1,2,3,5,6,7,8,9

Si desea eliminar todas las apariciones de un objeto determinado (basado en alguna condición), utilice el método de empalme de JavaScript dentro de a para el bucle.

Dado que la eliminación de un objeto afectaría la longitud de la matriz, asegúrese de disminuir el contador un paso, para que la verificación de longitud permanezca intacta.

var objArr=[{Name:"Alex", Age:62},
  {Name:"Robert", Age:18},
  {Name:"Prince", Age:28},
  {Name:"Cesar", Age:38},
  {Name:"Sam", Age:42},
  {Name:"David", Age:52}
];

for(var i = 0;i < objArr.length; i ++)
{
  if(objArr[i].Age > 20)
  {
    objArr.splice(i, 1);
    i--;  //re-adjust the counter.
  }
}

El fragmento de código anterior elimina todos los objetos con una edad superior a 20.

Use la función splice () de javascript.

Esto puede ayudar: http://www.w3schools.com/jsref/jsref_splice.asp

El empalme (i, 1) donde i es el índice incremental de la matriz eliminará el objeto. Pero recuerde que el empalme también restablecerá la longitud de la matriz, así que tenga cuidado con 'indefinido'. Usando su ejemplo, si elimina 'Kristian', en la próxima ejecución dentro del ciclo, seré 2 pero someArray tendrá una longitud de 1, por lo tanto, si intenta eliminar "John" obtendrá un error "indefinido" . Una solución a esto, aunque no elegante, es tener un contador separado para realizar un seguimiento del índice del elemento que se va a eliminar.

Devuelve solo objetos de la matriz cuya propiedad nameno es "Kristian"

var noKristianArray = $.grep(someArray, function (el) { return el.name!= "Kristian"; });

 var someArray = [
                {name:"Kristian", lines:"2,5,10"},
                {name:"John", lines:"1,19,26,96"},
                {name:"Kristian", lines:"2,58,160"},
                {name:"Felix", lines:"1,19,26,96"}
                ];
			 
var noKristianArray = $.grep(someArray, function (el) { return el.name!= "Kristian"; });

console.log(noKristianArray);

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

Estos conceptos usando Kendo Grid

var grid = $("#addNewAllergies").data("kendoGrid");

var selectedItem = SelectedCheckBoxList;

for (var i = 0; i < selectedItem.length; i++) {
    if(selectedItem[i].boolKendoValue==true)
    {
        selectedItem.length= 0;
    }
}

Supongo que las respuestas son muy ramificadas y anudadas.

Puede usar la siguiente ruta para eliminar un objeto de matriz que coincida con el objeto dado en la jerga moderna de JavaScript.

coordinates = [
    { lat: 36.779098444109145, lng: 34.57202827508546 },
    { lat: 36.778754712956506, lng: 34.56898128564454 },
    { lat: 36.777414146732426, lng: 34.57179224069215 }
];

coordinate = { lat: 36.779098444109145, lng: 34.57202827508546 };

removeCoordinate(coordinate: object) {
  const found = this.coordinates.find((obj) => obj === obj);
  if (found) {
    this.coordinates.splice(found, 1);
  }
}

this.removeCoordinate(coordinate);

Si desea acceder y eliminar el objeto de una matriz, simplemente puede intentar algo como esto.

// inside some function

let someArray = [ {"ColumnName" : "a", "PropertySerno" : 100005,"UpdateType" : 1},
                  {"ColumnName" : "b", "PropertySerno" : 100202,"UpdateType" : 1,
        "ShowRemoveButton" : true} ];
        
        for (let item of someArray) {
          delete item.ShowRemoveButton;
        }
        console.log(item.outputMappingData.Data);
        
//output will be like that = [ {"ColumnName" : "a", "PropertySerno" : 100005,"UpdateType" : 1},
//                             {"ColumnName" : "b", "PropertySerno" : 100202,"UpdateType" : 1 }];