53个字节

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()就是完成这项工作所需的一切。请参阅compatibility table。

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

Answer 3

20字节

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

Answer 4

这是一种功能性的方法。

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

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

Answer 5

这就是你想要的：

array.reverse();

DEMO

Answer 6

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

Answer 7

我见过的最短的反向方法就是这个：

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

Answer 8

这是一个不需要临时数组的版本。

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 9

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 10

使用排序方法

反转

这是一种更为简洁的方法。

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 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 reverseArray(a) { 
     var rA = []
     for (var i = a.length; i > 0; i--) {
         rA.push(a[i - 1])
     } 

     return rA;
  }

使用 .reverse()

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

Answer 13

**

最短的反向数组方法，不使用反向方法：

**

 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 14

index-example.js

Answer 15

通过变量交换（可变）在原地反转

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 16

使用.pop（）方法和while循环。

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

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

Answer 17

也可以使用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 18

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

简洁，保持原样。

Answer 19

就像其他人提到的那样，您可以在数组对象上使用.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 20

使用函数式编程反转数组的纯函数：

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

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

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

Answer 21

53个字节

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

只是为了好玩，这是一种比原生.reverse方法更快的替代实现。

Answer 22

如果不使用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 23

如何？

  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 24

事实上，reverse() 在某些情况下可能不起作用，所以你必须先做一个如下的做作

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

或使用concat

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

Answer 25

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

Answer 26

使用交换并返回原始数组。

UIContextMenuInteraction

Answer 27

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

或者像这样简单地为数组编译JavaScript内置方法：

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

你可以这样称呼它：

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

正如前面提到的，主要区别在于第二种方式，你不要触摸原始阵列......

Answer 28

我也面临着同样的问题。谢谢你这个问题。我做了下面的代码片段。效果很好。我用的是ES6。

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

当我进行console.log记录时，我得到如下输出

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

Answer 29

我们具有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 30

使用ES6的反向数组和子数组（就位）。

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

Answer 31

我不确定库的含义，但这是我能想到的最佳方法：

// return a new array with .map()
function ReverseArray1(array) {
    var len = array.length - 1;

    return array.map(function () {
        return array[len--]; 
    });
}

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

// initialize and return a new array
function ReverseArray2(array) {
    var len = array.length;
    var newArray = [];

    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
function ReverseArray3(array) {
    let i = 0, j = array.length - 1;

    while (i < j) {
        let 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
function ReverseArray4(array) {
    let newArray = [];

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

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

Answer 32

你可以做到

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

console.log(reverseArray)

你会得到

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

Answer 33

以下是具有最佳时空复杂度的解决方案

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 34

此函数将用于索引之间可能有间隔的数组。

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 35

使用ES6 rest运算符和箭头功能。

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

Answer 36

我刚刚将haskell实现重写为js。

# refactored function g
function g {
    param (
        [Parameter(ValueFromPipeline)]
        $InputObject,

        [Parameter(Mandatory)]
        [f]
        $f
    )
    process {
        $InputObject
    }
}

# usages of function g
usingObject { [f]::new() } {
    g -f $_
}

usingObject { [f]::new() } {
    'o' | g -f $_
}

try
{
    usingObject { [f]::new() } {
        'o' | g -f $_ | throws
    }
}
catch {}

usingObject { [f]::new() } {
    'o' | g -f $_ | blocks
}

如何在不使用库的情况下在JavaScript中反转数组？

36 个答案:

DEMO

使用排序方法

最短的反向数组方法，不使用反向方法：

53个字节