Phần tử mảng trao đổi Javascript

Có cách nào đơn giản hơn để trao đổi hai phần tử trong một mảng không?

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

Bạn chỉ cần một biến tạm thời.

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

Chỉnh sửa câu trả lời hàng đầu 10 năm sau với rất nhiều việc áp dụng ES6 trong vành đai của chúng tôi:

Đưa ra mảng arr = [1,2,3,4], bạn có thể trao đổi giá trị trong một dòng ngay bây giờ như sau:

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

Điều này sẽ tạo ra các mảng [2,1,3,4]. Đây là nhiệm vụ hủy hoại .

Nếu bạn muốn một biểu thức, sử dụng javascript gốc, hãy nhớ rằng giá trị trả về từ thao tác ghép có chứa (các) phần tử đã bị xóa.

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"

Biên tập:

Điều [0]cần thiết ở cuối biểu thức là Array.splice()trả về một mảng và trong tình huống này, chúng tôi yêu cầu phần tử đơn trong mảng được trả về.

Điều này có vẻ ổn ....

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

Howerver sử dụng

var b = list[y];

có nghĩa là một biến b sẽ xuất hiện trong phần còn lại của phạm vi. Điều này có khả năng có thể dẫn đến rò rỉ bộ nhớ. Không thể, nhưng vẫn tốt hơn để tránh.

Có lẽ một ý tưởng tốt để đưa điều này vào Array.prototype.swap

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

có thể được gọi là như:

list.swap( x, y )

Đây là một cách tiếp cận rõ ràng để tránh rò rỉ bộ nhớ và DRY .

Theo một số người ngẫu nhiên trên Metafilter , "Các phiên bản gần đây của Javascript cho phép bạn thực hiện các giao dịch hoán đổi (trong số những thứ khác) gọn gàng hơn nhiều:"

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

Các thử nghiệm nhanh của tôi cho thấy mã Pythonic này hoạt động rất tốt trong phiên bản JavaScript hiện đang được sử dụng trong "Tập lệnh Google Apps" (".ss"). Than ôi, các thử nghiệm tiếp theo cho thấy mã này đưa ra một "Uncaught ReferenceError: bên trái không hợp lệ trong bài tập." trong bất kỳ phiên bản JavaScript nào (".js") được Google Chrome sử dụng Phiên bản 24.0.1312.57 m.

Chà, bạn không cần phải đệm cả hai giá trị - chỉ một:

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

Bạn có thể trao đổi các phần tử trong một mảng theo cách sau:

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

Xem ví dụ sau:

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

Lưu ý: nó hoạt động theo cùng một cách cho các biến thông thường

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

Với các giá trị số, bạn có thể tránh một biến tạm thời bằng cách sử dụng bitwise xor

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

hoặc tổng số học (lưu ý rằng điều này chỉ hoạt động nếu x + y nhỏ hơn giá trị tối đa cho loại dữ liệu)

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

Điều này không tồn tại khi câu hỏi được hỏi, nhưng ES2015 đã giới thiệu tính năng phá hủy mảng, cho phép bạn viết nó như sau:

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

Để hoán đổi hai phần tử liên tiếp của mảng

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

Thông báo từ http://www.greywyvern.com/?post=265

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

Điều gì về Desturationuring_assocation

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

cũng có thể được mở rộng đến

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

Xem xét một giải pháp như vậy mà không cần xác định biến thứ ba:

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

Lưu ý: Bạn có thể muốn thêm các kiểm tra bổ sung, ví dụ về độ dài mảng. Giải pháp này có thể thay đổi được nên swaphàm không cần trả về một mảng mới, nó chỉ thực hiện đột biến trên mảng được truyền vào.

Bạn có thể trao đổi bất kỳ số lượng đối tượng hoặc nghĩa đen, thậm chí các loại khác nhau, bằng cách sử dụng một chức năng nhận dạng đơn giản như thế này:

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

Đối với vấn đề của bạn:

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

Điều này hoạt động trong JavaScript vì nó chấp nhận các đối số bổ sung ngay cả khi chúng không được khai báo hoặc sử dụng. Các bài tập a=b, vv, xảy ra sau khi ađược truyền vào hàm.

Đối với hai hoặc nhiều yếu tố (số cố định)

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

Không yêu cầu biến tạm thời!

Tôi đã suy nghĩ về việc đơn giản gọi list.reverse().
Nhưng sau đó tôi nhận ra nó chỉ hoạt động như trao đổi khilist.length = x + y + 1 .

Đối với số lượng phần tử thay đổi

Tôi đã xem xét các cấu trúc Javascript hiện đại khác nhau cho hiệu ứng này, bao gồm Bản đồ và bản đồ , nhưng thật đáng buồn là không có kết quả nào trong mã nhỏ gọn hơn hoặc nhanh hơn so với cách xây dựng dựa trên vòng lặp, lỗi thời này:

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>

Có một cách hoán đổi thú vị:

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

(Cách 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];

Đây là một lớp lót không đột biến list:

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

(Sử dụng các tính năng ngôn ngữ không có sẵn trong năm 2009 khi câu hỏi được đăng!)

Đây là một phiên bản nhỏ gọn hoán đổi giá trị tại i1 với i2 trong mảng

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

Đây là một biến thể đầu tiên kiểm tra nếu chỉ mục tồn tại trong mảng:

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

Hiện tại nó sẽ chỉ trả về thisnếu chỉ mục không tồn tại, nhưng bạn có thể dễ dàng sửa đổi hành vi khi không thành công

Hoán đổi phần tử đầu tiên và cuối cùng trong một mảng mà không có biến tạm thời hoặc phương thức hoán đổi ES6 [a, b] = [b, a]

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

Giải pháp bản in sao chép mảng thay vì làm biến đổi cái hiện có

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

Chỉ để giải trí, một cách khác mà không sử dụng bất kỳ biến phụ nào sẽ là:

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]

Vì lợi ích của sự ngắn gọn, đây là phiên bản một lớp lót xấu xí chỉ hơi xấu xí hơn tất cả những gì được ghép và cắt ở trên. Câu trả lời được chấp nhận thực sự là cách để đi và cách dễ đọc hơn.

Được:

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

nếu bạn muốn trao đổi các giá trị của hai chỉ số (a và b); sau đó điều này sẽ làm điều đó:

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

Ví dụ: nếu bạn muốn trao đổi 3 và 5, bạn có thể thực hiện theo cách này:

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

hoặc là

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

Cả hai đều cho kết quả như nhau:

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

#splicehatersarepunks :)

Nếu bạn không muốn sử dụng biến temp trong ES5, đây là một cách để trao đổi các phần tử mảng.

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 ]

thử chức năng này ...

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

Sử dụng ES6 có thể làm điều đó như thế này ...

Hãy tưởng tượng bạn có 2 mảng này ...

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

và bạn muốn trao đổi các giá trị đầu tiên:

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

và giá trị:

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

Sử dụng:

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

Nếu cần hoán đổi các yếu tố đầu tiên và cuối cùng:

array.unshift( array.pop() );