Elementi di schiera dello scambio Javascript

C’è un modo più semplice per scambiare due elementi in un array?

var a = list[x], b = list[y]; list[y] = a; list[x] = b; 

Hai solo bisogno di una variabile temporanea.

 var b = list[y]; list[y] = list[x]; list[x] = b; 

Se si desidera una singola espressione, utilizzando javascript nativo, ricordare che il valore restituito da un’operazione di splicing contiene gli elementi rimossi.

 var A = [1, 2, 3, 4, 5, 6, 7, 8, 9], x= 0, y= 1; A[x] = A.splice(y, 1, A[x])[0]; alert(A); // alerts "2,1,3,4,5,6,7,8,9" 

Modificare:

Il [0] è necessario alla fine dell’espressione come Array.splice() restituisce un array, e in questa situazione richiediamo il singolo elemento nell’array restituito.

Questo sembra ok ….

 var b = list[y]; list[y] = list[x]; list[x] = b; 

Come usare

 var b = list[y]; 

significa che una variabile b sarà presente per il resto dello scope. Ciò può potenzialmente portare a una perdita di memoria. Improbabile, ma ancora meglio da evitare.

Forse è una buona idea metterlo in Array.prototype.swap

 Array.prototype.swap = function (x,y) { var b = this[x]; this[x] = this[y]; this[y] = b; return this; } 

che può essere chiamato come:

 list.swap( x, y ) 

Questo è un approccio pulito sia per evitare perdite di memoria e DRY .

Secondo alcune persone a caso su Metafilter , “Le versioni recenti di Javascript ti permettono di fare swap (tra le altre cose) molto più ordinatamente:”

 [ list[x], list[y] ] = [ list[y], list[x] ]; 

I miei test rapidi hanno dimostrato che questo codice Pythonic funziona alla grande nella versione di JavaScript attualmente utilizzata in “Google Apps Script” (“.gs”). Purtroppo, ulteriori test mostrano che questo codice fornisce un “Errore di riferimento non rilevato”: lato sinistro non valido nell’assegnazione. ” in qualsiasi versione di JavaScript (“.js”) viene utilizzata da Google Chrome versione 24.0.1312.57 m.

Bene, non è necessario bufferizzare entrambi i valori – solo uno:

 var tmp = list[x]; list[x] = list[y]; list[y] = tmp; 

Puoi scambiare elementi in un array nel seguente modo:

 list[x] = [list[y],list[y]=list[x]][0] 

Guarda il seguente esempio:

 list = [1,2,3,4,5] list[1] = [list[3],list[3]=list[1]][0] //list is now [1,4,3,2,5] 

Nota: funziona allo stesso modo per variabili regolari

 var a=1,b=5; a = [b,b=a][0] 

Con valori numerici è ansible evitare una variabile temporanea utilizzando bit xor bitwise

 list[x] = list[x] ^ list[y]; list[y] = list[y] ^ list[x]; list[x] = list[x] ^ list[y]; 

o una sum aritmetica (osservando che funziona solo se x + y è inferiore al valore massimo per il tipo di dati)

 list[x] = list[x] + list[y]; list[y] = list[x] - list[y]; list[x] = list[x] - list[y]; 

Digest da http://www.greywyvern.com/?post=265

 var a = 5, b = 9; b = (a += b -= a) - b; alert([a, b]); // alerts "9, 5" 

Per scambiare due elementi consecutivi di array

 array.splice(IndexToSwap,2,array[IndexToSwap+1],array[IndexToSwap]); 

che dire di Destructuring_assignment

 var arr = [1, 2, 3, 4] [arr[index1], arr[index2]] = [arr[index2], arr[index1]] 

che può anche essere esteso a

 [src order elements] => [dest order elements] 

Questo non esisteva quando la domanda è stata posta, ma ES2015 ha introdotto la destrutturazione dell’array, permettendoti di scriverlo come segue:

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

Puoi scambiare qualsiasi numero di oggetti o letterali, anche di tipi diversi, usando una semplice funzione di id quadro come questa:

 var swap = function (x){return x}; b = swap(a, a=b); c = swap(a, a=b, b=c); 

Per il tuo problema:

 var swap = function (x){return x}; list[y] = swap(list[x], list[x]=list[y]); 

Funziona in JavaScript perché accetta argomenti aggiuntivi anche se non sono dichiarati o utilizzati. Le assegnazioni a=b ecc. Si verificano dopo che a è passata nella funzione.

Per due o più elementi (numero fisso)

 [list[y], list[x]] = [list[x], list[y]]; 

Nessuna variabile temporanea richiesta!

Stavo pensando di chiamare semplicemente list.reverse() .
Ma poi ho realizzato che avrebbe funzionato come swap solo quando list.length = x + y + 1 .

Per numero variabile di elementi

Ho esaminato varie costruzioni Javascript in questo senso, tra cui Mappa e mappa , ma purtroppo nessuno ha prodotto un codice più compatto o più veloce di questa vecchia costruzione basata su loop:

 function multiswap(arr,i0,i1) {/* argument immutable if string */ if (arr.split) return multiswap(arr.split(""), i0, i1).join(""); var diff = []; for (let i in i0) diff[i0[i]] = arr[i1[i]]; return Object.assign(arr,diff); } Example: var alphabet = "abcdefghijklmnopqrstuvwxyz"; var [x,y,z] = [14,6,15]; var output = document.getElementsByTagName("code"); output[0].innerHTML = alphabet; output[1].innerHTML = multiswap(alphabet, [0,25], [25,0]); output[2].innerHTML = multiswap(alphabet, [0,25,z,1,y,x], [25,0,x,y,z,3]); 
 
Input:
Swap two elements:
Swap multiple elements: 
 var a = [1,2,3,4,5], b=a.length; for (var i=0; i 

C’è un modo interessante di scambiare:

 var a = 1; var b = 2; [a,b] = [b,a]; 

(Modo ES6)

Ecco un one-liner che non modifica l’ list :

let newList = Object.assign([], list, {[x]: list[y], [y]: list[x]})

(Usa le funzionalità della lingua non disponibili nel 2009 quando la domanda è stata pubblicata!)

Ecco una versione compatta scambia il valore in i1 con i2 in arr

 arr.slice(0,i1).concat(arr[i2],arr.slice(i1+1,i2),arr[i1],arr.slice(i2+1)) 

Ecco una variante che controlla innanzitutto se l’indice esiste nell’array:

 Array.prototype.swapItems = function(a, b){ if( !(a in this) || !(b in this) ) return this; this[a] = this.splice(b, 1, this[a])[0]; return this; } 

Al momento restituirà this se l’indice non esiste, ma potresti facilmente modificare il comportamento in caso di errore

Solo per il gusto di farlo, un altro modo senza utilizzare alcuna variabile extra sarebbe:

 var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]; // swap index 0 and 2 arr[arr.length] = arr[0]; // copy idx1 to the end of the array arr[0] = arr[2]; // copy idx2 to idx1 arr[2] = arr[arr.length-1]; // copy idx1 to idx2 arr.length--; // remove idx1 (was added to the end of the array) console.log( arr ); // -> [3, 2, 1, 4, 5, 6, 7, 8, 9] 

Per brevità, ecco la versione brutta di una copertina che è solo un po ‘meno brutta di tutto ciò che concatena e affetta sopra. La risposta accettata è veramente la strada da percorrere e molto più leggibile.

Dato:

 var foo = [ 0, 1, 2, 3, 4, 5, 6 ]; 

se si desidera scambiare i valori di due indici (a e b); allora questo lo farebbe:

 foo.splice( a, 1, foo.splice(b,1,foo[a])[0] ); 

Ad esempio, se vuoi scambiare il 3 e il 5, puoi farlo in questo modo:

 foo.splice( 3, 1, foo.splice(5,1,foo[3])[0] ); 

o

 foo.splice( 5, 1, foo.splice(3,1,foo[5])[0] ); 

Entrambi producono lo stesso risultato:

 console.log( foo ); // => [ 0, 1, 2, 5, 4, 3, 6 ] 

#splicehatersarepunks 🙂

Se non si desidera utilizzare la variabile temporanea in ES5, questo è un modo per scambiare gli elementi dell’array.

 var swapArrayElements = function (a, x, y) { if (a.length === 1) return a; a.splice(y, 1, a.splice(x, 1, a[y])[0]); return a; }; swapArrayElements([1, 2, 3, 4, 5], 1, 3); //=> [ 1, 4, 3, 2, 5 ] 

prova questa funzione …

 $(document).ready(function () { var pair = []; var destinationarray = ['AAA','BBB','CCC']; var cityItems = getCityList(destinationarray); for (var i = 0; i < cityItems.length; i++) { pair = []; var ending_point = ""; for (var j = 0; j < cityItems[i].length; j++) { pair.push(cityItems[i][j]); } alert(pair); console.log(pair) } }); function getCityList(inputArray) { var Util = function () { }; Util.getPermuts = function (array, start, output) { if (start >= array.length) { var arr = array.slice(0); output.push(arr); } else { var i; for (i = start; i < array.length; ++i) { Util.swap(array, start, i); Util.getPermuts(array, start + 1, output); Util.swap(array, start, i); } } } Util.getAllPossiblePermuts = function (array, output) { Util.getPermuts(array, 0, output); } Util.swap = function (array, from, to) { var tmp = array[from]; array[from] = array[to]; array[to] = tmp; } var output = []; Util.getAllPossiblePermuts(inputArray, output); return output; } 
  

Scambia il primo e l’ultimo elemento di un array senza variabile temporanea o metodo di scambio ES6 [a, b] = [b, a]

[a.pop(), ...a.slice(1), a.shift()]

Se necessario, scambia solo il primo e l’ultimo elemento:

 array.unshift( array.pop() ); 
 Array.prototype.swap = function(a, b) { var temp = this[a]; this[a] = this[b]; this[b] = temp; }; 

Uso:

 var myArray = [0,1,2,3,4...]; myArray.swap(4,1);