หมุนองค์ประกอบในอาร์เรย์ใน JavaScript

ฉันสงสัยว่าวิธีใดเป็นวิธีที่มีประสิทธิภาพที่สุดในการหมุนอาร์เรย์ 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() );

เวอร์ชันดั้งเดิมของฉันด้านบนมีข้อบกพร่องดังที่คริสตอฟชี้ให้เห็นในความคิดเห็นต่อไปเวอร์ชันที่ถูกต้องคือ (การส่งคืนเพิ่มเติมอนุญาตให้ผูกมัด)

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

มีโซลูชันที่กะทัดรัดและ / หรือเร็วกว่าหรือไม่ซึ่งอาจอยู่ในบริบทของกรอบงาน JavaScript (ไม่มีเวอร์ชันใดที่เสนอมาจะกะทัดรัดหรือเร็วกว่า)

มีกรอบ JavaScript ใด ๆ ที่มีอาร์เรย์หมุนในตัวหรือไม่? (ยังไม่ตอบจากใคร)

Type-safe เวอร์ชันทั่วไปที่กลายพันธุ์อาร์เรย์:

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

ในความคิดเห็นที่ฌองยกประเด็นว่ารหัสไม่สนับสนุนการบรรทุกเกินพิกัดของและpush() splice()ฉันไม่คิดว่าสิ่งนี้จะมีประโยชน์จริงๆ (ดูความคิดเห็น) แต่วิธีแก้ปัญหาอย่างรวดเร็ว (แม้ว่าการแฮ็กบางส่วน) คือการแทนที่บรรทัด

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

ด้วยสิ่งนี้:

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

คุณสามารถใช้push(), pop(), shift()และunshift()วิธีการ:

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

การใช้งาน:

arrayRotate(['h','e','l','l','o']);       // ['e','l','l','o','h'];
arrayRotate(['h','e','l','l','o'], true); // ['o','h','e','l','l'];

หากคุณต้องการcountโต้แย้งดูคำตอบอื่นของฉัน: https://stackoverflow.com/a/33451102 🖤🧡💚💙💜

ฉันอาจจะทำสิ่งนี้:

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

แก้ไข     นี่คือเวอร์ชัน mutator:

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

ฟังก์ชั่นนี้ทำงานได้ทั้งสองทางและใช้ได้กับตัวเลขใด ๆ (แม้จะมีจำนวนมากกว่าความยาวอาร์เรย์ก็ตาม):

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

คำตอบจำนวนมากเหล่านี้ดูซับซ้อนเกินไปและอ่านยาก ไม่คิดว่าจะเห็นใครใช้ splice with 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 เอาต์พุต (* สร้างในเดือนพฤษภาคม):

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

modifiedArray =

W,N,E,S

การใช้สเปรดของ ES6 สำหรับตัวอย่างที่ไม่เปลี่ยนรูป ...

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

และ

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

อาจไม่ได้มีประสิทธิภาพมากที่สุด แต่ก็รัดกุม

วิธีแก้ปัญหาง่ายๆด้วยชิ้นส่วนและการทำลาย:

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]

นี่เป็นวิธีง่ายๆในการเปลี่ยนรายการในอาร์เรย์:

function rotate(array, stepsToShift) {

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

    return array;
}

@ คริสตอฟคุณทำรหัสสะอาดแล้ว แต่ช้าที่สุด 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

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

เมื่อฉันไม่พบตัวอย่างข้อมูลสำเร็จรูปที่จะเริ่มรายการวันด้วย "วันนี้" ฉันก็ทำเช่นนี้ (ไม่ใช่แบบทั่วไปอาจจะละเอียดอ่อนกว่าตัวอย่างข้างต้นมาก แต่ก็ได้ผล):

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

ขอบคุณ refactor เล็กน้อยโดยโปรแกรมเมอร์ที่ดีกว่าฉันมันสั้นกว่าความพยายามครั้งแรกของฉันหรือสองบรรทัด แต่ยินดีต้อนรับความคิดเห็นเพิ่มเติมเกี่ยวกับประสิทธิภาพ

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]

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

คำตอบที่ยอมรับมีข้อบกพร่องที่ไม่สามารถจัดการอาร์เรย์ที่มีขนาดใหญ่กว่าขนาด call stack ซึ่งขึ้นอยู่กับเซสชัน แต่ควรมีค่าประมาณ 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 ควรเปลี่ยนอาร์เรย์ปัจจุบันหรือสร้างอาร์เรย์ใหม่ฟังก์ชันของคุณสามารถทำได้ขึ้นอยู่กับว่าจำเป็นต้องใช้ shift หรือไม่ (ถูกต้องทั้งหมด .. )

ฉันได้ตัดสินใจที่จะแก้ไขโค้ดดังนี้

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

แล้วอีกครั้ง; แน่นอนว่า JS functors Array.prototype.map()นั้นช้าเมื่อเทียบกับสิ่งที่เทียบเท่าที่เข้ารหัสด้วย 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;
};

ฟังก์ชันนี้เร็วกว่าคำตอบที่ยอมรับสำหรับอาร์เรย์ขนาดเล็กเล็กน้อย แต่เร็วกว่ามากสำหรับอาร์เรย์ขนาดใหญ่ ฟังก์ชั่นนี้ยังอนุญาตให้มีจำนวนการหมุนที่มากกว่าความยาวของอาร์เรย์ซึ่งเป็นข้อ จำกัด ของฟังก์ชันดั้งเดิม

สุดท้ายคำตอบที่ยอมรับจะหมุนไปในทิศทางตรงกันข้ามตามที่อธิบายไว้

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

คุณสามารถตรวจสอบรายละเอียดประสิทธิภาพได้ที่นี่

แก้ไข :: เฮ้ปรากฎว่ามีการทำซ้ำมากเกินไป ไม่มีลูปไม่แตกแขนง

ยังคงใช้งานได้กับ 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))

แก้ไข 1 :: * การใช้งานแบบไม่มีสาขาและไม่มีการกลายพันธุ์

เดี๋ยวก่อนปรากฎว่าฉันมีสาขาที่ฉันไม่ต้องการมัน นี่คือวิธีแก้ปัญหาที่ใช้งานได้ จำนวนลบ = หมุนขวาโดย | 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 ขนาดใหญ่ตามอำเภอใจ

เดิม

หมุนไปทางซ้ายและขวา หมุนซ้ายกับบวกขวาหมุนกับเชิงลบnn

ใช้งานได้กับปัจจัยการผลิตขนาดใหญ่ที่หยาบคายของ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]และถูกข่มขู่ อย่าเป็น ฉันใช้เวลา 3 นาทีในการเล่นซ้ำเพื่อให้ได้ผล

1. เรารู้ว่าเป็นลบเนื่องจากกรณีที่เป็นn n < 0หากตัวเลขมีขนาดใหญ่กว่าช่วงของ Array n % A.lengthจะแมปลงในช่วง
2. n + A.lengthเพิ่มตัวเลขนั้นA.lengthเพื่อหักล้าง n จำนวนเงินที่ถูกต้อง
3. เรารู้ว่าเป็นลบเนื่องจากกรณีที่เป็นn เพิ่มตัวเลขนั้นเพื่อหักล้าง n จำนวนเงินที่ถูกต้องn < 0n + A.lengthA.length

4. ถัดไปแมปกับช่วงของความยาวของ A โดยใช้โมดูโล การปรับเปลี่ยนที่สองเป็นสิ่งจำเป็นในการแมปผลลัพธ์ของการคำนวณเป็นช่วงที่สามารถจัดทำดัชนีได้

   

5. ดัชนีแรก: -4 + 0 = -4 A.length = 5. A.length - 4 = 1. A 2คือ 2. ดัชนีแผนที่ 0 ถึง 2[2,... ]

6. ดัชนีถัดไป -4 + 1 = -3 5 + -3 = 2. A 2คือ 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 อยู่นอกขอบเขตเมื่อสร้างดัชนีดังนั้นแมป A 2กับค่าที่ส่วนที่เหลือ5 / 5ซึ่งคือ 0 A 2 = ค่าที่ A [0][5,1...]
3. ทำซ้ำ

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

โซลูชันที่ไม่กลายพันธุ์

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

ฉันกำลังแบ่งปันวิธีการแก้ปัญหาของฉันที่ฉันใช้ในการหมุนบนม้าหมุน อาจแตกได้เมื่อขนาดอาร์เรย์เล็กกว่า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]

วิธีการเพิ่มตัวนับจากนั้นหาส่วนที่เหลือของการหารด้วยความยาวอาร์เรย์เพื่อให้ได้ตำแหน่งที่คุณควรจะเป็น

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

ไวยากรณ์ของภาษานอกเหนือจากนี้ควรใช้งานได้ดี

หากอาร์เรย์ของคุณมีขนาดใหญ่และ / หรือคุณกำลังจะหมุนเวียนมากคุณอาจต้องการพิจารณาใช้รายการที่เชื่อมโยงแทนอาร์เรย์

@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)

ฉันมาช้า แต่ฉันมีอิฐที่จะเพิ่มคำตอบที่ดีเหล่านี้ ฉันถูกขอให้เขียนโค้ดฟังก์ชันดังกล่าวและฉันทำครั้งแรก:

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

ฉันไม่แน่ใจว่านี่เป็นวิธีที่มีประสิทธิภาพที่สุดหรือไม่ แต่ฉันชอบวิธีอ่านมันเร็วพอสำหรับงานขนาดใหญ่ส่วนใหญ่เพราะฉันได้ทดสอบในการผลิต ...

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

เนทีฟเร็วเล็กความหมายใช้ได้กับเครื่องยนต์เก่าและ "แกงได้"

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

** การใช้ 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)

Arrayใน JS ได้สร้างด้านล่างในวิธีการที่สามารถใช้ในการหมุนอาร์เรย์ค่อนข้างง่ายและเห็นได้ชัดว่าวิธีการเหล่านี้ไม่เปลี่ยนรูปในธรรมชาติ

• 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]

ใช้สำหรับลูป นี่คือขั้นตอน

1. จัดเก็บองค์ประกอบแรกของอาร์เรย์เป็นตัวแปรชั่วคราว
2. จากนั้นสลับจากซ้ายไปขวา
3. จากนั้นกำหนดตัวแปร temp ให้กับองค์ประกอบสุดท้ายของอาร์เรย์
4. ทำซ้ำขั้นตอนเหล่านี้สำหรับจำนวนการหมุน

function rotateLeft(arr, rotations) {
    let len = arr.length;
    for(let i=0; i<rotations; i++){ 
        let temp = arr[0];
        for(let i=0; i< len; i++){
            arr[i]=arr[i+1];
        }
        arr[len-1]=temp;
    }
    return arr;
}

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

let rotations = 3;
let output = rotateLeft(arr, rotations);
console.log("Result Array => ", output);

ด้วยไวยากรณ์ es6

function rotLeft(a, d) {
    const removed = a.splice(0,d);
    return [...a, ...removed];
}

ใช้สิ่งต่อไปนี้ -

arr=[1,2,3,4,5]  
let arrs=[]
arrs=arr.slice(d%arr.length).concat(arr.slice(0,d%arr.length))

ที่ไหน ไม่มีของการdหมุน
ทางออกที่ดีที่สุดไม่จำเป็นต้องใช้เทคนิค Brute force ของ Popping Pushing ด้วย ความซับซ้อนของเวลาO (1)