Javascript access deep child object by array of index numbers and assign new value

Question

const newFolders = [{name:'new1'},{name:'new2'}]
let folders = [
  {
    name: 'root',
    children:[
      {name:'folder1'},
      {
        name:'folder2',
        children:[
          {name: 'folder2.1'},
          {
            name: 'folder2.2',
            children: [
              {name:'target folder'}
            ]
          },
          {name: 'folder2.3'},
        ]
      },
      {name:'folder3'}
    ]
  }
]

// I don't want to use the below line to assign the newFolders variable to the target object
folders[0].children[1].children[1].children[0].children = newFolders;

// instead I have below
const child_index_map = [0,1,1,0]; // it should be any length for future access

// what I tried is (unsuccessful)
let temp = folders;
child_index_map.forEach((i, index)=>{
  temp = temp[i].children;
  if(index === child_index_map.length - 1){
    temp = newFolders;
  }
});
let folders = temp;

This is my folder structure and it should be any number of childrens.
I want to access the {name:'target folder'} object and assign newFolders to the object, but not the typical way like folders[0].children[1].children[1].children[0].children = newFolders;
instead of the above, I have index array const child_index_map = [0,1,1,0]

is there any possible way

Expected result

let folders = [
  {
    name: 'root',
    children:[
      {name:'folder1'},
      {
        name:'folder2',
        children:[
          {name: 'folder2.1'},
          {
            name: 'folder2.2',
            children: [
              {
                name:'target folder',
                children: [{name:'new1'},{name:'new2'}] // <--- this
              }
            ]
          },
          {name: 'folder2.3'},
        ]
      },
      {name:'folder3'}
    ]
  }
]

This might help: [How can I access and process nested objects, arrays or JSON?](https://stackoverflow.com/q/11922383/218196) — Felix Kling, Jul 26 '21 at 09:15

score 1 · Accepted Answer · answered Jul 26 '21 at 09:20

There were some issues with the code in array.forEach area.

const newFolders = [{ name: 'new1' }, { name: 'new2' }]
let folders = [
  {
    name: 'root',
    children: [
      { name: 'folder1' },
      {
        name: 'folder2',
        children: [
          { name: 'folder2.1' },
          {
            name: 'folder2.2',
            children: [
              { name: 'target folder' }
            ]
          },
          { name: 'folder2.3' },
        ]
      },
      { name: 'folder3' }
    ]
  }
]

// I don't want to use the below line to assign the newFolders variable to the target object
// folders[0].children[1].children[1].children[0].children = newFolders;

// instead I have below
const child_index_map = [0, 1, 1, 0]; // it should be any length for future access
// what I tried is (unsuccessful) => Is successful now
let temp = folders;
child_index_map.forEach((i, index) => {
  temp = temp[i];
  if (index === child_index_map.length - 1) {
    temp.children = newFolders;
  }
  if (temp.children) {
    temp = temp.children;
  }
});
// There is no need to update your floders variable.
// folders = temp;
console.log(folders);

You save my time @Nitheesh. works exactly what i want. Thank you so much. — Manojkumar, Jul 26 '21 at 11:32
@Manojkumar you are welcome. Please approve the answer if this meets your requirement. Happy to have an upvot aswell. — Nitheesh, Jul 26 '21 at 11:35

score 0 · Answer 2 · answered Jul 26 '21 at 09:09

You can use a recursive function to find the folder and then modify it.

const newFolders = [{name:'new1'},{name:'new2'}]
let folders = [
  {
    name: 'root',
    children:[
      {name:'folder1'},
      {
        name:'folder2',
        children:[
          {name: 'folder2.1'},
          {
            name: 'folder2.2',
            children: [
              {name:'target folder'}
            ]
          },
          {name: 'folder2.3'},
        ]
      },
      {name:'folder3'}
    ]
  }
]

const child_index_map = [0,1,1,0];

const getParentFolder = (folders, childMap, currentIndex) => {
  if(currentIndex === childMap.length - 1) return folders;
  if(Array.isArray(folders)) return getParentFolder(folders[childMap[currentIndex]], childMap, currentIndex+1);
  
  return getParentFolder(folders.children[childMap[currentIndex]], childMap, currentIndex+1);
}

const parentFolder = getParentFolder(folders, child_index_map, 0);
parentFolder.children = newFolders;

console.log(folders)

muhammed ikinci · Answer 3 · 2021-07-26T09:42:12.630

You can change the attachFolderName variable what you want.

let folders = [
  {
    name: 'root',
    children:[
      {name:'folder1'},
      {
        name:'folder2',
        children:[
          {name: 'folder2.1'},
          {
            name: 'folder2.2',
            children: [
              {
                name:'target folder',
                children: [{name:'new1'},{name:'new2'}] // <--- this
              }
            ]
          },
          {name: 'folder2.3'},
        ]
      },
      {name:'folder3'}
    ]
  }
]

let findAndAdd = (data, obj, search) => {
    function recursiveSearch (child) {
        if (child.children) {
            let filtered = child.children.find((f) => {
                return f.name === search
            })

            if (filtered) {
                if (!filtered.children)
                    filtered.children = [obj]
                else
                    filtered.children.push(obj)
                
                return;
            }

            child.children.forEach((c) => {
                recursiveSearch(c)
            })
        }
    }

    recursiveSearch(data[0])
}

let attachFolderName = "target folder"

findAndAdd(folders, {name: "new test with recursive"}, attachFolderName)

console.log(folders)

Javascript access deep child object by array of index numbers and assign new value

3 Answers3