Dì, ho un array che assomiglia a questo:

var playlist = [
    {artist:"Herbie Hancock", title:"Thrust"},
    {artist:"Lalo Schifrin", title:"Shifting Gears"},
    {artist:"Faze-O", title:"Riding High"}
];

Come posso spostare un elemento in un'altra posizione?

Voglio muovermi, ad esempio, {artist:"Lalo Schifrin", title:"Shifting Gears"}fino alla fine.

Ho provato a usare la giunzione, in questo modo:

var tmp = playlist.splice(2,1);
playlist.splice(2,0,tmp);

Ma non funziona.

La sintassi di Array.spliceè:

yourArray.splice(index, howmany, element1, /*.....,*/ elementX);

Dove:

• index è la posizione nell'array da cui vuoi iniziare a rimuovere gli elementi
• howmany è il numero di elementi che desideri rimuovere da index
• elemento1, ..., elementX sono elementi che si desidera inserita dalla posizione di indice .

Ciò significa che splice()può essere utilizzato per rimuovere elementi, aggiungere elementi o sostituire elementi in un array, a seconda degli argomenti passati.

Notare che restituisce un array degli elementi rimossi.

Qualcosa di carino e generico sarebbe:

Array.prototype.move = function (from, to) {
  this.splice(to, 0, this.splice(from, 1)[0]);
};

Quindi usa:

var ar = [1,2,3,4,5];
ar.move(0,3);
alert(ar) // 2,3,4,1,5

Diagramma:

Se conosci gli indici potresti facilmente scambiare gli elementi, con una semplice funzione come questa:

function swapElement(array, indexA, indexB) {
  var tmp = array[indexA];
  array[indexA] = array[indexB];
  array[indexB] = tmp;
}

swapElement(playlist, 1, 2);
// [{"artist":"Herbie Hancock","title":"Thrust"},
//  {"artist":"Faze-O","title":"Riding High"},
//  {"artist":"Lalo Schifrin","title":"Shifting Gears"}]

Gli indici array sono solo proprietà dell'oggetto array, quindi puoi scambiarne i valori.

Ecco una versione immutabile per coloro che sono interessati:

function immutableMove(arr, from, to) {
  return arr.reduce((prev, current, idx, self) => {
    if (from === to) {
      prev.push(current);
    }
    if (idx === from) {
      return prev;
    }
    if (from < to) {
      prev.push(current);
    }
    if (idx === to) {
      prev.push(self[from]);
    }
    if (from > to) {
      prev.push(current);
    }
    return prev;
  }, []);
}

Modificare 2 in 1 come primo parametro nella chiamata di giunzione quando si rimuove l'elemento:

var tmp = playlist.splice(1, 1);
playlist.splice(2, 0, tmp[0]);

Con ES6 puoi fare qualcosa del genere:

const swapPositions = (array, a ,b) => {
  [array[a], array[b]] = [array[b], array[a]]
}

let array = [1,2,3,4,5];
swapPositions(array,0,1);

/// => [2, 1, 3, 4, 5]

Puoi sempre usare il metodo di ordinamento, se non sai dove si trova il record al momento:

playlist.sort(function (a, b) {
    return a.artist == "Lalo Schifrin" 
               ? 1    // Move it down the list
               : 0;   // Keep it the same
});

EDIT: Per favore controlla la risposta di Andy poiché la sua risposta è arrivata prima e questa è solo un'estensione della sua

So che questa è una vecchia domanda, ma penso che valga la pena includerla Array.prototype.sort().

Ecco un esempio da MDN insieme al collegamento

var numbers = [4, 2, 5, 1, 3];
numbers.sort(function(a, b) {
  return a - b;
});
console.log(numbers);

// [1, 2, 3, 4, 5]

Fortunatamente non funziona solo con i numeri:

arr.sort([compareFunction])

compareFunction

Specifica una funzione che definisce l'ordinamento. Se omesso, l'array viene ordinato in base al valore del punto di codice Unicode di ciascun carattere, in base alla conversione di stringa di ciascun elemento.

Ho notato che li stai ordinando per nome:

let playlist = [
    {artist:"Herbie Hancock", title:"Thrust"},
    {artist:"Lalo Schifrin", title:"Shifting Gears"},
    {artist:"Faze-O", title:"Riding High"}
];

// sort by name
playlist.sort((a, b) => {
  if(a.artist < b.artist) { return -1; }
  if(a.artist > b.artist) { return  1; }

  // else names must be equal
  return 0;
});

nota che se vuoi ordinarli per cognome dovresti avere una chiave per entrambi first_name & last_nameo fare un po 'di magia regex, cosa che non posso fare XD

Spero che aiuti :)

Prova questo:

playlist = playlist.concat(playlist.splice(1, 1));

Se vuoi spostare solo un elemento da una posizione arbitraria alla fine dell'array, dovrebbe funzionare:

function toEnd(list, position) {
    list.push(list.splice(position, 1));
    return list;
}

Se vuoi spostare più elementi da una posizione arbitraria alla fine, puoi fare:

function toEnd(list, from, count) {
    list.push.apply(list, list.splice(from, count));
    return list;
}

Se desideri spostare più elementi da una posizione arbitraria a una posizione arbitraria, prova:

function move(list, from, count, to) {
    var args = [from > to ? to : to - count, 0];
    args.push.apply(args, list.splice(from, count));
    list.splice.apply(list, args);

    return list;
}

Come semplice soluzione mutevole puoi chiamare splice due volte di seguito:

playlist.splice(playlist.length - 1, 1, ...playlist.splice(INDEX_TO_MOVE, 1))

D'altra parte, una semplice soluzione immutabile potrebbe utilizzare slice poiché questo metodo restituisce una copia di una sezione dall'array originale senza modificarlo:

const copy = [...playlist.slice(0, INDEX_TO_MOVE - 1), ...playlist.slice(INDEX_TO_MOVE), ...playlist.slice(INDEX_TO_MOVE - 1, INDEX_TO_MOVE)]

Riordina il suo lavoro in questo modo

 var tmpOrder = playlist[oldIndex];
    playlist.splice(oldIndex, 1);
    playlist.splice(newIndex, 0, tmpOrder);

Spero che funzioni