将JavaScript函数反向放置--雄辩的JavaScript Ch4

有人能告诉我在反转阵列上这个函数哪里出了问题吗？这是本书中的练习

我已经通过控制台检查了我的变量，循环似乎在工作，但最后数组索引似乎没有被覆盖，我不明白为什么

我想要的答案是：

var arrayValue = [1, 2, 3, 4, 5];
reverseArrayInPlace(arrayValue);
console.log(arrayValue);
// → [5, 4, 3, 2, 1]

“严格使用”；
var sampleArray=[1,3,5,7,9]；
函数反转arrayinplace（someArray）{
var MiddleIndex=（Math.floor（someArray.length/2））；
对于（var i=0；i正如其他人已经注意到的那样，您忘记了赋值，因为
currentValue=mirrorIndex；
只是更改
currentValue
的值，而不是数组中的元素本身。
temp
也是如此。更一般的是：不能将
数组
元素存储到变量中作为对该的引用de>数组

这样的元素

这也会使函数看起来过于复杂。这里有两种选择。第一种是通过存储一个值，替换元素，并将存储的值分配给另一个元素来完成交换。第二种是在一行中使用

数组。拼接

（请参阅）

用于执行3个就地反转功能

功能反转界面（arr）{
变量len=arr.length-1，mid=Math.floor（len/2），i=-1；
而（i++

---

正如其他人已经注意到的那样，您忘记了赋值，因为

currentValue=mirrorIndex；

只是更改

currentValue

的值，而不是数组本身中的元素。这同样适用于

temp

。更一般的是：不能将

数组

元素存储到变量中作为该

数组的引用

这样的元素

这也会使函数看起来过于复杂。这里有两种选择。第一种是通过存储一个值，替换元素，并将存储的值分配给另一个元素来完成交换。第二种是在一行中使用

数组。拼接

（请参阅）

用于执行3个就地反转功能

功能反转界面（arr）{
变量len=arr.length-1，mid=Math.floor（len/2），i=-1；
而（i++

---

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

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"

---

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

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"

---

嘿，这是我的解决方案，我认为它非常有效：

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;
}

函数反转平面（数组）{
对于（var i=0；i嘿，这是我的解决方案，我认为它非常有效：

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;
}

函数反转平面（数组）{
对于（var i=0；i来说，这个版本似乎做的是最低限度的

// 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]

//将第一个元素与最后一个元素交换，
//然后是第二个，从第二个到最后一个，等等。
//当索引在中间相遇或通过时退出。
var reverseArrayInPlace=函数（数组）{
对于（var left=0，rite=数组.length-1；left
这个版本似乎是在做最起码的事情

// 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]

//将第一个元素与最后一个元素交换，
//然后是第二个，从第二个到最后一个，等等。
//当索引在中间相遇或通过时退出。
var reverseArrayInPlace=函数（数组）{
对于（var left=0，rite=array.length-1；leftconst reverseArrayInPlace = (array) => {
    let result = [];
    for (const key of Object.keys(array)) {
        if (String(parseInt(key)) === key && parseInt(key) >= 0)
            result[array.length - key - 1] = array[key];
        else
            result[key] = array[key];
    }
    return result;
}

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 ]