Ограничить вложенный массив рекурсивно JavaScript

Question

скажем, у меня есть данные:

const myArr = [
    {   
      id: '123',
      items: [{   
      id: '123',
      items: []
     },
     {   
      id: '123',
      items: []
     },
     {   
      id: '123',
      items: []
     }]
     },
     {   
      id: '123',
      items: []
     },
     {   
      id: '123',
      items: []
     }
    
]

Я хочу рекурсивно нарезать элементы. Скажем, если я хочу вернуть только счетчик 2, он должен отфильтровать первые «элементы» только по 2 записи, а вложенные элементы по 2 записи.

пока у меня есть этот код, и я уже очень запутался

const applyLimitRecursive = (arr) => {
  var result
  for (let i = 0; i < arr.length; i++) {
    if (!arr[i].items) {
      result = arr[i]
      break
    } else {
      result = applyLimitRecursive(arr[i].items)
      if (result) break
    }
  }
  return result
}

Answer 1

Если данные сериализуемы, вы можете использовать функцию возрождения JSON.parse. Если перебираемое значение является массивом, вернуть из него .slice(0, 2):

const result = JSON.parse(
  JSON.stringify(myArr),
  (_, val) => Array.isArray(val) ? val.slice(0, 2) : val
);

const myArr = [
  {   
    id: '123',
    items: [
      {
        id: 234,
        items: [
          { id: 5 },
          { id: 6 },
          { id: 7 },
        ]
      },
    ]
  }
];
const result = JSON.parse(
  JSON.stringify(myArr),
  (_, val) => Array.isArray(val) ? val.slice(0, 2) : val
);
console.log(result);

Или, чтобы сделать это более вручную:

const transform = (item) => {
  if (Array.isArray(item)) {
    return item.map(transform).slice(0, 2);
  }
  if (typeof item === 'object' && item !== null) {
    return Object.fromEntries(
      Object.entries(item).map(
        ([key, val]) => [key, transform(val)]
      )
    );
  }
  // primitives:
  return item;
};
const result = transform(myArr);

const myArr = [
  {   
    id: '123',
    items: [
      {
        id: 234,
        items: [
          { id: 5 },
          { id: 6 },
          { id: 7 },
        ]
      },
    ]
  }
];
const transform = (item) => {
  if (Array.isArray(item)) {
    return item.map(transform).slice(0, 2);
  }
  if (typeof item === 'object' && item !== null) {
    return Object.fromEntries(
      Object.entries(item).map(
        ([key, val]) => [key, transform(val)]
      )
    );
  }
  // primitives:
  return item;
};
const result = transform(myArr);
console.log(result);

Answer 2

Я не совсем уверен, что вы ищете, но я думаю, это оно?

function deeper(array, deep){
  if(array.length-1 < deep){
    return undefined;
  }
  const q = array[deep];
  if(typeof q === 'object' && q.items instanceof Array){
    return deeper(q.items, deep);
  }
  return q;
}
const myArr = [
  { // 0   
    id: '123a',
      items: [
        {   
          id: '123',
          items: ['zero', 'one', 2]
        },
      {   
        id: '123',
        items: []
      },
      {   
        id: '123',
        items: ['a']
     }]
   },
   { // 1 
     id: '123',
     items: [
       {
         id: '456',
         items : [
           {
             more: 'stuff',
             lame: false,
             id: '25',
             items: ['c', 'd']
           }
         ]
       },
       {
         id: '456',
         items : [
           {
             items: ['a', 'b']
           },
           {
             more: 'yup',
             lame: true,
             id: 789,
             items: ['see', 'one', 'test']
           }
         ]
       }
     ]
   },
   { // 2
     id: '123',
     items: []
   } 
]
console.log(deeper(myArr, 0));
console.log(deeper(myArr, 1));
console.log(deeper(myArr, 2));

Обратите внимание, что deep основано на индексе.