Das Löschen von einem Objekt mit Hilfe von JavaScript

stimmen
17

Ich habe ein Objekt, wie hier gezeigt:

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

Und ich habe Pfad als String:

var path = 0-0-1.

Ich habe, um das Objekt zu löschen:

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

Die ich, indem Sie tun so,

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

Aber ich will es dynamisch tun. Da Pfadzeichenfolge kann alles sein, möchte ich die oben ‚‘ Betreiber und Spleiß Definition dynamisch an bestimmtem Ort spleißen erstellt werden.

Veröffentlicht am 18/12/2018 um 11:13
quelle vom benutzer
In anderen Sprachen...                            


5 antworten

stimmen
17

Sie könnten die Indizes durch das Speichern des letzten Index und die Rückkehr der Kinder des aktuellen Index reduzieren. Später Spleiß mit dem letzten Index.

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

Beantwortet am 18/12/2018 um 11:19
quelle vom benutzer

stimmen
4

Sie könnten Ihre geteilt pathund verwenden Sie die Teile, etwa so:

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]);
Beantwortet am 18/12/2018 um 11:18
quelle vom benutzer

stimmen
2

Sie könnten eine rekursive Funktion schreiben, die die Hierarchie fährt nach unten, bis der Pfad zur Verfügung steht. Unten ist ein sehr minimal-Schnipsel.

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

Beantwortet am 18/12/2018 um 11:25
quelle vom benutzer

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

Beantwortet am 18/12/2018 um 12:04
quelle vom benutzer

stimmen
0

Wenn der Pfad immer von 3 (oder weniger) Indizes zusammengesetzt werden wird können Sie es leicht wie folgt aus:

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

Wenn der Pfad von vielleicht weniger als 3 Teilen zusammengesetzt werden wird können Sie die Funktion anpassen deleteByPathFälle zu behandeln , basierend auf der Anzahl von Teilen.

wenn der Pfad willkürlich sein wird und beliebig lang sein können , können Sie die justieren deleteByPathFunktion rekursiv wie folgt aus :

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);
   }
}
Beantwortet am 18/12/2018 um 11:22
quelle vom benutzer

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