Supprimer un objet du tableau à l'aide de JavaScript

Comment supprimer un objet d'un tableau? Je souhaite supprimer l'objet contenant le nom Kristiande someArray. Par exemple:

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

Je veux réaliser:

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

Vous pouvez utiliser plusieurs méthodes pour supprimer des éléments d'un tableau:

//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 vous souhaitez supprimer l'élément à la position x, utilisez:

someArray.splice(x, 1);

Ou

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

Répondre au commentaire de @ chill182 : vous pouvez supprimer un ou plusieurs éléments d'un tableau en utilisant Array.filter, ou Array.splicecombiné avec Array.findIndex(voir MDN ), par exemple

// 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>

Je recommande d'utiliser lodash.js ou sugar.js pour des tâches courantes comme celle-ci:

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

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

dans la plupart des projets, disposer d'un ensemble de méthodes d'assistance fournies par des bibliothèques comme celles-ci est très utile.

La solution propre serait d'utiliser Array.filter:

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

Le problème avec cela est qu'il ne fonctionne pas sur IE <9. Cependant, vous pouvez inclure du code provenant d'une bibliothèque Javascript (par exemple underscore.js ) qui l'implémente pour n'importe quel navigateur.

Que dis-tu de ça?

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

Votre "tableau" comme indiqué est une syntaxe JavaScript non valide. Les crochets {}sont pour les objets avec des paires nom / valeur de propriété, mais les crochets []sont pour les tableaux - comme ceci:

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

Dans ce cas, vous pouvez utiliser la .splice()méthode pour supprimer un élément. Pour supprimer le premier élément (index 0), dites:

someArray.splice(0,1);

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

Si vous ne connaissez pas l'index mais que vous souhaitez rechercher dans le tableau pour trouver l'élément avec le nom "Kristian" à supprimer, vous pouvez:

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

EDIT: Je viens de remarquer que votre question est taguée avec "jQuery", vous pouvez donc essayer la $.grep()méthode :

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

Cela supprimera John !

Vous pouvez utiliser array.filter ().

par exemple

        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"}];

Fonctions fléchées:

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

J'ai créé une fonction dynamique qui prend les objets Array, Key et value et retourne le même tableau après avoir supprimé l'objet souhaité:

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

        }

Exemple complet: 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"));

C'est une fonction qui fonctionne pour moi:

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

Vous pouvez également essayer de faire quelque chose comme ceci:

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

Utilisez la fonction d'épissage sur les tableaux. Spécifiez la position de l'élément de départ et la longueur de la sous-séquence que vous souhaitez supprimer.

someArray.splice(pos, 1);

Votez pour l' UndercoreJS pour un travail simple avec des tableaux.

La fonction _ .without () permet de supprimer un élément:

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

Avec fonction flèche 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 solution la plus simple serait de créer une carte qui stocke les index de chaque objet par nom, comme ceci:

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

Bien que ce ne soit probablement pas approprié pour cette situation, j'ai découvert l'autre jour que vous pouvez également utiliser le deletemot clé pour supprimer un élément d'un tableau si vous n'avez pas besoin de modifier la taille du tableau, par exemple.

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

Cette réponse

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

ne fonctionne pas pour plusieurs enregistrements remplissant la condition. Si vous disposez de deux enregistrements consécutifs, seul le premier est supprimé et l'autre ignoré. Vous devez utiliser:

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

au lieu .

Il semble y avoir une erreur dans la syntaxe de votre tableau, donc en supposant que vous voulez dire un tableau par opposition à un objet, Array.splice est votre ami ici:

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

Vous pouvez également utiliser la fonction de carte .

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

Vous pouvez également utiliser 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) 
})

C'est ce que j'utilise.

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

C'est aussi simple que de dire

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

Remplacez n'importe quel nombre au lieu de trois. Après la sortie attendue devrait être:

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

Si vous souhaitez supprimer toutes les occurrences d'un objet donné (en fonction d'une condition), utilisez la méthode d'épissage javascript dans un pour la boucle.

Étant donné que la suppression d'un objet affecterait la longueur du tableau, assurez-vous de décrémenter le compteur d'une étape, afin que la vérification de la longueur reste intacte.

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.
  }
}

L'extrait de code ci-dessus supprime tous les objets dont l'âge est supérieur à 20 ans.

Utilisez la fonction splice () de javascript.

Cela peut aider: http://www.w3schools.com/jsref/jsref_splice.asp

splice (i, 1) où i est l'index incrémentiel du tableau supprimera l'objet. Mais rappelez-vous que l'épissure réinitialisera également la longueur du tableau, alors faites attention à «non défini». En utilisant votre exemple, si vous supprimez «Kristian», lors de la prochaine exécution dans la boucle, je serai 2 mais someArray aura une longueur de 1, donc si vous essayez de supprimer «John», vous obtiendrez une erreur «non définie» . Une solution à ce problème, quoique peu élégante, consiste à disposer d'un compteur séparé pour suivre l'index de l'élément à supprimer.

Renvoie uniquement les objets du tableau dont la propriété namen'est pas "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>

This Concepts using 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;
    }
}

Je suppose que les réponses sont très ramifiées et nouées.

Vous pouvez utiliser le chemin suivant pour supprimer un objet tableau qui correspond à l'objet donné dans le jargon JavaScript moderne.

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 vous voulez accéder et supprimer un objet d'un tableau, vous pouvez simplement essayer quelque chose comme ça.

// 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 }];