如何在不使用庫的情況下反轉 JavaScript 中的數組？

Question

我正在使用array按順序保存一些數據，我想添加一個用戶可以反轉列表的功能。 我想不出任何可能的方法，所以如果有人知道如何，請幫忙。

Answer 1

Javascript 有一個reverse()方法，你可以在數組中調用它

var a = [3,5,7,8];
a.reverse(); // 8 7 5 3

不確定這是否是您所說的“您不能使用的庫”的意思，我猜這與練習有關。 如果是這樣，您可以實現自己的.reverse()版本

function reverseArr(input) {
    var ret = new Array;
    for(var i = input.length-1; i >= 0; i--) {
        ret.push(input[i]);
    }
    return ret;
}

var a = [3,5,7,8]
var b = reverseArr(a);

請注意，內置的.reverse()方法對原始數組進行操作，因此您不需要重新分配a 。

Answer 2

Array.prototype.reverse()是完成這項工作所需的全部。 請參閱兼容性表。

 var myArray = [20, 40, 80, 100]; var revMyArr = [].concat(myArray).reverse(); console.log(revMyArr); // [100, 80, 40, 20]

Answer 3

這是一種實用的方法。

const array = [1,2,3,4,5,6,"taco"];

function reverse(array){
  return array.map((item,idx) => array[array.length-1-idx])
}

Answer 4

20字節

let reverse=a=>[...a].map(a.pop,a)

Answer 5

const original = [1, 2, 3, 4];
const reversed = [...original].reverse(); // 4 3 2 1

簡明扼要，原汁原味。

Answer 6

reveresed = [...array].reverse()

Answer 7

我見過的最短的反向方法是這個：

let reverse = a=>a.sort(a=>1)

Answer 8

**

不使用逆向法的最短逆向數組法：

**

 var a = [0, 1, 4, 1, 3, 9, 3, 7, 8544, 4, 2, 1, 2, 3];

 a.map(a.pop,[...a]); 
// returns [3, 2, 1, 2, 4, 8544, 7, 3, 9, 3, 1, 4, 1, 0]

a.pop 方法取出最后一個元素並使用擴展運算符 () 放在前面

MDN 鏈接供參考：

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop

Answer 9

兩種方式：

1. 反循環

   function reverseArray(a) { var rA = [] for (var i = a.length; i > 0; i--) { rA.push(a[i - 1]) } return rA; }

2. 使用.reverse()

    function reverseArray(a) { return a.reverse() }

Answer 10

這就是你想要的：

array.reverse();

演示

Answer 11

我已經對解決方案進行了一些測試，這些解決方案不僅可以反轉數組，還可以復制它。 這是測試代碼。 reverse2方法是 Chrome 中最快的方法，但在 Firefox 中， reverse方法是最快的。

var array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

var reverse1 = function() {
  var reversed = array.slice().reverse();
};

var reverse2 = function() {
  var reversed = [];
  for (var i = array.length - 1; i >= 0; i--) {
    reversed.push(array[i]);
  }
};

var reverse3 = function() {
  var reversed = [];
  array.forEach(function(v) {
    reversed.unshift(v);
  });
};

console.time('reverse1');
for (var x = 0; x < 1000000; x++) {
  reverse1();
}
console.timeEnd('reverse1'); // Around 184ms on my computer in Chrome

console.time('reverse2');
for (var x = 0; x < 1000000; x++) {
  reverse2();
}
console.timeEnd('reverse2'); // Around 78ms on my computer in Chrome

console.time('reverse3');
for (var x = 0; x < 1000000; x++) {
  reverse3();
}
console.timeEnd('reverse3'); // Around 1114ms on my computer in Chrome

Answer 12

這是一個不需要臨時數組的版本。

function inplaceReverse(arr) {
  var i = 0;
  while (i < arr.length - 1) {
    arr.splice(i, 0, arr.pop());
    i++;
  }
  return arr;
}

// Useage:
var arr = [1, 2, 3];
console.log(inplaceReverse(arr)); // [3, 2, 1]

Answer 13

53 字節

function reverse(a){
    for(i=0,j=a.length-1;i<j;)a[i]=a[j]+(a[j--]=a[i++],0)
}

只是為了好玩，這里有一個比原生.reverse方法更快的替代實現。

Answer 14

你可以做

var yourArray = ["first", "second", "third", "...", "etc"]
var reverseArray = yourArray.slice().reverse()

console.log(reverseArray)

你會得到

["etc", "...", "third", "second", "first"]

Answer 15

> var arr = [1,2,3,4,5,6];
> arr.reverse();
  [6, 5, 4, 3, 2, 1]

Answer 16

array.reverse() 

以上將反轉您的數組但修改原始數組。 如果您不想修改原始數組，那么您可以這樣做：

var arrayOne = [1,2,3,4,5];

var reverse = function(array){
    var arrayOne = array
    var array2 = [];

    for (var i = arrayOne.length-1; i >= 0; i--){
      array2.push(arrayOne[i])
    } 
    return array2
}

reverse(arrayOne)

Answer 17

function reverseArray(arr) {
    let reversed = [];
    for (i = 0; i < arr.length; i++) { 
    reversed.push((arr[arr.length-1-i]))
    }
  return reversed;
}

Answer 18

使用.pop() 方法和 while 循環。

var original = [1,2,3,4];
var reverse = [];
while(original.length){
    reverse.push(original.pop());
}

輸出：[4,3,2,1]

Answer 19

我不確定圖書館是什么意思，但這是我能想到的最佳方式：

// return a new array with .map()
const ReverseArray1 = (array) => {
    let len = array.length - 1;

    return array.map(() => array[len--]);
}

console.log(ReverseArray1([1,2,3,4,5])) //[5,4,3,2,1]

// initialize and return a new array
const ReverseArray2 = (array) => {
    const newArray = [];
    let len = array.length;

    while (len--) {
        newArray.push(array[len]);
    }

    return newArray;
}

console.log(ReverseArray2([1,2,3,4,5]))//[5,4,3,2,1]

// use swapping and return original array
const ReverseArray3 = (array) => {
    let i = 0;
    let j = array.length - 1;

    while (i < j) {
        const swap = array[i];
        array[i++] = array[j];
        array[j--] = swap;
    }

    return array;
}
console.log(ReverseArray3([1,2,3,4,5]))//[5,4,3,2,1]

// use .pop() and .length
const ReverseArray4 = (array) => {
    const newArray = [];

    while (array.length) {
        newArray.push(array.pop());
    }

    return newArray;
}
console.log(ReverseArray4([1,2,3,4,5]))//[5,4,3,2,1]

Answer 20

使用函數式編程反轉數組的純函數：

var a = [3,5,7,8];

// ES2015
function immutableReverse(arr) {
  return [ ...a ].reverse();
}

// ES5
function immutableReverse(arr) {
  return a.concat().reverse()
}

Answer 21

正如其他人提到的，您可以在數組對象上使用.reverse() 。

但是，如果您關心保留原始對象，則可以改用reduce ：

const original = ['a', 'b', 'c'];
const reversed = original.reduce( (a, b) => [b].concat(a) );
//                                           ^
//                                           |
//                                           +-- prepend b to previous accumulation

// original: ['a', 'b', 'c'];
// reversed: ['c', 'b', 'a'];

Answer 22

也可以使用map方法來實現。

[1, 2, 3].map((value, index, arr) => arr[arr.length - index - 1])); // [3, 2, 1]

或者使用 reduce （稍微長一點的方法）

[1, 2, 3].reduce((acc, curr, index, arr) => {
    acc[arr.length - index - 1] = curr;
    return acc;
}, []);

Answer 23

通過變量交換（可變）就地反轉

const myArr = ["a", "b", "c", "d"];
for (let i = 0; i < (myArr.length - 1) / 2; i++) {  
    const lastIndex = myArr.length - 1 - i; 
    [myArr[i], myArr[lastIndex]] = [myArr[lastIndex], myArr[i]] 
}

Answer 24

使用sort方法反轉

• 這是一種更簡潔的方法。

 const resultN = document.querySelector('.resultN'); const resultL = document.querySelector('.resultL'); const dataNum = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; const dataLetters = ['a', 'b', 'c', 'd', 'e']; const revBySort = (array) => array.sort((a, b) => a < b); resultN.innerHTML = revBySort(dataNum); resultL.innerHTML = revBySort(dataLetters);

 <div class="resultN"></div> <div class="resultL"></div>

Answer 25

使用 ES6 剩余運算符和箭頭函數。

const reverse = ([x, ...s]) => x ? [...reverse(s), x] : [];
reverse([1,2,3,4,5]) //[5, 4, 3, 2, 1]

Answer 26

使用交換並返回原始數組。

 const reverseString = (s) => { let start = 0, end = s.length - 1; while (start < end) { [s[start], s[end]] = [s[end], s[start]]; // swap start++, end--; } return s; }; console.log(reverseString(["s", "t", "r", "e", "s", "s", "e", "d"]));

Answer 27

實際上reverse()在某些情況下可能不起作用，所以你必須先做一個如下的做作

let a = [1, 2, 3, 4];
console.log(a);  // [1,2,3,4]
a = a.reverse();
console.log(a); // [4,3,2,1]

或使用連接

let a = [1, 2, 3, 4];
console.log(a, a.concat([]).reverse());  // [1,2,3,4], [4,3,2,1]

Answer 28

不使用 push() 怎么辦！

使用 XOR 的解決方案！

var myARray = [1,2,3,4,5,6,7,8];

function rver(x){
    var l = x.length;
    for(var i=0; i<Math.floor(l/2); i++){

        var a = x[i];
        var b = x[l-1-i];

        a = a^b;
        b = b^a;
        a = a^b;

        x[i] = a;
        x[l-1-i] = b;
    }

    return x;

}

console.log(rver(myARray));

Answer 29

JavaScript 在 Array 上已經有 reverse() 方法，所以你不需要做那么多！

假設您有以下數組：

var arr = [1, 2, 3, 4, 5];

現在只需這樣做：

arr.reverse();

結果是：

[5, 4, 3, 2, 1];

但這基本上改變了原始數組，您可以編寫一個函數並用它返回一個新數組，如下所示：

function reverse(arr) {
  var i = arr.length, reversed = [];
  while(i) {
    i--;
    reversed.push(arr[i]);
  }
  return reversed;
}

或者像這樣簡單地改變 Array 的 JavaScript 內置方法：

function reverse(arr) {
  return arr.slice().reverse();
}

你可以這樣稱呼它：

reverse(arr); //return [5, 4, 3, 2, 1];

如前所述，主要區別在於第二種方式，您不接觸原始數組...

Answer 30

這個怎么樣？：

  function reverse(arr) {
    function doReverse(a, left, right) {
      if (left >= right) {
        return a;
      }
      const temp = a[left];
      a[left] = a[right];
      a[right] = temp;
      left++;
      right--;
      return doReverse(a, left, right);
    }

    return doReverse(arr, 0, arr.length - 1);
  }

  console.log(reverse([1,2,3,4]));

https://jsfiddle.net/ygpnt593/8/

Answer 31

此函數適用於索引之間可能存在間隙的數組。

function reverse( a ) {
    var b = [], c = [] ;
    a.forEach( function( v ) { b.push( v ) } ) ;
    a.forEach( function( v, i ) { c[i] = b.pop() } ) ;
    return c ;
}

var a= [] ; a[1] = 2 ; a[3] = 4 ; a[7] = 6 ; a[9] = 8 ;
a = reverse( a ) ;
var s = '' ;
a.forEach( function( v, i ) { s += 'a[' + i + '] = ' + v + '  ' } ) ;
console.log( s ) ;
// a[1] = 8  a[3] = 6  a[7] = 4  a[9] = 2

Answer 32

以下是具有最佳空間和時間復雜度的解決方案

function reverse(arr){
let i = 0;
let j = arr.length-1; 
while(i<j){
arr[j] = arr[j]+arr[i];
arr[i] = arr[j] - arr[i];
arr[j] = arr[j] - arr[i];
i++;
j--;
}
return arr;
}
var arr = [1,2,3,4,5,6,7,8,9]
reverse(arr);

輸出 => [9,8,7,6,5,4,3,2,1]

Answer 33

使用 ES6 反轉數組和子數組（就地）。

function reverse(array, i=0, j=array.length-1){
  while (i < j){
    [array[i], array[j]] = [array[j], array[i]];
    ++i;
    --j;
  }
}

Answer 34

我們有 reverse() 函數來反轉 JS 中給定的數組。

var a = [7,8,9];
a.reverse(); // 9 8 7

function reverseArr(input) 
{
var ret = new Array;
for(var i = input.length-1; i >= 0; i--) 
{
    ret.push(input[i]);
}
return ret;
}

Answer 35

我也遇到了同樣的問題。 謝謝你提出這個問題。 我做了如下代碼片段的代碼。 它工作得很好。 我用的是 ES6。

const Array = ["a", "b", "c", "d"];
let revArray = [].concat(Array).reverse();

當我 console.log 它時，我得到如下輸出

console.log(revArray)
// output: ["d","c","b","a"]

Answer 36

我只是將haskell實現重寫為js。

const rev = (list, reversed) => {
    if (list.length == 0) return reversed

    reversed.unshift(list[0])
    return rev(list.slice(1), reversed)
}

const reverse = (list) => rev(list, [])