If you are familiar with index positions, swapping elements in an array can be done easily using a simple function like the one shown below:

function exchangeElements(list, positionA, positionB) {
  var temp = list[positionA];
  list[positionA] = list[positionB];
  list[positionB] = temp;
}

exchangeElements(songList, 2, 5);
// [{"artist":"John Coltrane","title":"Giant Steps"},
//  {"artist":"Miles Davis","title":"So What"},
//  {"artist":"Duke Ellington","title":"Take the A Train"}]

Array indices serve as properties of the array object, allowing for easy value swapping.

One way to achieve this functionality with ES6 is as follows:

const switchValues = (list, index1 ,index2) => {
  [list[index1], list[index2]] = [list[index2], list[index1]]
}

let list = [10,20,30,40,50];
switchValues(list,0,1);

/// => [20, 10, 30, 40, 50]

For those interested, here is a preserved version:

function preservedMove(array, start, end) {
  return array.reduce((prev, current, index, self) => {
    if (start === end) {
      prev.push(current);
    }
    if (index === start) {
      return prev;
    }
    if (start < end) {
      prev.push(current);
    }
    if (index === end) {
      prev.push(self[start]);
    }
    if (start > end) {
      prev.push(current);
    }
    return prev;
  }, []);
}

If you're unsure of the current position of the record, one approach is to utilize the sort method:

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

Modify the first parameter from 2 to 1 in the splice method when deleting the element:

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

Here's a method to move an item in an array without mutating the original array:

const numbers = [10, 20, 30, 40, 50];

function moveItem(fromIndex, toIndex, arr) {
    const newArr = [...arr]; // Create a new copy of the original array

    const itemToMove = newArr.splice(fromIndex, 1)[0]; // Remove the item from the 'fromIndex' and store it
    newArr.splice(toIndex, 0, itemToMove); // Insert the stored item at the 'toIndex'

    return newArr;
}

console.log(moveItem(2, 4, numbers));

// Output: [10, 20, 40, 30, 50]

CodePen link for demonstration: https://codepen.io/mliq/pen/KKNyJZr

NOTE: I recommend checking out Andy's response, as it was posted earlier and my answer builds upon his.

Although this question is dated, I believe it's valuable to mention the use of Array.prototype.sort().

Here's an example from MDN along with the provided link

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

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

Fortunately, this method isn't limited to just sorting numbers:

arr.sort([compareFunction])

compareFunction

Defines a function that determines the sort order. If not specified, the array is sorted based on each character's Unicode code point value, according to the string conversion of each element.

I observed that you're arranging 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; }

  // names are equal
  return 0;
});

Just a side note, if you wish to organize them by last name, consider including keys for both first_name & last_name, or explore regex techniques (which I'm unable to assist with XD)

Hope this information proves useful :)

For the time complexity of all solutions, it is O(n^2) because the spice operation is used twice. However, there is potential for optimizing to O(n/2).

Optimal Solution:

• An array containing n elements,
• x represents 'to', y represents 'from'
• The condition should be n > x && n > y

The time complexity should be |y - x|, which corresponds to the number of elements between from and to.

• Best Case: O(1); //e.g. from:4 to:5
• Average Case: O(n/2)
• Worst Case: O(n) //e.g. 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));

Give this a shot:

arrangeList = arrangeList.concat(arrangeList.slice(1, 1));

To relocate a single item from any position to the end of an array, you can utilize this function:

function moveToTheEnd(array, index) {
    array.push(array.splice(index, 1));
    return array;
}

If your goal is to move multiple items starting from a specified position to the end of the array, use the following function:

function moveToTheEnd(array, start, count) {
    array.push.apply(array, array.splice(start, count));
    return array;
}

In case you need to move several items from one arbitrary position to another, you can try out this function:

function rearrange(array, start, count, destination) {
    var args = [start > destination ? destination : destination - count, 0];
    args.push.apply(args, array.splice(start, count));
    array.splice.apply(array, args);

    return array;
}

Upon my arrival here, my quest was to find a method for completely rearranging an array. I initially attempted the approach below, only to discover that most solutions focused on moving one element at a time from position A to position B.

I am optimistic that my solution will assist someone in need.

function reArrangeArray(startIndex=0,arr){
    var firstHalf = [];
    var secondHalf = []
    for(let i = 0; i<= (arr.length-1); i++){
        if(i<startIndex){
            firstHalf.push(arr[i])
        }else{
            secondHalf.push(arr[i])
        }
    }
    return secondHalf.concat(firstHalf)
}

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

If you're looking for a straightforward way to rearrange elements, consider utilizing the splice method twice consecutively:

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

Alternatively, for an immutable solution, you can rely on the slice method which generates a new array without altering the original one:

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