Javascript takas dizisi öğeleri

Bir dizideki iki öğeyi değiştirmenin daha basit bir yolu var mı?

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

Sadece bir geçici değişkene ihtiyacınız var.

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

Düzenleme kaçırma 10 yıl sonra bizim kemerleri altında ES6 benimsenmesi bir sürü üst cevap:

Dizi göz önüne alındığında, arr = [1,2,3,4]şimdi bir satırdaki değerleri şu şekilde değiştirebilirsiniz:

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

Bu dizi üretecektir [2,1,3,4]. Bu yıkıcı ödev .

Yerel javascript kullanarak tek bir ifade istiyorsanız, bir ekleme işleminden döndürülen değerin kaldırılan öğeleri içerdiğini unutmayın.

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"

Düzenle:

[0]Olarak ifade sonunda gerekli olan Array.splice()geri dönüş bir dizi ve bu durumda biz geri dizideki tek bir öğe gerektirmez.

Bu iyi görünüyor ....

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

Howerver kullanma

var b = list[y];

kapsamın geri kalanı için bir b değişkeninin mevcut olacağı anlamına gelir . Bu potansiyel olarak bir bellek sızıntısına yol açabilir. Olası değil, ama yine de kaçınmak daha iyidir.

Belki bunu Array.prototype.swap içine koymak için iyi bir fikir

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

hangi gibi çağrılabilir:

list.swap( x, y )

Bu, hem temiz bir yaklaşımdır kaçınarak bellek sızıntıları ve KURU .

Metafilter'daki bazı rastgele kişilere göre , "Javascript'in son sürümleri swapları (diğer şeylerin yanı sıra) çok daha düzgün bir şekilde yapmanıza izin verir:"

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

Hızlı testlerim, bu Pythonic kodunun şu anda "Google Apps Script" (".gs") 'de kullanılan JavaScript sürümünde harika çalıştığını gösterdi . Ne yazık ki, diğer testler bu kodun "Yakalanmayan ReferenceError: Ödevde geçersiz sol taraf" verdiğini gösteriyor. hangi JavaScript sürümünde (".js") Google Chrome Sürüm 24.0.1312.57 m tarafından kullanılır.

Her iki değeri de tamponlamanız gerekmez - sadece bir:

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

Bir dizideki öğeleri şu şekilde değiştirebilirsiniz:

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

Aşağıdaki örneğe bakın:

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

Not: normal değişkenler için aynı şekilde çalışır

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

Sayısal değerlerle, bitsel xveya kullanarak geçici bir değişkeni önleyebilirsiniz.

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

veya bir aritmetik toplamı (bunun yalnızca x + y veri türü için maksimum değerden küçükse işe yaradığını belirtmek)

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

Bu soru sorulduğunda yoktu, ancak ES2015 dizi yıkımını başlattı ve aşağıdaki gibi yazmanıza izin verdi:

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

Dizinin ardışık iki öğesini değiştirmek için

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

Http://www.greywyvern.com/?post=265 adresinden özetleyin

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

Destructuring_assignment hakkında

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

bu da genişletilebilir

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

Üçüncü değişkeni tanımlamaya gerek kalmadan böyle bir çözümü düşünün:

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"]

Not: Örneğin dizi uzunluğu için ek kontroller eklemek isteyebilirsiniz. Bu çözüm değiştirilebilir, böylece swapfonksiyonun yeni bir dizi döndürmesi gerekmez, sadece geçirilen dizi üzerinden mutasyon yapar.

Aşağıdaki gibi basit bir kimlik işlevini kullanarak, farklı türlerde bile, istediğiniz sayıda nesneyi veya değişmezi değiştirebilirsiniz:

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

Sorununuz için:

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

Bu, JavaScript'te çalışır çünkü bildirilmemesine veya kullanılmamasına rağmen ek argümanları kabul eder. Ödevler a=bvb. İşleve geçtikten sonra olur a.

İki veya daha fazla eleman için (sabit sayı)

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

Geçici değişken gerekmez!

Sadece aramayı düşünüyordum list.reverse().
Ama sonra sadece takas olarak çalışacağını fark ettim list.length = x + y + 1.

Değişken eleman sayısı için

Harita ve harita dahil olmak üzere çeşitli modern Javascript yapılarına baktım , ancak ne yazık ki hiçbiri bu eski moda, döngü tabanlı yapıdan daha kompakt veya daha hızlı bir kodla sonuçlandı:

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>

Değiştirmenin ilginç bir yolu var:

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

(ES6 yolu)

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

İşte mutasyona uğramayan tek bir astar list:

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

(Soru gönderildiğinde 2009'da bulunmayan dil özelliklerini kullanır!)

İşte kompakt bir sürüm i1'de i2 ile değeri değiştirir

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

Dizinin dizinde olup olmadığını ilk olarak kontrol eden bir varyasyon şunlardır:

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

Şu anda thisdizin mevcut değilse geri dönecek , ancak başarısız olduğunda davranışı kolayca değiştirebilirsiniz.

Geçici değişken veya ES6 takas yöntemi olmayan bir dizideki ilk ve son öğeyi değiştir [a, b] = [b, a]

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

Var olanı mutasyona uğratmak yerine diziyi klonlayan daktilo çözümü

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

Sadece eğlenmek için, herhangi bir ekstra değişken kullanmadan başka bir yol olacaktır:

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]

Kısacası, yukarıdaki tüm concat ve dilimlemeden biraz daha az çirkin olan çirkin tek katlı versiyon. Kabul edilen cevap gerçekten gitmenin ve okunabilirliğin yoludur.

Verilen:

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

iki endeksin (a ve b) değerlerini değiştirmek isterseniz; o zaman bu yapardı:

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

Örneğin, 3 ve 5'i değiştirmek istiyorsanız, bunu şu şekilde yapabilirsiniz:

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

veya

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

Her ikisi de aynı sonucu verir:

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

#splicehatersarepunks :)

ES5'te temp değişkeni kullanmak istemiyorsanız, dizi öğelerini değiştirmenin bir yoludur.

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 ]

bu işlevi deneyin ...

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

ES6'yı kullanarak böyle yapmak mümkündür ...

Bu 2 diziye sahip olduğunuzu düşünün ...

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

ve ilk değerleri değiştirmek istersiniz:

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

ve değer:

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

Kullanımı:

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

Sadece ilk ve son elemanları takas etmeniz gerekiyorsa:

array.unshift( array.pop() );