A swap() function would result in cleaner code (DRY) than doing the work inline. Unfortunately, the following function accomplished nothing because in JavaScript parameters are always pass-by-value:
function swap(a,b) { var temp=a; a=b; b=temp; }
Is there any way of writing a function that accomplished what this is attempting, particularly for numeric values?
I'm not impressed with the answers to this related question.
This answer has the right idea, but doesn't handle the general case.
As you correctly identified, since the parameters are passed by value you cannot write a function that replaces the block:
var a,b;
...
var tmp = a; a = b; b = tmp;
However, you can do it if both are values of an object:
var o = {};
o.a = 3;
o.b = 4;
function swap(obj) { var tmp = obj.a; obj.a = obj.b; obj.b = tmp; }
swap(o);
You can also generalize the swap:
function swap(obj, a, b) { var tmp = obj[a]; obj[a] = obj[b]; obj[b] = tmp; }
swap(o,'a','b')
You can also make this a prototype function:
Object.prototype.swap = function(a,b) { var tmp = this[a]; this[a] = this[b]; this[b] = tmp; }
o.swap('a','b')
With EMCAScript 6, you can abuse the destructuring assignment feature.
var x = 1, y = 2;
console.log(`x = ${x}, y = ${y}`);
[x, y] = [y, x];
console.log(`x = ${x}, y = ${y}`);MDN actually has this as one of its examples.
EDIT:
Somehow I missed the bold text in the question. If you absolutely need it to be a function, this kind of fits the definition (and is definitely intended as a joke):
function swap() {
return [arguments[1], arguments[0]];
}
var x = 1, y = 2;
console.log(`x = ${x}, y = ${y}`);
[x, y] = swap(x, y);
console.log(`x = ${x}, y = ${y}`);
To make swap(a,b) work as in C, you need references to the variables. It can be done lighter than in the above answer 1. Just
function swap(n, m) {
var temp = this[n];
this[n] = this[m];
this[m] = temp;
}
The this in this function is window, and call is swap('a', 'b'). Sure, you can avoid local variable temp with either logic or arithmetic (for ints).
I found this approach, which isn't too bad (at least for my purposes):
function swap( swap_name_a, swap_name_b )
{
eval
(
"var swap_temp="+swap_name_a+";"
+ swap_name_a+"="+swap_name_b+";"
+ swap_name_b+"=swap_temp;"
);
}
You are required to quote the arguments:
swap('a','b');
It seems to also work with more complex arguments:
swap('list[index1]','list[index2]');
Note: You will need to implement the swap() function within each scope that it will be used because it must have access to the named arguments. This goes against the "don't-repeat-yourself" principal, but in some circumstances it may be acceptable to copy-and-paste a bit of boilerplate code like this if it results in simplification of your algorithm logic.
By the way: The example from which I derived this returned the string from swap() and relied on the caller to forward the string to eval: eval(swap('a','b')). This solves the scope problem, but makes the swap operation more error prone -- and less attractive.
Be careful, that source also warned that this method could result in taunting.
Will time-traveling space-vampires steal your credit cards if you use eval()? You should decide that for yourself, but here's some help:
The biggest concern I see is that this might be relatively slow (depending on how the interpreter manages caching). If it is too slow for your purposes, then don't use it.