Swapping objects by reference?

Question

I'm looking to swap two objects using a swap function with just reference to them.

A typical use-case would be like this:

function swap(a, b) {
    ...
}

var a = [ { id: 1 }, { id: 2 } ]
swap(a[0], a[0])
console.log(a) // [ { id: 2 }, { id: 1 } ]

var one = { id: 1 }
var two = { id: 2 }
swap(one, two)
console.log(one) // Should be { id: 2 }
console.log(two) // Should be { id: 1 }

(Added some more use cases. swap Should not be dependent on any array functionalities.)

Is this possible? I know that javascript's functions are copy-reference source. So essentially, swap(a, b)'s a and b is just a copy of a[0] and a[1], so it seems like I can't swap them around without actually copying the fields of a into the fields of b and vice versa, which seems impractical.

---

edit: @timolawl pointed out ES6's destructuring, but it doesn't seem to work with this use case:

let a = [{ id: 1 }, { id: 2 }]

let one = a[0]
let two = a[1]

console.log(a[0])
console.log(a[1])

[one, two] = [two, one]

console.log(a[0])
console.log(a[1])

jsfiddle

Answer 1

With ES6, you can use destructuring:

General case:

[a, b] = [b, a];

Example:

let one = { id: 1 };
let two = { id: 2 };

document.body.insertAdjacentHTML('beforeend', '<pre>' + JSON.stringify(one, 0, 4) + '</pre>');
document.body.insertAdjacentHTML('beforeend', '<pre>' + JSON.stringify(two, 0, 4) + '</pre>');

[one, two] = [two, one];

document.body.insertAdjacentHTML('beforeend', '<pre>' + JSON.stringify(one, 0, 4) + '</pre>');
document.body.insertAdjacentHTML('beforeend', '<pre>' + JSON.stringify(two, 0, 4) + '</pre>');

Answer 2

It's possible to refactor this function to accomplish what you want - provide the array and two indices and swap based on those. For example:

function swap(array, a, b) {
    var temp = array[a]; // store a temporary copy of the variable

    // perform the swap
    array[a] = array[b];
    array[b] = temp;
}

Note that the temporary copy is necessary because data is overwritten when you set array[a] = array[b] - so you have to store the value of array[a] beforehand.

Answer 3

Swap via Deep copy

There is no simple way. Object.assign can help but any properties down the chain are only shallow copies. There is also the cludgy JSON copy. var b = JSON.parse(JSON.stringify(a)); but this does not handle functions and ignores all properties that are unassigned, and can not deal with any cyclic data (that is all to common). You can iterate the properties, and prototype chains and use Object.hasOwnProperty but again you are left with unknowns as to how deep the copy should be, how to workout inheritance, and more

Generally a copy (or swap) needs to be aware of the meaning and context of the data. Some may consider it a short fall not in Javascript favour, but then a general swap or copy funtion sort of breaks many of the rules of functional programing, data encapsulation, etc all of which have good reasoning behind them.

This and many more reasons are why there are no moves to provide a convenient deep copy.