Comment échanger deux variables en JavaScript

J'ai ces deux variables:

var a = 1,
    b = 2;

Ma question est de savoir comment les échanger? Seulement ces variables, pas des objets.

Voici une ligne unique pour permuter les valeurs de deux variables.
Données variables aet b:

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

Démonstration ci-dessous:

var a=1,
    b=2,
    output=document.getElementById('output');

output.innerHTML="<p>Original: "+a+", "+b+"</p>";

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

output.innerHTML+="<p>Swapped: "+a+", "+b+"</p>";

<div id="output"></div>

ES6 (Firefox et Chrome le prennent déjà en charge (Destructuring Assignment Array Matching)):

let a = 5, b = 6;
[a, b] = [b, a];
console.log(`${a} ${b}`);

Tu peux le faire:

var a = 1,
    b = 2,
    tmp;
tmp = a;
a = b;
b = tmp;

Pour la lisibilité et la maintenabilité, cela est imbattable (du moins en JavaScript). Quiconque maintient le code (y compris vous dans six mois) saura exactement ce qui se passe.

Comme ce sont des nombres entiers, vous pouvez également utiliser n'importe quel nombre d'astuces intelligentes ¹ pour permuter sans utiliser une troisième variable. Par exemple, vous pouvez utiliser l'opérateur xor au niveau du bit:

let a = 1, b = 2;
a = a ^ b;
b = a ^ b;
a = a ^ b;
    
console.log('a is now:', a);
console.log('b is now:', b);

C'est ce qu'on appelle l'algorithme d'échange XOR. Sa théorie de fonctionnement est décrite dans cet article de Wikipédia .

¹ « Le programmeur compétent est pleinement conscient de la taille limitée de son propre crâne. Il se rapproche donc sa tâche avec humilité pleine et évite des tours intelligentes comme la peste. » - Edsger W. Dijkstra

N'utilisez pas le code ci-dessous. Ce n'est pas la méthode recommandée pour permuter les valeurs de deux variables ( utilisez simplement une variable temporaire pour cela). Cela montre juste une astuce JavaScript.

Cette solution n'utilise aucune variable temporaire, aucun tableau, un seul ajout et c'est rapide . En fait, c'est parfois plus rapide qu'une variable temporaire sur plusieurs plateformes .
Il fonctionne pour tous les nombres, ne déborde jamais et gère les cas extrêmes tels que Infinity et NaN.

a = b + (b=a, 0)

Cela fonctionne en deux étapes:

• (b=a, 0)définit bl'ancienne valeur de aet donne0
• a = b + 0définit al'ancienne valeur deb

Depuis ES6, vous pouvez également permuter les variables de manière plus élégante:

var a = 1,
    b = 2;

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

console.log('a:', a, 'b:', b); // a: 2 b: 1

Voici un one-liner, supposant aet bexistant déjà et ayant des valeurs à échanger:

var c=a, a=b, b=c;

Comme @Kay l'a mentionné, cela fonctionne en fait mieux que le mode tableau (presque 2x plus rapide).

Utilisez une troisième variable comme celle-ci:

var a = 1,
    b = 2,
    c = a;

a = b; // must be first or a and b end up being both 1
b = c;

DEMO - Utilisation d'une troisième variable

Méthode ES6 +: depuis ES6, vous pouvez permuter les variables plus élégamment. Vous pouvez utiliser la correspondance de tableau d'affectation de déstructuration. C'est tout simplement. var a = 10 b = 20;

[a, b] = [b, a]

console.log (a, b) // 20 10

Vous pouvez maintenant enfin faire:

let a = 5;
let b = 10;

[a, b] = [b, a]; // ES6

console.log(a, b);

Vous pouvez utiliser une variable d'échange temporaire ou XOR.

a = a ^ b
b = a ^ b
a = a ^ b

Ceci est juste un concept logique de base et fonctionne dans toutes les langues prenant en charge le fonctionnement XOR.

modifier: voir les commentaires. J'ai oublié de dire que cela ne fonctionne à coup sûr qu'avec un entier. Supposé les variables entières du fil de discussion de la question

Vous pouvez utiliser l' affectation de déstructuration ES6 comme ceci:

let a = 10;
let b = 20;

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

console.log(a, b); // a = 20, b = 10

Comme votre question était précieuse "Seulement ces variables, pas aucun objet.", La réponse sera également précieuse:

var a = 1, b = 2

a=a+b;
b=a-b;
a=a-b;

c'est un truc

Et comme l'a dit Rodrigo Assis, ça "peut être plus court"

 b=a+(a=b)-b;

Démo: http://jsfiddle.net/abdennour/2jJQ2/

Destructuration ES6:

À l'aide d'un tableau: [a, b] = [b, a]; // my favorite

Utilisation d'un objet: {a, b} = {a:b, b:a}; // not bad neither

Comment pourrions-nous manquer ces oneliners classiques

var a = 1, b = 2
a = ({a:b, _:(b=a)}).a;

Et

var a = 1, b = 2
a = (_=b,b=a,_);

Le dernier expose la variable globale '_' mais cela ne devrait pas avoir d'importance, car la convention javascript typique est de l'utiliser comme variable 'ne se soucie pas'.

Je vois une sorte d'olympiade de programmation ici. Une autre solution en une ligne délicate:

b = (function(){ a=b; return arguments[0]; })(a);

Violon: http://jsfiddle.net/cherniv/4q226/

Échange de ligne unique

a = a^b^(b^=(a^b));

var a = 5;
var b = 10;

b = [a, a = b][0];
//or
b = [a, a = b];
b = b[0];

//or
b = [a, b];
a = b[1];
b = b[0];


alert("a=" + a + ',' + "b=" + b);

supprimer ou commenter les 2 // ou et exécuter avec le seul ensemble de code

http://jsfiddle.net/USdv8/57/

Nous pouvons échanger des var comme ceci:

var val1 =  117,
    val2 = 327;

val2 = val1-val2; 
console.log(val2);
val1 = val1-val2;
console.log(val1);
val2 = val1+val2;
console.log(val2);

Dans ES6, il existe maintenant une affectation de déstructuration et vous pouvez faire:

let a = 1;
let b = 2;
[b, a] = [a, b]  // a = 2, b = 1

let a = 2, b = 4;
[b, a] = [a, b];

une approche plus verbeuse serait

let a = 2, b = 4;
a = [a, b];
b = a[0];
a = a[1];

C'est très simple, utilisez la syntaxe de déstructuration des tableaux ES6 qui est [y, x] = [x, y] pour plus d'informations consultez ce lien https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment

Jusqu'à ES5, pour échanger deux nombres, vous devez créer une variable temporaire, puis l'échanger. Mais dans ES6, il est très facile d'échanger deux nombres en utilisant la déstructuration des tableaux. Voir exemple.

let x,y;
[x,y]=[2,3];
console.log(x,y);      // return 2,3

[x,y]=[y,x];
console.log(x,y);      // return 3,2

Parce que j'entends que cette méthode fonctionne plus lentement:

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

Si vous prévoyez de stocker vos variables dans un objet (ou un tableau), cette fonction devrait fonctionner:

function swapVars(obj, var1, var2){
    let temp = obj[var1];
    obj[var1] = obj[var2];
    obj[var2] = temp;
}

Usage:

let test = {a: 'test 1', b: 'test 2'};

console.log(test); //output: {a: 'test 1', b: 'test 2'}

swapVars(test, 'a', 'b');

console.log(test); //output: {a: 'test 2', b: 'test 1'}

Nous pouvons utiliser l'IIFE pour échanger deux valeurs sans paramètre supplémentaire

var a = 5, b =8;
b = (function(a){ 
    return a 
}(a, a=b));

document.write("a: " + a+ "  b:  "+ b);

La déstructuration des tableaux ES6 est utilisée pour permuter deux variables. Voir exemple

var [x,y]=[1,2];
[x,y]=[y,x];

Une manière plus simple possible avec:

x === 1et y === 2; Mais après déstructuration, xest y, c'est 2-à- dire , et yest x, c'est-à-dire 1.

Swap en utilisant Bitwise

let a = 10;
let b = 20;
a ^= b;
y ^= a;
a ^= b;

Swap sur une seule ligne "à l'aide d'un tableau"

[a, b] = [b, a]

(fonction (A, B) {b = A; a = B;}) (parseInt (a), parseInt (b));