Gire os elementos em uma matriz em JavaScript

Eu estava me perguntando qual era a maneira mais eficiente de girar um array JavaScript.

Eu descobri esta solução, onde um positivo ngira a matriz para a direita e um negativo npara a esquerda ( -length < n < length):

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

Que pode então ser usado desta forma:

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

Minha versão original acima tem uma falha, como apontado por Christoph nos comentários abaixo, uma versão correta é (o retorno adicional permite encadeamento):

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

Existe uma solução mais compacta e / ou rápida, possivelmente no contexto de um framework JavaScript? (nenhuma das versões propostas abaixo é mais compacta ou mais rápida)

Existe alguma estrutura de JavaScript com uma rotação de array embutida? (Ainda não respondido por ninguém)

Versão genérica com segurança de tipo que altera a matriz:

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

Nos comentários, Jean levantou a questão de que o código não suporta sobrecarga de push()e splice(). Não acho que isso seja realmente útil (veja os comentários), mas uma solução rápida (um pouco como um hack, embora) seria substituir a linha

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

com este:

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

Usar em unshift()vez de push()é quase duas vezes mais rápido no Opera 10, enquanto as diferenças no FF eram insignificantes; o código:

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

Você pode usar push(), pop(), shift()e unshift()métodos:

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

uso:

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

Se você precisar de um countargumento, veja minha outra resposta: https://stackoverflow.com/a/33451102 🖤🧡💚💙💜

Eu provavelmente faria algo assim:

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

Editar     Aqui está uma versão modificadora:

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

Esta função funciona em ambos os sentidos e funciona com qualquer número (mesmo com um número maior que o comprimento da matriz):

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

uso:

for(let i = -6 ; i <= 6 ; i++) {
  console.log(arrayRotate(["🧡","💚","💙","💜","🖤"], i), i);
}

resultado:

[ "🖤", "🧡", "💚", "💙", "💜" ]    -6
[ "🧡", "💚", "💙", "💜", "🖤" ]    -5
[ "💚", "💙", "💜", "🖤", "🧡" ]    -4
[ "💙", "💜", "🖤", "🧡", "💚" ]    -3
[ "💜", "🖤", "🧡", "💚", "💙" ]    -2
[ "🖤", "🧡", "💚", "💙", "💜" ]    -1
[ "🧡", "💚", "💙", "💜", "🖤" ]    0
[ "💚", "💙", "💜", "🖤", "🧡" ]    1
[ "💙", "💜", "🖤", "🧡", "💚" ]    2
[ "💜", "🖤", "🧡", "💚", "💙" ]    3
[ "🖤", "🧡", "💚", "💙", "💜" ]    4
[ "🧡", "💚", "💙", "💜", "🖤" ]    5
[ "💚", "💙", "💜", "🖤", "🧡" ]    6

Muitas dessas respostas parecem complicadas e difíceis de ler. Acho que não vi ninguém usando splice com 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;
}

Saídas console.log (* geradas em maio):

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

Quanto à compactação, posso oferecer algumas funções genéricas de uma linha (sem contar a parte console.log | return). Basta inserir a matriz e o valor alvo nos argumentos.

Eu combino essas funções em uma para um programa de jogo de cartas para quatro jogadores, onde a matriz é ['N', 'E', 'S', 'W']. Deixei-os separados caso alguém queira copiar / colar para suas necessidades. Para os meus propósitos, utilizo as funções quando procuro quem é a próxima vez de jogar / agir durante as diferentes fases do jogo (Pinochle). Não me preocupei em testar a velocidade, então, se outra pessoa quiser, fique à vontade para me informar os resultados.

* Observe, a única diferença entre as funções é o "+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;
}

função de combinação ...

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

AdjustArray =

W,N,E,S

Usando a propagação do ES6 como um exemplo imutável ...

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

e

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

Provavelmente não é o mais eficiente, mas é conciso.

Solução fácil com fatia e desestruturação:

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]

Esta é uma maneira muito simples de deslocar itens em uma matriz:

function rotate(array, stepsToShift) {

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

    return array;
}

@Christoph, você fez um código limpo, mas 60% mais lento do que este que encontrei. Veja o resultado em jsPerf: http://jsperf.com/js-rotate-array/2 [Editar] OK, agora há mais navegadores e métodos não óbvios de bruxa, os melhores

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

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

Quando não consegui encontrar um snippet pronto para começar uma lista de dias com 'hoje', fiz assim (não muito genérico, provavelmente muito menos refinado do que os exemplos acima, mas deu certo):

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

Graças a uma pequena refatoração por um programador melhor do que eu, é uma ou duas linhas mais curta do que minha tentativa inicial, mas quaisquer comentários adicionais sobre eficiência são bem-vindos.

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

Em uma linha de código:

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

A resposta aceita tem uma falha de não ser capaz de lidar com matrizes maiores do que o tamanho da pilha de chamadas, que depende da sessão, mas deve ter cerca de 100 ~ 300 mil itens. Por exemplo, na sessão atual do Chrome que experimentei, era 250891. Em muitos casos, você pode nem saber o tamanho do array pode crescer dinamicamente. Então esse é um problema sério.

Para superar essa limitação, acho que um método interessante é utilizar Array.prototype.map()e mapear os elementos reorganizando os índices de maneira circular. Este método aceita um argumento inteiro. Se este argumento for positivo, ele girará na direção dos índices crescentes e se negativo na direção dos índices decrescentes. Isso tem apenas complexidade de tempo O (n) e retornará um novo array sem alterar aquele que é chamado enquanto manipula milhões de itens sem nenhum problema. Vamos ver como funciona;

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

Na verdade, depois de ter sido criticado em dois assuntos como segue;

1. Não há necessidade de uma condicional para entrada positiva ou negativa, uma vez que revela uma violação de DRY. Você poderia fazer isso com um mapa porque cada n negativo tem um equivalente positivo (totalmente certo ..)
2. Uma função Array deve alterar o array atual ou fazer um novo array, sua função pode fazer tanto dependendo se uma mudança é necessária ou não (Totalmente correto ..)

Decidi modificar o código da seguinte maneira;

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

Então de novo; é claro que os functores JS Array.prototype.map()são lentos em comparação com seus equivalentes codificados em JS simples. A fim de obter mais de 100% de aumento de desempenho, o seguinte provavelmente seria minha escolha Array.prototype.rotate()se algum dia eu precisasse girar um array no código de produção como o que usei em minha tentativa deString.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;
};

Esta função é um pouco mais rápida do que a resposta aceita para pequenos arrays, mas MUITO mais rápida para grandes arrays. Essa função também permite um número arbitrário de rotações maior do que o comprimento da matriz, o que é uma limitação da função original.

Por último, a resposta aceita gira na direção oposta, conforme descrito.

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

E o equivalente funcional (que parece também ter alguns benefícios de desempenho):

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

Você pode verificar a análise de desempenho aqui.

EDITAR:: Ei, acontece que há muita iteração acontecendo. Sem loops, sem ramificação.

Ainda funciona com n negativo para rotação à direita e n positivo para rotação à esquerda para qualquer tamanho n, sem mutação

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

Aqui está a versão do código de golfe para risos

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

EDIT1 :: * Implementação sem ramificações e sem mutação.

Então, ei, descobri que eu tinha um galho que não precisava. Aqui está uma solução de trabalho. num negativo = girar para a direita por | num | num positivo = girar para a esquerda por num

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

A equação ((n%l) + l) % lmapeia números exatamente positivos e negativos de quaisquer valores arbitrariamente grandes de n

ORIGINAL

Gire para a esquerda e para a direita. Gire para a esquerda com positivo n, gire para a direita com negativo n.

Funciona para entradas obscenamente grandes de n.

Sem modo de mutação. Muita mutação nessas respostas.

Além disso, menos operações do que a maioria das respostas. Sem estalo, sem empurrar, sem emenda, sem mudança.

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

ou

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

Explicação:

mapeie cada índice de A para o valor no deslocamento do índice. Nesse caso

offset = num

se o offset < 0then offset + index + positive length of Airá apontar para o deslocamento inverso.

se, offset > 0 and offset < length of Aentão, simplesmente mapeie o índice atual para o índice de deslocamento de A.

Caso contrário, module o deslocamento e o comprimento para mapear o deslocamento nos limites da matriz.

Tomemos por exemplo offset = 4e offset = -4.

Quando offset = -4, e A = [1,2,3,4,5], para cada índice, offset + indextornará a magnitude (ou Math.abs(offset)) menor.

Vamos explicar o cálculo do índice de n negativo primeiro. A[(((n % A.length) + A.length) % A.length)+0]e foi intimidado. Não sinta. Levei 3 minutos em um Repl para resolver isso.

1. Sabemos que né negativo porque o caso é n < 0. Se o número for maior do que o intervalo do Array, n % A.lengthirá mapeá-lo para o intervalo.
2. n + A.lengthadicione esse número para A.lengthcompensar na quantidade correta.
3. Sabemos que né negativo porque o caso é n < 0. n + A.lengthadicione esse número aA.length compensar na quantidade correta.

4. Próximo Mapeie-o para a faixa de comprimento de A usando módulo. O segundo módulo é necessário para mapear o resultado do cálculo em uma faixa indexável

   

5. Primeiro índice: -4 + 0 = -4. A.length = 5. a.length - 4 = 1. A 2 é 2. Mapa índice de 0 a 2.[2,... ]

6. Próximo índice, -4 + 1 = -3. 5 + -3 = 2. A 2 é 3. Índice do mapa 1 a 3.[2,3... ]
7. Etc.

O mesmo processo se aplica a offset = 4. Quando offset = -4, e A = [1,2,3,4,5], para cada índice, offset + indexaumentará a magnitude.

1. 4 + 0 = 0. Mapeie A [0] para o valor em A [4].[5...]
2. 4 + 1 = 5, 5 está fora dos limites durante a indexação, então mapeie A 2 para o valor no restante de 5 / 5, que é 0. A 2 = valor em A [0].[5,1...]
3. repetir.

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

Solução não mutante

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

com mutação

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

Estou compartilhando minha solução que estou usando para girar no carrossel. Ele pode quebrar quando o tamanho do array for menor do que displayCount, mas você pode adicionar uma condição extra para parar de girar quando for pequeno ou concatenar o array principal * displayCount vezes também.

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]

Que tal incrementar um contador e então obter o resto de uma divisão pelo comprimento do array para chegar onde você deveria estar.

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

Deixando de lado a sintaxe da linguagem, isso deve funcionar bem.

Se seu array vai ser grande e / ou você vai girar muito, você pode querer considerar o uso de uma lista encadeada em vez de um array.

@molokoloco Eu precisava de uma função que pudesse configurar para girar em uma direção - verdadeiro para frente e falso para trás. Eu criei um snippet que leva uma direção, um contador e uma matriz e produz um objeto com o contador incrementado na direção apropriada, bem como os valores anteriores, atuais e próximos. Ele NÃO modifica o array original.

Eu também o comparei com o seu snippet e, embora não seja mais rápido, é mais rápido do que aqueles com os quais você compara o seu - 21% mais lento 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)

Estou chegando tarde, mas tenho um tijolo a acrescentar a essas boas respostas. Pediram-me para codificar essa função e primeiro fiz:

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

Mas parecia menos eficiente do que seguir quando né grande:

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

Não tenho certeza se esta é a forma mais eficiente, mas gosto da forma como lê, é rápido o suficiente para a maioria das tarefas grandes, pois testei em produção ...

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

Nativo, rápido, pequeno, semântico, funciona em motores antigos e "curryable".

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

** Usando a versão mais recente do JS, podemos construí-lo facilmente **

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

aqui se move: número de rotações , um array que você pode passar por número aleatório

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

Arrayem JS tem o método embutido abaixo que pode ser usado para girar uma matriz com bastante facilidade e, obviamente, esses métodos são imutáveis por natureza.

• push: Insere o item no final da matriz.
• pop: Remove o item do final da matriz.
• unshift: Insere o item no início da matriz.
• shift: Remove o item do início da matriz.

A solução abaixo ( ES6) leva dois argumentos, a matriz precisa ser girada en, o número de vezes que a matriz deve ser girada.

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

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

Ele pode ser adicionado a Array.prototype e pode ser usado em todo o seu aplicativo

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]

Usando o loop for. Aqui estão os passos

1. Armazene o primeiro elemento da matriz como variável temporária.
2. Em seguida, troque da esquerda para a direita.
3. Em seguida, atribua a variável temporária ao último elemento da matriz.
4. Repita essas etapas para o número de rotações.

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

com sintaxe es6

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

Não tenho certeza sobre a eficiência, mas faria desta forma não mutante:

	Array.prototype.rotate = function( n ) {
  
		 return this.map( (item, index)=> this[ (this.length + index + n)%this.length ] )
	}