将数组元素从一个数组位置移动到另一个数组位置 [英] Move an array element from one array position to another

问题描述

我很难弄清楚如何移动数组元素.例如，给定以下内容:

I'm having a hard time figuring out how to move an array element. For example, given the following:

var arr = [ 'a', 'b', 'c', 'd', 'e'];

如何编写一个函数将 'd' 移动到 'b' 之前?

How can I write a function to move 'd' before 'b'?

还是'a'在'c'之后?

移动后，应更新其余元素的索引.这意味着在移动后的第一个示例中，

After the move, the indices of the rest of the elements should be updated. This means in the first example after the move,

arr = ['a', 'd', 'b', 'c', 'e']

这看起来应该很简单，但我无法理解它.

This seems like it should be pretty simple, but I can't wrap my head around it.

推荐答案

如果你想要一个 npm 版本，array-move 是最接近这个答案的，尽管它不是相同的实现.有关更多详细信息，请参阅其用法部分.可以在 npm 上的 上找到此答案的先前版本(修改后的 Array.prototype.move)array.prototype.move.

If you'd like a version on npm, array-move is the closest to this answer, although it's not the same implementation. See its usage section for more details. The previous version of this answer (that modified Array.prototype.move) can be found on npm at array.prototype.move.

我在这个功能上取得了相当不错的成功:

I had fairly good success with this function:

function array_move(arr, old_index, new_index) {
    if (new_index >= arr.length) {
        var k = new_index - arr.length + 1;
        while (k--) {
            arr.push(undefined);
        }
    }
    arr.splice(new_index, 0, arr.splice(old_index, 1)[0]);
    return arr; // for testing
};

// returns [2, 1, 3]
console.log(array_move([1, 2, 3], 0, 1)); 

请注意，最后一个 return 仅用于测试目的:splice 就地对数组执行操作，因此不需要返回.通过扩展，这个 move 是一个就地操作.如果您想避免这种情况并返回副本，请使用 slice.

Note that the last return is simply for testing purposes: splice performs operations on the array in-place, so a return is not necessary. By extension, this move is an in-place operation. If you want to avoid that and return a copy, use slice.

单步执行代码:

1. 如果 new_index 大于数组的长度，我们希望(我假设)用新的 undefined 正确填充数组.这个小片段通过在数组上推送 undefined 来处理这个问题，直到我们有合适的长度.
2. 然后，在arr.splice(old_index, 1)[0]中，我们拼接出旧元素.splice 返回拼接出来的元素，但它在一个数组中.在我们上面的例子中，这是[1].因此，我们采用该数组的第一个索引来获取原始 1.
3. 然后我们使用 splice 将这个元素插入到 new_index 的位置.由于我们填充了上面的数组，如果 new_index >arr.length，它可能会出现在正确的位置，除非他们做了一些奇怪的事情，比如传入一个负数.

1. If new_index is greater than the length of the array, we want (I presume) to pad the array properly with new undefineds. This little snippet handles this by pushing undefined on the array until we have the proper length.
2. Then, in arr.splice(old_index, 1)[0], we splice out the old element. splice returns the element that was spliced out, but it's in an array. In our above example, this was [1]. So we take the first index of that array to get the raw 1 there.
3. Then we use splice to insert this element in the new_index's place. Since we padded the array above if new_index > arr.length, it will probably appear in the right place, unless they've done something strange like pass in a negative number.

一个更高级的版本来解释负指数:

A fancier version to account for negative indices:

function array_move(arr, old_index, new_index) {
    while (old_index < 0) {
        old_index += arr.length;
    }
    while (new_index < 0) {
        new_index += arr.length;
    }
    if (new_index >= arr.length) {
        var k = new_index - arr.length + 1;
        while (k--) {
            arr.push(undefined);
        }
    }
    arr.splice(new_index, 0, arr.splice(old_index, 1)[0]);
    return arr; // for testing purposes
};
    
// returns [1, 3, 2]
console.log(array_move([1, 2, 3], -1, -2));

哪个应该正确地考虑 array_move([1, 2, 3], -1, -2) 之类的事情(将最后一个元素移动到倒数第二个位置).结果应该是 [1, 3, 2].

Which should account for things like array_move([1, 2, 3], -1, -2) properly (move the last element to the second to last place). Result for that should be [1, 3, 2].

无论哪种方式，在您最初的问题中，您都会在 c 之后为 a 执行 array_move(arr, 0, 2).对于 b 之前的 d，你会做 array_move(arr, 3, 1).

Either way, in your original question, you would do array_move(arr, 0, 2) for a after c. For d before b, you would do array_move(arr, 3, 1).

这篇关于将数组元素从一个数组位置移动到另一个数组位置的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！