Элементы массива подкачки Javascript

Есть ли более простой способ поменять два элемента в массиве?

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

Вам нужна только одна временная переменная.

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

Отредактируйте верхний ответ 10 лет спустя, получив множество ES6 под нашими поясами:

Учитывая массив arr = [1,2,3,4], вы можете поменять значения в одну строку, вот так:

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

Это произведет массив [2,1,3,4]. Это деструктурирующее задание .

Если вам нужно одно выражение с использованием собственного javascript, помните, что возвращаемое значение из операции сращивания содержит элементы, которые были удалены.

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"

Редактировать:

[0]Необходимо в конце выражения , как Array.splice()возвращает массив, и в этой ситуации , мы требуем , чтобы один элемент в возвращаемом массиве.

Это кажется хорошо ....

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

Hoverver с помощью

var b = list[y];

означает, что переменная b будет присутствовать для остальной части области. Это может привести к утечке памяти. Вряд ли, но все же лучше избегать.

Может быть, хорошая идея поместить это в Array.prototype.swap

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

который можно назвать как:

list.swap( x, y )

Это чистый подход, позволяющий избежать утечек памяти и СУХОГО .

По словам случайного человека из Metafilter , «последние версии Javascript позволяют вам делать свопы (между прочим) гораздо более аккуратно:»

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

Мои быстрые тесты показали, что этот код Pythonic отлично работает в версии JavaScript, используемой в настоящее время в «Google Apps Script» («.gs»). Увы, дальнейшие тесты показывают, что этот код выдает «Uncaught ReferenceError: Недопустимая левая часть в назначении». в любой версии JavaScript (".js") используется Google Chrome версии 24.0.1312.57 m.

Ну, вам не нужно буферизовать оба значения - только одно:

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

Вы можете поменять местами элементы в массиве следующим образом:

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

Смотрите следующий пример:

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

Примечание: это работает так же для обычных переменных

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

С числовыми значениями вы можете избежать временной переменной, используя побитовый xor

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

или арифметическая сумма (учитывая, что это работает, только если x + y меньше максимального значения для типа данных)

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

Этого не было, когда задавался вопрос, но ES2015 ввел деструктуризацию массива, что позволило написать его следующим образом:

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

Поменять местами два последовательных элемента массива

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

Дайджест от http://www.greywyvern.com/?post=265

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

как насчет Destructuring_assignment

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

который также может быть расширен до

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

Рассмотрим такое решение без необходимости определять третью переменную:

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

Примечание: вы можете добавить дополнительные проверки, например, для длины массива. Это решение является изменяемым, поэтому swapфункция не должна возвращать новый массив, она просто выполняет мутацию переданного массива.

Вы можете поменять местами любое количество объектов или литералов, даже разных типов, используя простую функцию идентификации, например:

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

Для вашей проблемы:

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

Это работает в JavaScript, потому что он принимает дополнительные аргументы, даже если они не объявлены или не используются. Назначения и a=bт. Д. Происходят после aпередачи в функцию.

Для двух или более элементов (фиксированное число)

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

Временная переменная не требуется!

Я думал просто позвонить list.reverse().
Но потом я понял, что своп будет работать только тогда, когда list.length = x + y + 1.

Для переменного количества элементов

Я рассмотрел различные современные конструкции Javascript на этот счет, включая Map и map , но, к сожалению, ни одна из них не привела к созданию кода, который был бы более компактным или более быстрым, чем эта старомодная конструкция на основе циклов:

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>

Есть один интересный способ обмена:

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

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

Вот одна строка, которая не мутирует list:

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

(Использует языковые функции, недоступные в 2009 году, когда вопрос был опубликован!)

Вот компактная версия меняет значение на i1 с i2 в обр

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

Вот вариант, который сначала проверяет, существует ли индекс в массиве:

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

В настоящее время он просто вернется, thisесли индекс не существует, но вы можете легко изменить поведение при сбое

Поменяйте местами первый и последний элемент в массиве без временной переменной или метода обмена ES6 [a, b] = [b, a]

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

Решение Typescript, которое клонирует массив, а не изменяет существующий

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

Просто для удовольствия, другой способ без использования какой-либо дополнительной переменной будет:

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]

Для краткости, вот уродливая версия с одной линией, которая только немного менее уродлива, чем вся эта конкатата и нарезка выше. Принятый ответ - действительно путь, и более читаемый.

Дано:

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

если вы хотите поменять местами значения двух индексов (a и b); тогда это будет сделано:

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

Например, если вы хотите поменять местами 3 и 5, вы можете сделать это следующим образом:

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

или

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

Оба дают одинаковый результат:

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

#splicehatersarepunks :)

Если вы не хотите использовать временную переменную в ES5, это один из способов замены элементов массива.

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 ]

попробуйте эту функцию ...

$(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 это можно сделать так ...

Представьте, что у вас есть эти 2 массива ...

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

и вы хотите поменять местами первые значения:

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

и значение:

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

Использование:

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

Если нужно поменять местами только первый и последний элементы:

array.unshift( array.pop() );