如何在嵌套对象中移动元素位置？解决数组方法报错问题

Great question! The issue here is that even though your object uses numeric keys like an array, it's still a plain JavaScript object—so array methods like splice won't work directly. But we can adapt the array movement logic by first converting the object into a manageable array of entries, adjusting the order, then converting back to an object.

Here's a step-by-step solution: #

1. Extract the object's key-value pairs into an array (so we can use array methods to reorder).
2. Locate the entry you want to move, then use splice (just like your array function) to reposition it.
3. Convert the reordered array back into an object.

Working Code Example #

First, here's a reusable function that handles this:

function objectMove(obj, oldKey, newIndex) {
  // Convert the object to an array of [key, value] pairs
  const entries = Object.entries(obj);
  
  // Find the index of the entry with our target oldKey (note: keys are strings in entries)
  const oldIndex = entries.findIndex(([key]) => key === String(oldKey));
  
  // If the key doesn't exist, return a copy of the original object
  if (oldIndex === -1) {
    return {...obj};
  }
  
  // Move the entry in the entries array (same logic as your array function)
  const [movedEntry] = entries.splice(oldIndex, 1);
  entries.splice(newIndex, 0, movedEntry);
  
  // Convert the reordered entries back to an object
  return Object.fromEntries(entries);
}

How to Use It #

Apply it to your original object like this:

var obj = { 0:{id: 1, name: 'one'}, 1:{id: 2, name: 'two'}, 2:{id: 3, name: 'three'}, 3:{id: 4, name: 'four'} };
// Move the entry with key `1` to position 3 (the last index, matching your desired result)
var newObj = objectMove(obj, 1, 3);

console.log(newObj);
// Output: { 0:{id: 1, name: 'one'}, 1:{id: 3, name: 'three'}, 2:{id: 4, name: 'four'}, 3:{id: 2, name: 'two'} }

Legacy Environment Support #

If you need to support older browsers that don't have Object.entries or Object.fromEntries, use this version with Object.keys:

function objectMoveLegacy(obj, oldKey, newIndex) {
  const keys = Object.keys(obj);
  const oldIndex = keys.indexOf(String(oldKey));
  
  if (oldIndex === -1) {
    return Object.assign({}, obj);
  }
  
  // Remove the old key and insert it at the new index
  const movedKey = keys.splice(oldIndex, 1)[0];
  keys.splice(newIndex, 0, movedKey);
  
  // Build the new object in the reordered key sequence
  const newObj = {};
  keys.forEach(key => {
    newObj[key] = obj[key];
  });
  
  return newObj;
}

Key Notes #

• JavaScript objects (ES6+) preserve the order of numeric keys, so the reordered entries will maintain the sequence you want.
• We convert oldKey to a string because object keys are stored as strings internally, even if you define them as numbers.
• If newIndex is larger than the number of entries, splice will automatically add the moved entry to the end—just like your array function does.

内容的提问来源于stack exchange，提问作者Masha