Réponses:
Voici une ligne unique pour permuter les valeurs de deux variables.
Données variables a
et 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>
[a, b] = [b, a];
.
Invalid left-hand side in assignment
erreur.
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 1 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 .
1 « 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
ToInt32
méthode interne - voir la section 11.10 du standard ECMAScript ). Il ne produit pas les résultats corrects pour les valeurs numériques non entières. Il convertit également les valeurs non numériques en entiers 32 bits. Si vous commencez par a = "hi"
et b = "there"
, vous vous retrouvez avec a == 0
et b == 0
.
typeof a == 'boolean'
ou a === false
, par exemple. Les nombres réels fonctionnent, sauf qu'ils sont arrondis vers zéro et arrondis à l'entier le plus proche.
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 b
l'ancienne valeur de a
et donne0
a = b + 0
définit a
l'ancienne valeur deb
,
, et il a été encapsulé pour définir la priorité à droite. L'opérateur virgule évalue ses deux arguments (dans ce cas b=a
et 0
) et renvoie le dernier (dans ce cas 0
). Donc ici, cela a pour effet de remettre le nouveau b
à l'ancienne valeur de a
, tout en cédant 0
.
Voici un one-liner, supposant a
et b
existant 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).
var a, b, tmp;
a = 1
:; b = 2
; tmp=a, a=b, b=tmp;
Goût personnel.
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;
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'.
a = (_=b,b=a,_);
_
? Pourquoi n'a-t-il pas besoin de déclaration?
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);
arguments
, faites-le b = (function (x){ return x; })(a, a=b)
.
arguments
liste serait également une variable.
a
à arguments[0]
en passant comme paramètre.
arguments
et son assignation se fait "dans les coulisses"
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
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 === 1
et y === 2
; Mais après déstructuration, x
est y
, c'est 2
-à- dire , et y
est 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));