在 JavaScript 中旋转数组中的元素

Question

我想知道旋转 JavaScript 数组最有效的方法是什么。

我想出了这个解决方案，其中正数 n 将数组向右旋转，负数 n 向左旋转 (-length < n < length)：

Array.prototype.rotateRight = function( n ) {
  this.unshift( this.splice( n, this.length ) );
}

然后可以这样使用：

var months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
months.rotate( new Date().getMonth() );

我上面的原始版本有一个缺陷，正如下面 cmets 中 Christoph 指出的那样，正确的版本是（额外的返回允许链接）：

Array.prototype.rotateRight = function( n ) {
  this.unshift.apply( this, this.splice( n, this.length ) );
  return this;
}

是否有更紧凑和/或更快的解决方案，可能是在 JavaScript 框架的上下文中？ （以下提议的版本都不是更紧凑或更快）

有没有内置数组旋转的 JavaScript 框架？ （仍然没有人回答）

Answer 1

您可以使用push()、pop()、shift() 和unshift() 方法：

function arrayRotate(arr, reverse) {
  if (reverse) arr.unshift(arr.pop());
  else arr.push(arr.shift());
  return arr;
}

用法：

arrayRotate([1, 2, 3, 4, 5]);       // [2, 3, 4, 5, 1];
arrayRotate([1, 2, 3, 4, 5], true); // [5, 1, 2, 3, 4];

如果您需要count 参数，请参阅我的其他答案：
https://stackoverflow.com/a/33451102?????

Answer 2

类型安全的通用版本，可改变数组：

Array.prototype.rotate = (function() {
    // save references to array functions to make lookup faster
    var push = Array.prototype.push,
        splice = Array.prototype.splice;

    return function(count) {
        var len = this.length >>> 0, // convert to uint
            count = count >> 0; // convert to int

        // convert count to value in range [0, len)
        count = ((count % len) + len) % len;

        // use splice.call() instead of this.splice() to make function generic
        push.apply(this, splice.call(this, 0, count));
        return this;
    };
})();

在 cmets 中，Jean 提出了代码不支持 push() 和 splice() 重载的问题。我不认为这真的很有用（见 cmets），但一个快速的解决方案（虽然有点 hack）是替换该行

push.apply(this, splice.call(this, 0, count));

用这个：

(this.push || push).apply(this, (this.splice || splice).call(this, 0, count));

---

在 Opera 10 中使用 unshift() 代替 push() 几乎快两倍，而在 FF 中的差异可以忽略不计；代码：

Array.prototype.rotate = (function() {
    var unshift = Array.prototype.unshift,
        splice = Array.prototype.splice;

    return function(count) {
        var len = this.length >>> 0,
            count = count >> 0;

        unshift.apply(this, splice.call(this, count % len, len));
        return this;
    };
})();

Answer 3

我可能会这样做：

Array.prototype.rotate = function(n) {
    n = n % this.length;
    return this.slice(n, this.length).concat(this.slice(0, n));
}

---

编辑    这是一个修改器版本：

Array.prototype.rotate = function(n) {
    n = n % this.length;
    while (this.length && n < 0) n += this.length;
    this.push.apply(this, this.splice(0, n));
    return this;
}

Answer 4

这个函数可以双向工作，也可以处理任何数字（即使数字大于数组长度）：

function arrayRotate(arr, count) {
  count -= arr.length * Math.floor(count / arr.length);
  arr.push.apply(arr, arr.splice(0, count));
  return arr;
}

用法：

for(let i = -6 ; i <= 6 ; i++) {
  console.log(arrayRotate(["?","?","?","?","?"], i), i);
}

结果：

[ "?", "?", "?", "?", "?" ]    -6
[ "?", "?", "?", "?", "?" ]    -5
[ "?", "?", "?", "?", "?" ]    -4
[ "?", "?", "?", "?", "?" ]    -3
[ "?", "?", "?", "?", "?" ]    -2
[ "?", "?", "?", "?", "?" ]    -1
[ "?", "?", "?", "?", "?" ]    0
[ "?", "?", "?", "?", "?" ]    1
[ "?", "?", "?", "?", "?" ]    2
[ "?", "?", "?", "?", "?" ]    3
[ "?", "?", "?", "?", "?" ]    4
[ "?", "?", "?", "?", "?" ]    5
[ "?", "?", "?", "?", "?" ]    6

Answer 5

其中许多答案似乎过于复杂且难以阅读。 我想我没有看到任何人使用 splice 和 concat...

function rotateCalendar(){
    var cal=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],
    cal=cal.concat(cal.splice(0,new Date().getMonth()));
    console.log(cal);  // return cal;
}

---

console.log 输出（*5 月生成）：

["May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", "Jan", "Feb", "Mar", "Apr"]

---

至于紧凑性，我可以提供几个通用的单行函数（不包括 console.log | return 部分）。只需在参数中输入数组和目标值即可。

我将这些函数合二为一，用于一个四人纸牌游戏程序，其中数组为 ['N','E','S','W']。我将它们分开，以防有人想复制/粘贴以满足他们的需要。出于我的目的，我在寻找在游戏的不同阶段（Pinochle）下轮到谁来玩/行动时使用这些功能。我没有费心测试速度，所以如果其他人愿意，请随时告诉我结果。

*注意，函数之间的唯一区别是“+1”。

function rotateToFirst(arr,val){  // val is Trump Declarer's seat, first to play
    arr=arr.concat(arr.splice(0,arr.indexOf(val)));
    console.log(arr); // return arr;
}
function rotateToLast(arr,val){  // val is Dealer's seat, last to bid
    arr=arr.concat(arr.splice(0,arr.indexOf(val)+1));
    console.log(arr); // return arr;
}

---

组合函数...

function rotateArray(arr,val,pos){
    // set pos to 0 if moving val to first position, or 1 for last position
    arr=arr.concat(arr.splice(0,arr.indexOf(val)+pos));
    return arr;
}
var adjustedArray=rotateArray(['N','E','S','W'],'S',1);

调整数组=

W,N,E,S

Answer 6

切片和解构的简单解决方案：

const rotate = (arr, count = 1) => {
  return [...arr.slice(count, arr.length), ...arr.slice(0, count)];
};

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

console.log(rotate(arr, 1));  // [2, 3, 4, 5, 1]
console.log(rotate(arr, 2));  // [3, 4, 5, 1, 2]
console.log(rotate(arr, -2)); // [4, 5, 1, 2, 3]
console.log(rotate(arr, -1)); // [5, 1, 2, 3, 4]

Answer 7

使用 ES6 的 spread 做一个不可变的例子......

[...array.slice(1, array.length), array[0]]

和

[array[array.items.length -1], ...array.slice(0, array.length -1)]

虽然它可能不是最有效的，但它很简洁。

Answer 8

这里有一个非常简单的方法来移动数组中的项目：

function rotate(array, stepsToShift) {

    for (var i = 0; i < stepsToShift; i++) {
        array.unshift(array.pop());
    }

    return array;
}

Answer 9

当我找不到现成的 sn-p 以“今天”开始日期列表时，我这样做了（不太通用，可能远没有上面的例子那么精致，但完成了工作):

//returns 7 day names with today first
function startday() {
    const days = ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'];
    let today = new Date();
    let start = today.getDay(); //gets day number
    if (start == 0) { //if Sunday, days are in order
        return days
    }
    else { //if not Sunday, start days with today
        return days.slice(start).concat(days.slice(0,start))
    }
}

感谢比我更好的程序员进行了一点重构，它比我最初的尝试短了一两行，但欢迎任何关于效率的进一步 cmet。

Answer 10

@Christoph，您编写了一个干净的代码，但比我找到的这个代码慢 60%。在 jsPerf 上查看结果：http://jsperf.com/js-rotate-array/2 [编辑] 好的，现在有更多的浏览器，一个不明显的女巫方法是最好的

var rotateArray = function(a, inc) {
    for (var l = a.length, inc = (Math.abs(inc) >= l && (inc %= l), inc < 0 && (inc += l), inc), i, x; inc; inc = (Math.ceil(l / inc) - 1) * inc - l + (l = inc))
    for (i = l; i > inc; x = a[--i], a[i] = a[i - inc], a[i - inc] = x);
    return a;
};

var array = ['a','b','c','d','e','f','g','h','i'];

console.log(array);
console.log(rotateArray(array.slice(), -1)); // Clone array with slice() to keep original

Answer 11

见http://jsperf.com/js-rotate-array/8

function reverse(a, from, to) {
  --from;
  while (++from < --to) {
    var tmp = a[from];
    a[from] = a[to];
    a[to] = tmp;
  }
}

function rotate(a, from, to, k) {
  var n = to - from;
  k = (k % n + n) % n;
  if (k > 0) {
    reverse(a, from, from + k);
    reverse(a, from + k, to);
    reverse(a, from, to);
  }
}

Answer 12

function rotate(arr, k) {
for (var i = 0; i < k+1; i++) {
    arr.push(arr.shift());
}
return arr;
}
//k work as an index array
console.log(rotate([1, 2, 7, 4, 5, 6, 7], 3)); //[5,6,7,1,2,7,4]
console.log(rotate([-1, -100, 3, 99], 2));     //[99,-1,-100,3]

Answer 13

// Example of array to rotate
let arr = ['E', 'l', 'e', 'p', 'h', 'a', 'n', 't'];

// Getting array length
let length = arr.length;

// rotation < 0 (move left), rotation > 0 (move right)
let rotation = 5;

// Slicing array in two parts
let first  = arr.slice(   (length - rotation) % length, length); //['p', 'h', 'a' ,'n', 't']
let second = arr.slice(0, (length - rotation) % length); //['E', 'l', 'e']

// Rotated element
let rotated = [...first, ...second]; // ['p', 'h', 'a' ,'n', 't', 'E', 'l', 'e']

一行代码：

let rotated = [...arr.slice((length - rotation) % length, length), ...arr.slice(0, (length - rotation) % length)];

Answer 14

接受的答案有一个缺陷，即无法处理大于调用堆栈大小的数组，这取决于会话，但应该大约为 100~300K 项。例如，在我尝试的当前 Chrome 会话中，它是 250891。在许多情况下，您甚至可能不知道数组可能动态增长到什么大小。所以这是一个严重的问题。

为了克服这个限制，我想一种有趣的方法是利用Array.prototype.map() 并通过以循环方式重新排列索引来映射元素。此方法采用一个整数参数。如果此参数为正，它将在增加索引时旋转，如果为负，则在减少索引方向上旋转。这只有 O(n) 时间复杂度，并且将返回一个新数组而不会改变它所调用的数组，同时处理数百万个项目而没有任何问题。让我们看看它是如何工作的；

Array.prototype.rotate = function(n) {
var len = this.length;
return !(n % len) ? this
                  : n > 0 ? this.map((e,i,a) => a[(i + n) % len])
                          : this.map((e,i,a) => a[(len - (len - i - n) % len) % len]);
};
var a = [1,2,3,4,5,6,7,8,9],
    b = a.rotate(2);
console.log(JSON.stringify(b));
    b = a.rotate(-1);
console.log(JSON.stringify(b));

其实我在以下两件事上受到批评后；

1. 没有必要为正输入或负输入设置条件，因为它揭示了违反 DRY 的情况。您可以使用一个映射来执行此操作，因为每个负 n 都有一个正等效项（完全正确..）
2. Array 函数应该更改当前数组或创建一个新数组，您的函数可以根据是否需要移位来执行（完全正确..）

我决定修改代码如下；

Array.prototype.rotate = function(n) {
var len = this.length;
return !(n % len) ? this.slice()
                  : this.map((e,i,a) => a[(i + (len + n % len)) % len]);
};
var a = [1,2,3,4,5,6,7,8,9],
    b = a.rotate(10);
console.log(JSON.stringify(b));
    b = a.rotate(-10);
console.log(JSON.stringify(b));

再说一遍；当然，像Array.prototype.map() 这样的 JS 仿函数与用纯 JS 编码的等效函数相比速度很慢。为了获得超过 100% 的性能提升，如果我需要在生产代码中旋转数组，就像我在尝试 String.prototype.diff() 时使用的那样，以下可能是我的选择 Array.prototype.rotate()

Array.prototype.rotate = function(n){
  var len = this.length,
      res = new Array(this.length);
  if (n % len === 0) return this.slice();
  else for (var i = 0; i < len; i++) res[i] = this[(i + (len + n % len)) % len];
  return res;
};

Answer 15

这个函数比小数组的公认答案要快一点，但对于大数组来说要快得多。这个函数还允许旋转大于数组长度的任意次数，这是原始函数的一个限制。

最后，接受的答案与描述的相反方向旋转。

const rotateForEach = (a, n) => {
    const l = a.length;
    a.slice(0, -n % l).forEach(item => a.push( item ));
    return a.splice(n % l > 0 ? (-n % l) : l + (-n % l));
}

以及等效的功能（似乎也有一些性能优势）：

const rotateReduce = (arr, n) => {
    const l = arr.length;
    return arr.slice(0, -n % l).reduce((a,b) => {
        a.push( b );
        return a;
    }, arr).splice(n % l> 0 ? l + (-n % l) : -n % l);
};

您可以查看performance breakdown here.

Answer 16

编辑:: 嘿，事实证明发生了太多的迭代。没有循环，没有分支。

对于任何大小的 n，仍然适用于负 n 右旋转和正 n 左旋转， 无突变

function rotate(A,n,l=A.length) {
  const offset = (((n % l) + l) %l)
  return A.slice(offset).concat(A.slice(0,offset))
}

这是用于咯咯笑的代码高尔夫版本

const r = (A,n,l=A.length,i=((n%l)+l)%l)=>A.slice(i).concat(A.slice(0,i))

EDIT1::* 无分支、无变异的实现。

嘿，原来我有一个不需要它的分支。这是一个有效的解决方案。 负数 = 向右旋转 |num| 正数 = 左旋转 num

function r(A,n,l=A.length) {
  return A.map((x,i,a) => A[(((n+i)%l) + l) % l])
}

方程((n%l) + l) % l 精确映射任意大的 n 值的正数和负数

原创

左右旋转。向左旋转正n，向右旋转负n。

适用于 n 的大量输入。

没有突变模式。这些答案的突变太多了。

此外，与大多数答案相比，操作更少。没有弹出，没有推送，没有拼接，没有移位。

const rotate = (A, num ) => {
   return A.map((x,i,a) => {
      const n = num + i
      return n < 0 
        ? A[(((n % A.length) + A.length) % A.length)]
        : n < A.length 
        ? A[n] 
        : A[n % A.length]
   })
}

或

 const rotate = (A, num) => A.map((x,i,a, n = num + i) => 
  n < 0
    ? A[(((n % A.length) + A.length) % A.length)]
    : n < A.length 
    ? A[n] 
    : A[n % A.length])

//test
rotate([...Array(5000).keys()],4101)   //left rotation
rotate([...Array(5000).keys()],-4101000)  //right rotation, num is negative

// will print the first index of the array having been rotated by -i
// demonstrating that the rotation works as intended
[...Array(5000).keys()].forEach((x,i,a) => {
   console.log(rotate(a,-i)[0])
}) 
// prints even numbers twice by rotating the array by i * 2 and getting the first value
//demonstrates the propper mapping of positive number rotation when out of range
[...Array(5000).keys()].forEach((x,i,a) => {
   console.log(rotate(a,i*2)[0])
})

解释：

将 A 的每个索引映射到索引偏移处的值。在这种情况下

offset = num

如果offset < 0 则offset + index + positive length of A 将指向反向偏移量。

如果offset > 0 and offset < length of A 则简单地将当前索引映射到A 的偏移索引。

否则，将偏移量和长度取模以映射数组边界中的偏移量。

以offset = 4 和offset = -4 为例。

当offset = -4 和A = [1,2,3,4,5] 时，对于每个索引，offset + index 将使幅度（或Math.abs(offset)）更小。

我们先解释一下负n的索引的计算。 A[(((n % A.length) + A.length) % A.length)+0] 并被吓倒了。 别这样。我在 Repl 中花了 3 分钟才解决这个问题。

1. 我们知道n 是否定的，因为案例是n < 0。如果数字大于 Array 的范围，n % A.length 会将其映射到该范围内。
2. n + A.length 将该数字添加到 A.length 以正确偏移 n 金额。
3. 我们知道n 是否定的，因为案例是n < 0。 n + A.length 将该数字添加到 A.length 以抵消 n 正确的数量。

4. 接下来使用模数将其映射到 A 的长度范围。第二个模数是将计算结果映射到可索引范围中所必需的

5. 第一个索引：-4 + 0 = -4。 A.length = 5。A.length - 4 = 1。A2 为 2。映射索引 0 到 2。[2,... ]

6. 下一个索引，-4 + 1 = -3。 5 + -3 = 2。A2 是 3。将索引 1 映射到 3。[2,3... ]
7. 等

同样的过程适用于offset = 4。 当offset = -4和A = [1,2,3,4,5]时，对于每个索引，offset + index会使幅度变大。

1. 4 + 0 = 0。将 A[0] 映射到 A[4] 处的值。 [5...]
2. 4 + 1 = 5, 索引时 5 超出范围，所以将 A2 映射到 5 / 5 余数的值，即 0。A2 = 值 一个[0]。 [5,1...]
3. 重复。

Answer 17

2021 年 2 月更新

一个单行函数来执行数组元素的向右旋转和向左旋转。

向左旋转

const arrRotateLeft = (a,n) =>{while (n>0) {a.push(a.shift());n--;}return a;};

向右旋转

const arrRotateRight= (a,n) =>{while (n>0) {a.unshift(a.pop());n--;}return a;};

const arrRotateLeft = (a,n)=>{while (n>0) {a.push(a.shift());n--;}return a;};

const arrRotateRight= (a,n)=>{while (n>0) {a.unshift(a.pop());n--;}return a;};


//=========== Test rotate Left =================
console.log(arrRotateLeft([1,2,3,4,5,6],0));       // [1,2,3,4,5,6]   <== rotate in this direction
console.log(arrRotateLeft([1,2,3,4,5,6],1));       // [2,3,4,5,6,1]
console.log(arrRotateLeft([1,2,3,4,5,6],2));       // [3,4,5,6,1,2]
console.log(arrRotateLeft([1,2,3,4,5,6],3));       // [4,5,6,1,2,3]
console.log(arrRotateLeft([1,2,3,4,5,6,7,8],5));   // [6,7,8,1,2,3,4,5]


//=========== Test rotate Right =================
console.log(arrRotateRight([1,2,3,4,5,6],0));      // [1,2,3,4,5,6]   ==> rotate in this direction
console.log(arrRotateRight([1,2,3,4,5,6],1));      // [6,1,2,3,4,5]
console.log(arrRotateRight([1,2,3,4,5,6],2));      // [5,6,1,2,3,4]
console.log(arrRotateRight([1,2,3,4,5,6],3));      // [4,5,6,1,2,3]
console.log(arrRotateRight([1,2,3,4,5,6,7,8],5));  // [4,5,6,7,8,1,2,3]

Answer 18

为了将数组向左旋转 'd' 个位置，我们可以使用 unshift() 和 pop()。

   var arr=[1,2,3,4,5],d=4;
   for(var i=d;i<arr.length;i++)
    arr.unshift(arr.pop());
    console.log(arr);

对于黑客等级，解决DS左右旋转问题解决方案（javascript，java）查看我下面的文章

https://webdev99.com/left-rotationproblem-solving-data-structures/

Answer 19

Follow a simpler approach of running a loop to n numbers and shifting places upto that element.

function arrayRotateOne(arr, n) {
  for (let i = 0; i < n; i++) {
    arr.unshift(arr.pop());
  }
  return arr;
}
console.log( arrayRotateOne([1,2,3,4,5,6],2));



function arrayRotateOne(arr,n) {
  for(let i=0; i<n;i++){
      arr.push(arr.shift());
      console.log('execute',arr)
    }
     return arr;
 }

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

Answer 20

非变异解决方案

var arr = ['a','b','c','d']
arr.slice(1,arr.length).concat(arr.slice(0,1)

有突变

var arr = ['a','b','c','d']
arr = arr.concat(arr.splice(0,1))

Answer 21

我正在分享我用于在轮播上旋转的解决方案。 当数组大小小于displayCount 时，它可能会中断，但是您可以添加额外的条件以在它很小时停止旋转，或者也可以连接主数组 *displayCount 次。

function rotate(arr, moveCount, displayCount) {
  const size = arr.length;

  // making sure startIndex is between `-size` and `size`
  let startIndex = moveCount % size;
  if (startIndex < 0) startIndex += size; 

  return [...arr, ...arr].slice(startIndex, startIndex + displayCount);
}

// move 3 to the right and display 4 items
// rotate([1,2,3,4,5], 3, 4) -> [4,5,1,2]

// move 3 to the left and display 4 items
// rotate([1,2,3,4,5], -3, 4) -> [3,4,5,1]

// move 11 to the right and display 4
// rotate([1,2,3,4,5], 3, 4) -> [2,3,4,5]

Answer 22

不要使用concat 或splice 或其他任何东西。使用.map 或while 循环以简单、有效的方式向左或向右旋转。这个想法是迭代原始数组的长度。在每次迭代中，更新要添加到新旋转数组的旋转中下一个值的索引。这个解决方案是 O(n) 时间复杂度——两个例子中只有一个循环。

地图：

function Rotate(arr, n) {
  if (n === 0) {
    return arr;
  }

  var left = n < 0;
  n = Math.abs(left ? n : arr.length - n);

  return arr.map(() => {
    n = n < arr.length ? n : 0;

    return arr[n++];
  });
}

var array = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15];
var places = 4;

console.log(Rotate(array, places));//[12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
console.log(Rotate(array, -places));//[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3]

同时：

function Rotate(arr, n) {
  if (n === 0) {
    return arr;
  }

  var rotatedArray = [];
  var left = n < 0;
  n = Math.abs(left ? n : arr.length - n);

  while (rotatedArray.length < arr.length) {
    n = n < arr.length ? n : 0;
    rotatedArray.push(arr[n++]);
  }

  return rotatedArray;
}

splice 和 concat 方法是 O(n) 操作；前者删除然后返回一个“拼接”值的数组，后者返回一个包含合并数组值的新数组。所以，如果你同时使用它们，你做的工作太多： O(n) * 2 和两个新复制的数组。坦率地说，使用简单的while 循环更容易了解发生的逻辑。

Answer 23

如何增加一个计数器，然后将除法的余数除以数组长度以获得您应该在的位置。

var i = 0;
while (true);
{
    var position = i % months.length;
    alert(months[position]);
    ++i;
}

除此之外的语言语法应该可以正常工作。

Answer 24

如果您的数组会很大和/或您要旋转很多，您可能需要考虑使用链表而不是数组。

Answer 25

@molokoloco 我需要一个可以配置为沿一个方向旋转的函数——true 表示向前，false 表示向后。我创建了一个 sn-p，它接受一个方向、一个计数器和一个数组，并输出一个对象，其中计数器在适当的方向以及先前、当前和下一个值递增。它不会修改原始数组。

我还根据你的 sn-p 计时，虽然它并不快，但它比你的比较快 - 慢 21% http://jsperf.com/js-rotate-array/7。

function directionalRotate(direction, counter, arr) {
  counter = direction ? (counter < arr.length - 1 ? counter + 1 : 0) : (counter > 0 ? counter - 1 : arr.length - 1)
  var currentItem = arr[counter]
  var priorItem = arr[counter - 1] ? arr[counter - 1] : arr[arr.length - 1]
  var nextItem = arr[counter + 1] ? arr[counter + 1] : arr[0]
  return {
    "counter": counter,
    "current": currentItem,
    "prior": priorItem,
    "next": nextItem
  }
}
var direction = true // forward
var counter = 0
var arr = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'];

directionalRotate(direction, counter, arr)

Answer 26

我来晚了，但我有一块砖可以补充这些好的答案。 我被要求编写这样一个函数，我首先做到了：

Array.prototype.rotate = function(n)
{
    for (var i = 0; i < n; i++)
    {
        this.push(this.shift());
    }
    return this;
}

但是当n 很大时，它的效率似乎低于跟随：

Array.prototype.rotate = function(n)
{
    var l = this.length;// Caching array length before map loop.

    return this.map(function(num, index) {
        return this[(index + n) % l]
    });
}

Answer 27

我不确定这是否是最有效的方式，但我喜欢它的读取方式，它对于大多数大型任务来说已经足够快了，因为我已经在生产环境中对其进行了测试......

function shiftRight(array) {
  return array.map((_element, index) => {
    if (index === 0) {
      return array[array.length - 1]
    } else return array[index - 1]
  })
}

function test() {
  var input = [{
    name: ''
  }, 10, 'left-side'];
  var expected = ['left-side', {
    name: ''
  }, 10]
  var actual = shiftRight(input)

  console.log(expected)
  console.log(actual)

}

test()

Answer 28

原生、快速、小型、语义化、适用于旧引擎并且“可咖喱”。

function rotateArray(offset, array) {
    offset = -(offset % array.length) | 0 // ensure int
    return array.slice(offset).concat(
        array.slice(0, offset)
    )
}

Answer 29

** 使用最新版本的 JS，我们可以轻松构建它 **

 Array.prototype.rotateLeft = function (n) {
   this.unshift(...this.splice(-(n), n));
    return this
  }

这里移动：转数，一个数组你可以传递随机数

let a = [1, 2, 3, 4, 5, 6, 7];
let moves = 4;
let output = a.rotateLeft(moves);
console.log("Result:", output)

Answer 30

JS 中的

Array 具有以下内置方法，可以很容易地用于旋转数组，显然这些方法在本质上是不可变的。

• push：将项目插入到数组的末尾。
• pop：从数组末尾移除项目。
• unshift：将项目插入到数组的开头。
• shift：从数组的开头删除项目。

下面的解决方案（ES6）有两个参数，数组需要旋转，n，数组应该旋转的次数。

const rotateArray = (arr, n) => {
  while(arr.length && n--) {
    arr.unshift(arr.pop());
  }
  return arr;
}

rotateArray(['stack', 'overflow', 'is', 'Awesome'], 2) 
// ["is", "Awesome", "stack", "overflow"]

它可以添加到 Array.prototype 中，并且可以在您的整个应用程序中使用

Array.prototype.rotate = function(n) {
 while(this.length && n--) {
   this.unshift(this.pop());
 }
 return this;
}
[1,2,3,4].rotate(3); //[2, 3, 4, 1]