我正在使用array按顺序保存一些数据，我想添加一个用户可以反转列表的功能。我想不出任何可能的方法，所以如果有人知道如何，请帮助。
答案 0 :(得分：83)
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。
答案 1 :(得分：24)
Array.prototype.reverse()就是完成这项工作所需的一切。请参阅compatibility table。
var arr = [20, 40, 80, 100];
console.log(arr.reverse());
// [100, 80, 40, 20]
答案 2 :(得分：13)
20字节
let reverse=a=>[...a].map(a.pop,a)
答案 3 :(得分：12)
这是一种功能性的方法。
const array = [1,2,3,4,5,6,"taco"];
function reverse(array){
return array.map((item,idx) => array[array.length-1-idx])
}
答案 4 :(得分：5)
答案 5 :(得分：3)
> var arr = [1,2,3,4,5,6];
> arr.reverse();
[6, 5, 4, 3, 2, 1]
答案 6 :(得分：3)
我见过的最短的反向方法就是这个：
let reverse = a=>a.sort(a=>1)
答案 7 :(得分：3)
这是一个不需要临时数组的版本。
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]
答案 8 :(得分：3)
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)
答案 9 :(得分：2)
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>
答案 10 :(得分：2)
我已经对解决方案进行了一些测试，这些解决方案不仅可以反转阵列，还可以进行复制。这是测试代码。 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
答案 11 :(得分：2)
两种方式：
计数器循环
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()
}
答案 12 :(得分：2)
**
**
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
答案 13 :(得分：1)
index-example.js答案 14 :(得分：1)
通过变量交换（可变）在原地反转
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]]
}
答案 15 :(得分：1)
使用.pop（）方法和while循环。
var original = [1,2,3,4];
var reverse = [];
while(original.length){
reverse.push(original.pop());
}
输出：[4,3,2,1]
答案 16 :(得分：1)
也可以使用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;
}, []);
答案 17 :(得分：1)
var original = [1, 2, 3, 4];
var reversed = [...original].reverse(); // 4 3 2 1
简洁，保持原样。
答案 18 :(得分：1)
就像其他人提到的那样，您可以在数组对象上使用.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'];
答案 19 :(得分：1)
使用函数式编程反转数组的纯函数：
var a = [3,5,7,8];
// ES2015
function immutableReverse(arr) {
return [ ...a ].reverse();
}
// ES5
function immutableReverse(arr) {
return a.concat().reverse()
}
答案 20 :(得分：1)
function reverse(a){
for(i=0,j=a.length-1;i<j;)a[i]=a[j]+(a[j--]=a[i++],0)
}
只是为了好玩，这是一种比原生.reverse方法更快的替代实现。
答案 21 :(得分：0)
如果不使用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));
答案 22 :(得分：0)
如何？
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]));
答案 23 :(得分：0)
事实上，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]
答案 24 :(得分：0)
function reverseArray(arr) {
let reversed = [];
for (i = 0; i < arr.length; i++) {
reversed.push((arr[arr.length-1-i]))
}
return reversed;
}
答案 25 :(得分：0)
使用交换并返回原始数组。
UIContextMenuInteraction
答案 26 :(得分：0)
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];
正如前面提到的，主要区别在于第二种方式，你不要触摸原始阵列......
答案 27 :(得分：0)
我也面临着同样的问题。谢谢你这个问题。我做了下面的代码片段。效果很好。我用的是ES6。
const Array = ["a", "b", "c", "d"];
let revArray = [].concat(Array).reverse();
当我进行console.log记录时，我得到如下输出
console.log(revArray)
// output: ["d","c","b","a"]
答案 28 :(得分：0)
我们具有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;
}
答案 29 :(得分：0)
使用ES6的反向数组和子数组（就位）。
function reverse(array, i=0, j=array.length-1){
while (i < j){
[array[i], array[j]] = [array[j], array[i]];
++i;
--j;
}
}
答案 30 :(得分：0)
我不确定库的含义，但这是我能想到的最佳方法：
// 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]
答案 31 :(得分：0)
你可以做到
var yourArray = ["first", "second", "third", "...", "etc"]
var reverseArray = yourArray.slice().reverse()
console.log(reverseArray)
你会得到
["etc", "...", "third", "second", "first"]
答案 32 :(得分：0)
以下是具有最佳时空复杂度的解决方案
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]
答案 33 :(得分：0)
此函数将用于索引之间可能有间隔的数组。
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
答案 34 :(得分：0)
使用ES6 rest运算符和箭头功能。
const reverse = ([x, ...s]) => x ? [...reverse(s), x] : [];
reverse([1,2,3,4,5]) //[5, 4, 3, 2, 1]
答案 35 :(得分：-1)
我刚刚将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
}