If you know the indexes you could easily swap the elements, with a simple function like this:

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

Array indexes are just properties of the array object, so you can swap its values.

With ES6 you can do something like this:

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] 

Here is an immutable version for those who are interested:

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

You could always use the sort method, if you don't know where the record is at present:

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

Change 2 to 1 as the first parameter in the splice call when removing the element:

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

Immutable version, no side effects (doesn’t mutate original array):

const testArr = [1, 2, 3, 4, 5]; function move(from, to, arr) { const newArr = [...arr]; const item = newArr.splice(from, 1)[0]; newArr.splice(to, 0, item); return newArr; } console.log(move(3, 1, testArr)); // [1, 4, 2, 3, 5] 

codepen: https://codepen.io/mliq/pen/KKNyJZr

EDIT: Please check out Andy's answer as his answer came first and this is solely an extension of his

I know this is an old question, but I think it's worth it to include Array.prototype.sort().

Here's an example from MDN along with the link

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

Luckily it doesn't only work with numbers:

arr.sort([compareFunction])

compareFunction

Specifies a function that defines the sort order. If omitted, the array is sorted according to each character's Unicode code point value, according to the string conversion of each element.

I noticed that you're ordering them by first name:

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

note that if you wanted to order them by last name you would have to either have a key for both first_name & last_name or do some regex magic, which I can't do XD

Hope that helps :)

Time complexity of all answers is O(n^2) because had used twice spice. But O(n/2) is possible.

Most Perfomance Solution:

• Array with n elements,
• x is to, y is from
• should be n >x && n > y

time complexity should be |y - x|. So its is number of elements that is between from and to.

• bestcase: O(1); //ex: from:4 to:5
• average : O(n/2)
• worthcase : O(n) //ex: from:0 to:n

function reOrder(from,to,arr) { if(from == to || from < 0 || to < 0 ) { return arr}; var moveNumber = arr[from]; if(from < to) { for(var i =from; i< to; i++){ arr[i] = arr[i+1] } } else{ for(var i = from; i > to; i--){ arr[i] = arr[i-1]; } } arr[to] = moveNumber; return arr; } var arr = [0,1,2,3,4,5,6,7,8,9,10,11,12,13]; console.log(reOrder(3,7,arr));

Try this:

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

If you only ever want to move one item from an arbitrary position to the end of the array, this should work:

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

If you want to move multiple items from some arbitrary position to the end, you can do:

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

If you want to move multiple items from some arbitrary position to some arbitrary position, try:

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

I came here looking for a rearranging complete array, I want something like I did below, but found most of the answers for moving only one element from position A to position B.

Hope my answer will help someone here

function reArrangeArray(firstIndex=0,arr){ var a = []; var b = [] for(let i = 0; i<= (arr.length-1); i++){ if(i<firstIndex){ a.push(arr[i]) }else{ b.push(arr[i]) } } return b.concat(a) } const arrayToRearrange = [{name: 'A'},{name: 'B'},{name: 'C'},{name: 'D'},{name: 'E'}]; reArrangeArray(2,arrayToRearrange) // Output // [ // { name: 'C' }, // { name: 'D' }, // { name: 'E' }, // { name: 'A' }, // { name: 'B' } // ] 

As a simple mutable solution you can call splice twice in a row:

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

On the other hand, a simple inmutable solution could use slice since this method returns a copy of a section from the original array without changing it:

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