Suppression d'un objet en utilisant JavaScript

voix
17

J'ai un objet comme indiqué:

const arr = [
  {
    name: 'FolderA',
    child: [
      {
        name: 'FolderB',
        child: [
          {
            name: 'FolderC0',
            child: [],
          },
          {
            name: 'FolderC1',
            child: [],
          },
        ],
      },
    ],
  },
  {
    name: 'FolderM',
    child: [],
  },
];

Et je voie sous forme de chaîne:

var path = 0-0-1.

Je dois supprimer l'objet:

{
    name: 'FolderC1',
    child: [],
 },

Ce que je peux le faire en faisant,

arr[0].child[0].splice(1, 1);

Mais je veux le faire dynamiquement. Puisque la chaîne de chemin peut être quelque chose, je veux ce qui précède. » l'opérateur et la définition de raccordement à créer dynamiquement pour raccorder un endroit donné.

Créé 18/12/2018 à 11:13
source utilisateur
Dans d'autres langues...                            


5 réponses

voix
17

Vous pouvez réduire les indices en enregistrant le dernier indice et le retour des enfants de l'indice réel. épissures plus tard avec le dernier indice.

function deepSplice(array, path) {
    var indices = path.split('-'),
        last = indices.pop();

    indices
        .reduce((a, i) => a[i].child, array)
        .splice(last, 1);
}

const array = [{ name: 'FolderA', child: [{ name: 'FolderB', child: [{ name: 'FolderC0', child: [] }, { name: 'FolderC1', child: [] }] }] }, { name: 'FolderM', child: [] }];

deepSplice(array, "0-0-1");
console.log(array);
.as-console-wrapper { max-height: 100% !important; top: 0; }

Créé 18/12/2018 à 11:19
source utilisateur

voix
4

Vous pouvez diviser votre pathet utiliser les pièces, comme ceci:

let path = '0-0-1';
let parts = path.split('-');

// Call your splice using your parts (unsure if your '1' is the index, or deleteCount).

// If parts[2] is the index
arr[parts[0]].child[parts[1]].splice(parts[2], 1);

// If parts[2] is the deleteCount:
arr[parts[0]].child[parts[1]].splice(1, parts[2]);
Créé 18/12/2018 à 11:18
source utilisateur

voix
2

Vous pouvez écrire une fonction récursive qui se déplace dans la hiérarchie jusqu'à ce que le chemin est disponible. Ci-dessous un extrait très minime.

const arr = [
  {
    name: 'FolderA',
    child: [
      {
        name: 'FolderB',
        child: [
          {
            name: 'FolderC0',
            child: [],
          },
          {
            name: 'FolderC1',
            child: [],
          },
        ],
      },
    ],
  },
  {
    name: 'FolderM',
    child: [],
  },
];

let ar_path = "0-0-1";

function deleteRecursive(arr, path) {
  if(Array.isArray(arr) && path.length > 0){
     const index = Number(path.shift());
     if (path.length > 0) 
        deleteRecursive(arr[index].child, path)
     else 
        arr.slice(index, 1);
  } else {
     console.log('invalid');
  }
}


deleteRecursive(arr, ar_path.split('-'))

console.log(arr);

Créé 18/12/2018 à 11:25
source utilisateur

voix
0

//Variable setup:
const arr = [
    {
        name: 'FolderA',
        child: [
            {
                name: 'FolderB',
                child: [
                    {
                        name: 'FolderC0',
                        child: [],
                    },
                    {
                        name: 'FolderC1',
                        child: [],
                    },
                ],
            },
        ],
    },
    {
        name: 'FolderM',
        child: [],
    },
];
const path = "0-0-1";
//Break the path into pieces to iterate through:
const pathArray = path.split("-");
//Javascript assignments are by reference, so arrayToManage is going to be an internal piece within the original array
let arrayToManage = arr;
//We are going to iterate through the children of the array till we get above where we want to remove
while(pathArray.length > 1){
    const key = parseInt(pathArray.shift());
    arrayToManage = arrayToManage[key].child;
}
//Get the last position of the last array, where we want to remove the item
const key = parseInt(pathArray.shift());
arrayToManage.splice(key,1);
//And because it's all by reference, changed we made to arrayToManage were actually made on the arr object
console.log("end result:", JSON.stringify(arr));

Créé 18/12/2018 à 12:04
source utilisateur

voix
0

Si le chemin est toujours va être composé de 3 indices (ou moins), vous pouvez le faire facilement comme ce qui suit:

function deleteByPath(arr, path) {
   const index = path.split('-').map((x) => +x);
   if ( index.length < 1) {
      return null;
   } else if ( 1 === index.length ) {
     return arr.splice(index[0], 1);
   } else if ( 2 === index.length ) {
     return arr[index[0]].child.splice(index[1], 1);
   } else {
     return arr[index[0]].child[index[1]].child.splice(index[2], 1);
   }
}

const arr = [
  {
    name: 'FolderA',
    child: [
      {
        name: 'FolderB',
        child: [
          {
            name: 'FolderC0',
            child: [],
          },
          {
            name: 'FolderC1',
            child: [],
          },
        ],
      },
    ],
  },
  {
    name: 'FolderM',
    child: [],
  },
];

console.log(deleteByPath(arr, "0-0-1"));
console.log(deleteByPath(arr, "0-1"));
console.log(deleteByPath(arr, "0"));

Si le chemin va être composé de peut - être moins de 3 parties , vous pouvez régler la fonction deleteByPathpour traiter les cas en fonction du nombre de pièces.

si le chemin va être arbitraire et peut avoir une longueur , vous pouvez régler la deleteByPathfonction récursive comme ce qui suit:

function deleteByIndexRecursive(arr, index, current) {
  return current+1 < index.length ? deleteByIndexRecursive(arr.child[index[current]], current+1) : arr.child.splice(index[current], 1); 
}
function deleteByPath(arr, path) {
   const index = path.split('-').map((x) => +x);
   if ( 1>index.length) {
     return null;
   } else if ( 1===index.length) {
     return arr.splice(index[0], 1);
   } else {
     return deleteByIndexRecursive(arr[index[0]], index, 1);
   }
}
Créé 18/12/2018 à 11:22
source utilisateur

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more