Сделать рекурсивную функцию неизменной?

Question

У меня есть рекурсивная функция, которая удаляет элемент по id, также, если этот элемент вложен в дочерний массив, он переместит его на один уровень вверх, это в основном своего рода структура меню.Когда элемент удаляется, дети не выбрасываются, а остаются в исходном объекте.

Теперь это принимает параметр 'data' и манипулирует им, но Мне интересно, если этоможно преобразовать это в функцию, которая возвращает новый массив, сохраняя неизменность аргумента?

Это функция

function removeId(data, id, parent = null) {
  data.forEach((o, i) => {
    if (o.id && o.id === id) {
      if (parent) {
        o.children.forEach(c => parent.children.push(c));
      }
      data.splice(i, 1);
      return true;
    } else if (o.children) {
      removeId(o.children, id, o);
    }
  });
}

Это используемые тестовые данные

const data = [
  {
    id: 2,
    children: [
      {
        id: 1,
        children: []
      }
    ]
  },
  {
    id: 3,
    children: [],
  }
]

Функция вызывается следующим образом

data = removeId(data, itemIdToDelete)

Ожидаемый результат - новый (неизменяемый) массив со структурой предыдущего, кроме удаленных элементов (вложенных)

Это ожидаемый результат после запуска метода и передачи идентификатора 2, который будет удален

const data = [
  {
    id: 1,
    children: []
  },
  {
    id: 3,
    children: [],
  }
]

Я пробовал

• Преобразованиефункция с использованием Array.reduce () или Array.filter (), но она нарушает рекурсивность и возвращает неопределенное значение каждый раз.

Редактировать: Это не просто проблема глубокого клонирования, здесь есть логика, дляпример проверки, если родительесть дети.

Answer 1

Вы можете сделать это с помощью метода reduce и создать новый массив на каждом уровне рекурсии.

const data = [{"id":2,"children":[{"id":1,"children":[]}]},{"id":3,"children":[]}]

function removeId(data, id) {
  return data.reduce((r, e) => {
    // create shallow copy of the current object
    const o = Object.assign({}, e);
    
    // if object has children property
    // create nested copy of children with recursive call
    // where data param will now be children of the current element
    if(e.children) {
      o.children = removeId(e.children, id);
    }
    
    // if id of the current element is equal to target id
    // push(spread) its children to current accumulator - r
    // that will depend of the current recursion level
    // else just push current object shallow copy - o
    if (id == e.id) {
      r.push(...o.children)
    } else {
      r.push(o)
    }
    
    // return accumulator
    return r;
  }, [])
}

console.log(removeId(data, 1))
console.log(removeId(data, 3))
console.log(removeId(data, 2))

Answer 2

Вы можете сделать это, рекурсивно создавая массив

const data = [
{
id: 2,
children: [
  {
    id: 1,
    children: []
  }
]
},
{
id: 3,
children: [],
}
];

function removeData(myarray, removable) {
 var branch = [];
 var datas= {};
 myarray.forEach((dat, key) => {
  if(dat.id != removable) {
     datas.id = dat.id;
     datas.children = [];
  }

 if(dat.children.length >0) {
       var children =   removeData(dat.children, removable);
       if(children && datas.id) {
            datas.children = children;
        } else {
             datas = children[0];
        } 
    }
    if(datas.children || datas.id) {
        branch.unshift(datas);
        datas ={};
    }   
 });
 return branch;
 }

 console.log(JSON.stringify(removeData(data, 2)));

http://jsfiddle.net/djky4gtq/3/

Answer 3

Вместо этого вы можете сделать это с генераторами, и, таким образом, избежать всего этого толчка.yield* затем можно использовать для вывода дочерних данных на уровень.

const data = [{"id":2,"children":[{"id":1,"children":[]}]},{"id":3,"children":[]}]

function * _removeId(data, id){
  for(o of data){
    if(o.id===id) yield* o.children;
    else yield Object.assign({},o,{children: removeId(o.children, id)});
  }
}

function removeId(data, id){
  return Array.from(_removeId(data, id));
}

console.log(removeId(data,1));
console.log(removeId(data,2));
console.log(removeId(data,3));

В основном yield* переносит итерацию массива на другой вызов функции, поэтому вставляет дочерние элементы в последовательность вместо корневого элемента, если идентификатор совпадает.Это также означает, что нет необходимости передавать родительский объект.Object.assign имеет дело с клонированием объекта, а Array.from обеспечивает каждый раз новый объект массива.