Rotate the elements in an array in JavaScript

我可能会这样做:

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

如何递增一个计数器，然后得到除以数组长度的余数，得到你应该在的位置。

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

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

类型安全，通用的变异数组的版本:

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

在评论中，Jean 提出了代码不支持 push()和 splice()过载的问题。我不认为这是真正有用的(见注释) ，但一个快速的解决方案(虽然有点黑客)将是替换行

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

with this one:

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

使用 unshift()代替 push()的速度几乎是 Opera 10的两倍，而 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;
};
})();

如果你的数组很大并且/或者你要旋转很多次，你可以考虑使用链表来代替数组。

When I couldn't find a ready-made snippet to start a list of days with 'today', I did it like this (not quite generic, probably far less refined than the above examples, but did the job):

//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))
}
}

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

@ Christoph 你的代码很干净，但是 最慢的60% 比我找到的这个要好。看看 jsPerf 上的结果: < a href = “ http://jsPerf.com/js-rol-array/2”rel = “ nofollow”> 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

@ molokoloco 我需要一个函数，我可以配置旋转的方向-真为前进和假为后退。我创建了一个代码片段，该代码片段接受一个方向、一个计数器和一个数组，并输出一个对象，计数器在适当的方向以及先前值、当前值和下一个值递增。它不修改原始数组。

我还对你的代码片段进行了计时，虽然它不快，但是比你的代码片段要快——慢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)

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

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

这些答案中有许多似乎过于复杂和难以阅读。 我没看到有人用拼接连接..。

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 outputs (*generated in May):

["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

This function works in both way and works with any number (even with number greater than array length):

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

接受的答案有一个缺陷，即不能处理大于调用堆栈大小的数组，这取决于会话，但应该是大约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% 的性能提升，以下可能是我的选择 Array.prototype.rotate()，如果我曾经需要在生产代码中旋转一个数组，就像我在 String.prototype.diff()上尝试使用的那样

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

2022及就位

你也可以像这样单次旋转

function rotateArrayInPlaceByOne(a){
[a[a.length-1],a] = [a[0],a.copyWithin(0,1,a.length)];
return a;
}

在 V8中，无论是使用数组解构还是临时交换元素，这一行都比上面的答案稍慢。http://jsben.ch/6fFyr

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

function rotate(array, stepsToShift) {


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


return array;
}

这个函数比小数组的可接受答案稍微快一点，但是对于大数组要快得多。这个函数还允许任意数量的旋转大于数组的长度，这是原始函数的一个限制。

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

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

你可以看看 表现不佳。

我要迟到了，但我还有一块砖头要补充这些好的答案。 我被要求编写这样一个函数，我首先这样做了:

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

编辑: 结果发现迭代太多了，没有循环，没有分支。

Still works with negative n for right rotation and positive n for left rotation for any size 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))

Branchless, mutationless implementation.

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

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])
})

offset = num