JavaScript 函數到 reverseArrayInPlace — Eloquent JavaScript Ch4

Question

誰能告訴我這個函數在反轉數組上哪里出了問題？ 這是Eloquent JavaScript一書中的一個練習。

我已經通過控制台檢查了我的變量，循環似乎在工作，但最后數組索引似乎沒有被覆蓋，我不明白為什么！

我正在尋找的答案是：

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

 "use strict"; var sampleArray = [1,3,5,7,9]; function reverseArrayInPlace (someArray) { var MiddleIndex = (Math.floor(someArray.length/2)); for (var i = 0; i <= MiddleIndex-1; i++) { var currentValue = someArray[i]; var mirrorIndex = someArray[someArray.length -i -1]; var temp = currentValue; currentValue = mirrorIndex; mirrorIndex = temp; } return someArray; } console.log(reverseArrayInPlace(sampleArray));

Answer 1

正如其他人已經注意到的那樣，您忘記了賦值，因為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>

Answer 2

我們將創建一個以相反順序檢索元素的 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"

通過將下面的代碼添加到函數的中間，我們可以擴展它以在元素添加到底層數組時自動更新陰影，而無需再次調用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"

Answer 3

嘿，這是我的解決方案，我認為它很有效：

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

Answer 4

這個版本似乎是最低限度的。

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

Answer 5

這可能是一種可能的解決方案，但我不確定它是否會反過來。 由於我創建了一個映射來存儲值，因此將它們以相反的順序放置在原始數組中。

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

Answer 6

ECMAScript 2017 答案：（根據本書最新版本）

const reverseArrayInPlace = (array) => {
    let result = [];
    for (let index = 0; index < array.length; index++)
        if (index in array)
            result[array.length - index - 1] = array[index];
    return result;
}

//let myArray = [0, 1, 2, 3, undefined, 4, 5];
//myArray[100] = 100;
//reverseArray(myArray);
// → 100, <93 empty slots>, 5, 4, undefined, 3, 2, 1, 0"

---

更新：也適用於非整數索引

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

Answer 7

這是我的解決方案：

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

Answer 8

這是我在 eloquent 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 ]