javascript 在不使用 reverse() 的情况下反转数组

Question

我想在不使用 reverse() 函数的情况下反转数组：

function reverse(array){
    var output = [];
    for (var i = 0; i<= array.length; i++){
        output.push(array.pop());
    }

    return output;
}

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

但是，它显示 [7, 6, 5, 4] 有人可以告诉我，为什么我的反向功能是错误的？提前致谢！

Answer 1

array.pop() 从数组中删除弹出的元素，将其大小减小一。一旦您位于 i === 4，您的中断条件不再计算为 true 并且循环结束.

---

一种可能的解决方案：

function reverse(array) {
  var output = [];
  while (array.length) {
    output.push(array.pop());
  }

  return output;
}

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

Answer 2

您可以使用Array.prototype.reduceright 并反转它

检查以下sn-p

var arr = ([1, 2, 3, 4, 5, 6, 7]).reduceRight(function(previous, current) {
  previous.push(current);
  return previous;
}, []);

console.log(arr);

Answer 3

无需弹出任何内容...只需以相反的顺序遍历现有数组即可创建新数组。

function reverse(array){
    var output = [];
    for (var i = array.length - 1; i> -1; i--){
        output.push(array[i]);
    }

    return output;
}

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

在回答被接受后编辑。

对您的开篇文章的评论中的链接让我测试了我的方式与接受的答案的方式。我很高兴看到我的方式，至少在我的情况下，每次都更快。差一点，但速度更快。

这是我用来测试它的副本/粘贴（从 Firefox 开发人员便笺簿测试）：

function reverseMyWay(array){
    var output = [];
    for (var i = array.length - 1; i> -1; i--){
        output.push(array[i]);
    }

    return output;
}

function reverseTheirWay(array) {
  var output = [];
  while (array.length) {
    output.push(array.pop());
  }

  return output;
}

function JustDoIt(){
    console.log("their way starts")
    var startOf = new Date().getTime();
    for(var p = 0; p < 10000; p++)
        {
            console.log(reverseTheirWay([7,6,5,4,3,2,1]))
        }
    var endOf = new Date().getTime();
    console.log("ran for " + (endOf - startOf) + " ms");
    console.log("their way ends")

}


function JustDoIMyWay(){
    console.log("my way starts")
    var startOf = new Date().getTime();
    for(var p = 0; p < 10000; p++)
        {
            console.log(reverseMyWay([7,6,5,4,3,2,1]))
        }
    var endOf = new Date().getTime();
    console.log("ran for " + (endOf - startOf) + " ms");
    console.log("my way ends")
}

JustDoIt();
JustDoIMyWay();

Answer 4

在 ES6 中可以写成

reverse = (array) => array.map(array.pop, [... array]);

Answer 5

在不使用内置函数和额外空间的情况下反转数组的解决方案。

let arr = [1, 2, 3, 4, 5, 6, 7];
let n = arr.length-1;

for(let i=0; i<=n/2; i++) {
  let temp = arr[i];
  arr[i] = arr[n-i];
  arr[n-i] = temp;
}
console.log(arr);

Answer 6

以相反的方式执行，因为当您每次执行.pop() 时，数组的长度都会受到影响。

function reverse(array){
    var output = [];
    for (var i = array.length; i > 0; i--){
        output.push(array.pop());
    }
    return output;
}

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

或者您可以在从数组中弹出之前将数组的长度缓存在一个变量中，

function reverse(array){
    var output = [];
    for (var i = 0, len= array.length; i< len; i++){
        output.push(array.pop());
    }

    return output;
}

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

Answer 7

您正在使用reverse 函数修改现有数组，这会影响array.length。

不要pop离开数组，只需访问数组中的项和unshift新数组上的项，使现有数组的第一个元素成为新数组的最后一个元素：

function reverse(array){
  var output = [],
      i;
  for (i = 0; i < array.length; i++){
    output.unshift(array[i]);
  }

  return output;
}

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

如果您想像Array.prototype.reverse 那样就地修改数组（通常不建议引起副作用），您可以拼接数组，然后在开头取消移动项目：

function reverse(array) {
  var i,
      tmp;
  for (i = 1; i < array.length; i++) {
    tmp = array.splice(i, 1)[0];
    array.unshift(tmp);
  }
  return array;
}

var a = [1, 2, 3, 4, 5];
console.log('reverse result', reverse(a));
console.log('a', a);

Answer 8

这件作品允许将数组反转到位，无需弹出、拼接或推送。

var arr = [1, 2, 3, 4, 5];
function reverseArrayInPlace(arr2) {
  var half = Math.floor(arr2.length / 2);
  for (var i = 0; i < half; i++) {
    var temp = arr2[arr2.length - 1 - i];
    arr2[arr2.length - 1 - i] = arr2[i];
    arr2[i] = temp;
  }
  return arr2;
}

Answer 9

当您从第一个数组中弹出项目时，它的长度会发生变化，并且您的循环计数会缩短。您需要缓存原始数组的原始长度，以便循环运行正确的次数。

function reverse(array){
    var output = [];
    var len = array.length;
    for (var i = 0; i< len; i++){
        output.push(array.pop());
    }

    return output;
}

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

Answer 10

您正在修改原始数组并更改其大小。您可以使用 while 而不是 for 循环

    function reverse(array){
        var output = [];
        while(array.length){
            //this removes the last element making the length smaller
            output.push(array.pop());
        }

        return output;
}

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

Answer 11

function rvrc(arr) {
  for (let i = 0; i < arr.length / 2; i++) {
    const buffer = arr[i];

    arr[i] = arr[arr.length - 1 - i];
    arr[arr.length - 1 - i] = buffer;
  }
};

Answer 12

这是因为每次执行 array.pop() 时，虽然它确实返回了数组中的最后一个索引，但它也会从数组中删除它。循环在每次迭代时重新计算数组的长度。因为数组在每次迭代时都会缩短 1 个索引，所以您会从函数返回一个更短的数组。

Answer 13

这段代码可以在不使用第二个数组的情况下工作。它使用的是内置方法 splice。

function reverse(array){
    for (let i = 0; i < array.length; i++) {
        array.splice(i, 0, array.splice(array.length - 1)[0]);
    }
    return array;
}

Answer 14

这里，我们来定义函数

function rev(arr) {
  const na = [];
  for (let i=0; i<arr.length; i++) {
    na.push(arr[arr.length-i])
  }
  return na;
}

假设您的数组定义为 'abca' 并包含 ['a','b','c','d','e','foo','bar']

我们会这样做：

var reva = rev(abca)

这将使 'reva' 返回 ['bar','foo','e','d','c','b','a']。 希望我能帮上忙！

Answer 15

您可以使用 .map，因为它非常适合这种情况，并且只有 1 行：

const reverse = a =>{ i=a.length; return a.map(_=>a[i-=1]) }

这将获取数组，并且对于每个索引，将其更改为数组的长度 - 索引，或数组的另一侧。

Answer 16

反向循环

let array = ["ahmet", "mehmet", "aslı"]


    length = array.length
    newArray = [];
    for (let i = length-1; i >-1; i--) {

        newArray.push(array[i])

    }

    console.log(newArray)

Answer 17

还有这个：

function reverseArray(arr) { 
    let top = arr.length - 1;
    let bottom = 0;
    let swap = 0;
    
    while (top - bottom >= 1) {
        swap = arr[bottom];
        arr[bottom] = arr[top];
        arr[top] = swap;
        bottom++;
        top--;
    }
}

Answer 18

function reverse(arr) {
  for (let i = 0; i < arr.length - 1; i++) {
    arr.splice(i, 0, arr.pop())
  }
  return arr;
}
console.log(reverse([1, 2, 3, 4, 5]))
//without another array

Answer 19

reverse=a=>a.map((x,y)=>a[a.length-1-y])

reverse=a=>a.map((x,y)=>a[a.length-1-y])

console.log(reverse(["Works","It","One","Line"]))

Answer 20

最短的一个：

let reverse = arr = arr.map(arr.pop, [...arr])

Answer 21

这是一个老问题，但有人可能会觉得这很有帮助。

主要有两种方法：

首先，不合适，你基本上将最后一个元素推入一个新数组，并使用新数组：

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

arrReverse([0,1,2,3,4,5,6,7,8,9]);

然后就位。这有点棘手，但我认为它就像在你面前有四个物体。你需要先握住手中的第一个，然后将最后一个物品移动到第一个位置，然后将手中的物品放在最后一个位置。 然后，将最左边的边加一，最右边的边减一：

function reverseArr(arr) {
    let lh;
        
    for(let i = 0; i<arr.length/2; i++){
    
            lh = arr[i];
        arr[i] = arr[arr.length -i -1];
        arr[arr.length -i -1] = lh;
        
    }
    return arr;
}

reverseArr([0,1,2,3,4,5,6,7,8,9]);

像这样。我什至将我的变量 lh 命名为“左手”以帮助实现这个想法。

了解数组非常重要，弄清楚它们的工作原理不仅可以让您免于不必要的冗长乏味的解决方法，还可以帮助您更好地掌握某些数据概念！

Answer 22

function reverse(str1) {
  let newstr = [];
  let count = 0;
  for (let i = str1.length - 1; i >= 0; i--) {
    newstr[count] = str1[i];
    count++;
  }
  return newstr;
}
reverse(['x','y','z']);

Answer 23

数组=[2,3,4,5]

 for(var i=0;i<Array.length/2;i++){
    var temp =Array[i];
    Array[i]=Array[Array.length-i-1]
    Array[Array.length-i-1]=temp
}

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