JavaScript function to reverseArrayInPlace -- Eloquent JavaS

正如其他人已经注意到的那样，您忘记了一个赋值，因为currentValue = mirrorIndex;只是更改了currentValue的值，而不是数组本身中的元素。temp也是如此。更通用：您不能将Array元素存储到变量中作为对该Array元素的引用。

它还会使您的函数看起来过于复杂。这里有两个选择。在第一个中，交换是通过存储一个值、替换元素并将存储的值分配给另一个元素来完成的。在场景中，使用Array.splice在一行中完成相同的操作（参见MDN）。

以下是对 3 个就地反向函数性能的测试。

function reverseInPlace(arr) {
 var len = arr.length-1, mid = Math.floor(len/2), i = -1;
 while( i++ < mid ) {
   var swap = arr[len-i]; // save swapvalue
   arr[len-i] = arr[i];   // assign current value to swap position
   arr[i] = swap;         // assign swapvalue to current position
 }
}
// Swapping in one line (using splice)
function reverseInPlace2(arr) {
 var mid = Math.floor(arr.length/2), i = -1;
 while( i++ < mid ) { arr[i] = arr.splice(-(i+1), 1, arr[i])[0]; }
}
// demo
var log = Helpers.log2Screen;
var arr = [1,2,3,4];
reverseInPlace(arr);
log( 'Even length: `reverseInPlace(arr) -&gt; [', arr, ']`' );
arr = [1,2,3,4,5,6,7];
reverseInPlace(arr);
log( 'Odd length: `reverseInPlace(arr) -&gt; [', arr, ']`' );
arr = [1,2,3,4,5];
reverseInPlace2(arr);
log( 'Use `Array.splice: reverseInPlace2(arr4) -&gt; [', arr, ']`' );
// clarification of what happens in your code
log(''n<b>Clarification of what happens in your code</b>');
var myArr = [1,2,3,4,5];
var el2 = myArr[2];
log('Assigned: `MyArr: ', myArr, ', el2: ', el2, '`'); 
log( 'Storing: `var el2 = myArr[2];`' );
el2 = myArr[0];
log( 'Assigning: `el2 = myArr[0];`' );
log( '`myArray` did not change `MyArr: ', myArr, '`' ); 
log( 'But `el2` did: ', '`el2: ', el2, '`' );

<!-- some helpers -->
<script src="https://rawgit.com/KooiInc/Helpers/master/Helpers-min.js"></script>

我们将创建一个影子数组，而不是反转数组，该数组以相反的顺序检索元素：

function reverse_shadow(arr) {
    var o = [];
    o.length = arr.length;
    arr.forEach(function(elt, i) {
        Object.defineProperty(o, i, { 
            get: function() { return arr[arr.length - i - 1]; } 
        });
    });
    return o;
}
var arr = [1, 2, 3, 4];
var reversed = reverse_shadow(arr);
>> reversed.join(' ')
<< "4 3 2 1"

通过将下面的代码添加到函数的中间，我们可以将其扩展为在将元素添加到底层数组时自动更新影子，而无需再次调用reverse_shadow：

Object.observe(arr, function(changes) {
    changes.forEach(function(change) {
        if (change.name === 'length') { o.length = arr.length; }
        else if (change.type === 'add') {
            Object.defineProperty(o, change.name, {
                get: function() { return arr[arr.length - change.name - 1]; }
            });
        }
    });
});
>> arr.push(5);
>> reversed.join(' ')
<< "5 4 3 2 1"

这是我的解决方案，我认为它运行良好：

function reverseInPlace(array) {
    for (var i = 0; i<array.length; i+=2) {
        array.unshift(array[i]);
    }
    array.splice(Math.floor(array.length/2), array.length/2);
    return array;
}

这个版本似乎在做最低限度的工作。

// Swap the first element with the last,
// then the 2nd with the 2nd-to-last, etc.
// Quit when the indices meet or pass in the middle.
var reverseArrayInPlace = function(array) {
  for(var left =0, rite = array.length-1; left < rite; left++, rite--){
    var leftcopy = array[left];
    array[left] = array[rite];
    array[rite] = leftcopy;
  }
}
var arrayValue = [1, 2, 3, 4, 5];
reverseArrayInPlace(arrayValue);
console.log(arrayValue);
// → [5, 4, 3, 2, 1]

这可能是一种可能的解决方案，但我不确定它是否相反。由于我创建了一个映射来存储值，因此将它们以相反的顺序放置在原始数组中。

function reverseArrayInPlace(array){
    var map = {};
  for(var i = 0; i < array.length; i++){
    map[i] = array[i];
  }
  for(var i = 0; i <= (array.length - 1); i++){
    array[i] = map[(array.length - 1) - i];
  }
  return array;
}

的解决方案：

function reverseArrayInPlace(arr){
  for(let i of [...arr]) {
    arr.unshift(i) 
    arr.pop()
 }
}
let arrayValue = [1, 2, 3, 4, 5];
reverseArrayInPlace(arrayValue);
console.log(arrayValue);

雄辩的JS中的任务解决方案（第3版）

let numArray = [1, 2, 3, 4, 5];
reverseArrayInPlace(numArray);
function reverseArrayInPlace(number) {
    let newArray = [];
    for (let numbers of number) {
        newArray.unshift(numbers);
    }
    console.log(newArray);
}
// -> [ 5, 4, 3, 2, 1 ]