Elemen array swap Javascript

Apakah ada cara yang lebih sederhana untuk menukar dua elemen dalam array?

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

Anda hanya perlu satu variabel sementara.

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

Edit pembajakan jawaban teratas 10 tahun kemudian dengan banyak adopsi ES6 di bawah ikat pinggang kami:

Dengan array yang diberikan arr = [1,2,3,4], Anda dapat menukar nilai dalam satu baris sekarang seperti:

[arr[0], arr[1]] = [arr[1], arr[0]];

Ini akan menghasilkan array [2,1,3,4]. Ini adalah tugas yang merusak .

Jika Anda ingin ekspresi tunggal, menggunakan javascript asli, ingat bahwa nilai kembali dari operasi splice berisi elemen yang telah dihapus.

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"

Edit:

The [0]diperlukan pada akhir ekspresi sebagai Array.splice()hasil array, dan dalam situasi ini kita memerlukan satu elemen dalam array kembali.

Ini sepertinya ok ....

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

Howerver menggunakan

var b = list[y];

berarti variabel b akan hadir untuk sisa ruang lingkup. Ini berpotensi menyebabkan kebocoran memori. Tidak mungkin, tetapi masih lebih baik untuk dihindari.

Mungkin ide yang bagus untuk memasukkan ini ke dalam Array.prototype.swap

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

yang bisa disebut seperti:

list.swap( x, y )

Ini adalah pendekatan yang bersih untuk menghindari kebocoran memori dan KERING .

Menurut beberapa orang acak di Metafilter , "Versi Javascript terbaru memungkinkan Anda melakukan swap (antara lain) jauh lebih rapi:"

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

Tes cepat saya menunjukkan bahwa kode Pythonic ini berfungsi dengan baik dalam versi JavaScript yang saat ini digunakan di "Google Apps Script" (".gs"). Sayangnya, tes lebih lanjut menunjukkan kode ini memberikan "Uncaught ReferenceError: sisi kiri tidak valid dalam penugasan." dalam versi apa pun JavaScript (".js") digunakan oleh Google Chrome Versi 24.0.1312.57 m.

Nah, Anda tidak perlu buffer kedua nilai - hanya satu:

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

Anda bisa menukar elemen dalam array dengan cara berikut:

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

Lihat contoh berikut:

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

Catatan: ini bekerja dengan cara yang sama untuk variabel biasa

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

Dengan nilai numerik Anda dapat menghindari variabel sementara dengan menggunakan bitwise xor

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

atau jumlah aritmatika (mencatat bahwa ini hanya berfungsi jika x + y kurang dari nilai maksimum untuk tipe data)

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

Ini tidak ada ketika pertanyaan diajukan, tetapi ES2015 memperkenalkan perusakan array, memungkinkan Anda untuk menulisnya sebagai berikut:

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

Untuk menukar dua elemen array berturut-turut

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

Intisari dari http://www.greywyvern.com/?post=265

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

bagaimana dengan Destructure_assignment

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

yang juga dapat diperpanjang ke

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

Pertimbangkan solusi seperti itu tanpa perlu mendefinisikan variabel ketiga:

function swap(arr, from, to) {
  arr.splice(from, 1, arr.splice(to, 1, arr[from])[0]);
}

var letters = ["a", "b", "c", "d", "e", "f"];

swap(letters, 1, 4);

console.log(letters); // ["a", "e", "c", "d", "b", "f"]

Catatan: Anda mungkin ingin menambahkan cek tambahan misalnya untuk panjang array. Solusi ini bisa berubah sehingga swapfungsi tidak perlu mengembalikan array baru, itu hanya mutasi over array yang dilewatkan.

Anda dapat menukar sejumlah objek atau literal, bahkan dari jenis yang berbeda, menggunakan fungsi identitas sederhana seperti ini:

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

Untuk masalah Anda:

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

Ini berfungsi dalam JavaScript karena ia menerima argumen tambahan meskipun tidak dideklarasikan atau digunakan. Penugasan a=bdll, terjadi setelah aditeruskan ke fungsi.

Untuk dua atau lebih elemen (nomor tetap)

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

Tidak diperlukan variabel sementara!

Saya sedang berpikir tentang sekadar menelepon list.reverse().
Tapi kemudian saya menyadari itu akan berfungsi sebagai swap hanya ketika list.length = x + y + 1.

Untuk jumlah elemen yang bervariasi

Saya telah melihat berbagai konstruksi Javascript modern untuk efek ini, termasuk Peta dan peta , tetapi sayangnya tidak ada yang menghasilkan kode yang lebih kompak atau lebih cepat daripada konstruksi berbasis loop yang kuno:

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]);

<table>
    <tr><td>Input:</td>                        <td><code></code></td></tr>
    <tr><td>Swap two elements:</td>            <td><code></code></td></tr>
    <tr><td>Swap multiple elements:&nbsp;</td> <td><code></code></td></tr>
</table>

Ada satu cara yang menarik untuk bertukar:

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

(Cara ES6)

var a = [1,2,3,4,5], b=a.length;

for (var i=0; i<b; i++) {
    a.unshift(a.splice(1+i,1).shift());
}
a.shift();
//a = [5,4,3,2,1];

Berikut adalah satu-liner yang tidak bermutasi list:

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

(Menggunakan fitur bahasa tidak tersedia pada 2009 ketika pertanyaan diposting!)

Berikut ini adalah nilai swap versi kompak di i1 dengan i2 di arr

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

Berikut adalah variasi yang pertama memeriksa apakah indeks ada dalam 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;
}

Saat ini hanya akan kembali thisjika indeks tidak ada, tetapi Anda dapat dengan mudah mengubah perilaku gagal

Tukar elemen pertama dan terakhir dalam array tanpa metode swap variabel atau ES6 sementara [a, b] = [b, a]

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

Solusi skrip yang mengkloning larik alih-alih mengubah yang sudah ada

export function swapItemsInArray<T>(items: T[], indexA: number, indexB: number): T[] {
  const itemA = items[indexA];

  const clone = [...items];

  clone[indexA] = clone[indexB];
  clone[indexB] = itemA;

  return clone;
}

Hanya untuk bersenang-senang, cara lain tanpa menggunakan variabel tambahan adalah:

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]

Demi singkatnya, inilah versi one-liner jelek yang hanya sedikit kurang jelek dari semua yang concat dan mengiris di atas. Jawaban yang diterima benar-benar cara untuk pergi dan jauh lebih mudah dibaca.

Diberikan:

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

jika Anda ingin menukar nilai dua indeks (a dan b); maka ini akan melakukannya:

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

Misalnya, jika Anda ingin menukar 3 dan 5, Anda bisa melakukannya dengan cara ini:

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

atau

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

Keduanya menghasilkan hasil yang sama:

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

#splicehatersarepunks :)

Jika Anda tidak ingin menggunakan variabel temp di ES5, ini adalah salah satu cara untuk menukar elemen 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 ]

coba fungsi ini ...

$(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;
    }

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

Menggunakan ES6 dimungkinkan untuk melakukannya seperti ini ...

Bayangkan Anda memiliki 2 array ini ...

const a = ["a", "b", "c", "d", "e"];
const b = [5, 4, 3, 2, 1];

dan Anda ingin menukar nilai pertama:

const [a0] = a;
a[0] = b[0];
b[0] = a0;

dan nilai:

a; //[5, "b", "c", "d", "e"]
b; //["a", 4, 3, 2, 1]

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

Pemakaian:

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

Jika perlu bertukar elemen pertama dan terakhir saja:

array.unshift( array.pop() );