Javascript 스왑 어레이 요소

Javascript 스왑 어레이 요소

어레이 내의 2개의 요소를 간단하게 교환할 수 있는 방법이 있습니까?

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()어레이를 반환합니다.이 상황에서는 반환된 어레이에 단일 요소가 필요합니다.

Metafilter의 한 무작위 인사에 따르면, "최근 버전의 Javascript를 사용하면 더 깔끔하게 스와프를 할 수 있습니다."

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

빠른 테스트 결과, 이 피토닉 코드는 현재 "Google Apps Script"(.gs)에서 사용되는 JavaScript 버전에서 매우 잘 작동하는 것으로 나타났습니다.아아, 추가 테스트 결과 이 코드는 "Uncatched ReferenceError:잘못된 왼쪽 할당"은 Google Chrome 버전 24.0.1312.57m에서 사용되는 JavaScript 버전(.js")에 관계없이 사용됩니다.

이거 괜찮은 것 같은데...

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

서버 사용 방법

var b = list[y];

b 변수가 스코프의 나머지 부분에 존재하는 것을 의미합니다.이로 인해 메모리 누수가 발생할 수 있습니다.그럴 것 같진 않지만 피하는 게 더 낫지

이것을 Array.protype.swap에 넣는 것이 좋습니다.

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

이것은 다음과 같이 불릴 수식별:

list.swap( x, y )

이는 메모리 누수와 드라이를 모두 방지하기 위한 깨끗한 방법입니다.

두 값을 모두 버퍼링할 필요는 없습니다.단 한 가지 값:

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]

이는 질문 당시에는 존재하지 않았지만 ES2015에서는 어레이 파괴 기능을 도입하여 다음과 같이 작성할 수 있습니다.

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

세 번째 변수를 정의할 필요 없이 이러한 솔루션을 고려하십시오.

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함수는 새 배열을 반환할 필요가 없으며 전달된 배열에 대한 변환만 수행합니다.

배열의 연속된 두 요소를 스왑하려면

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

숫자 값을 사용하면 비트 단위 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];

두 개 이상의 요소(고정수)의 경우

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

임시 변수가 필요하지 않습니다!

list.reverse().
그 후 나는 한다는 것을 .list.length = x + y + 1.

요소의 수가 가변적인 경우

Map과 Map을 포함한 다양한 최신 Javascript 구조를 조사했지만 안타깝게도 이 구식 루프 기반 구조보다 더 콤팩트하거나 더 빠른 코드는 없었다.

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>

Destructuring_assignment는 어떻습니까?

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

또한 확장될 수도 있습니다.

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

http://www.greywyvern.com/?post=265에서 요약

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

다음과 같은 간단한 ID 함수를 사용하여 서로 다른 유형의 개체 또는 리터럴을 원하는 수만큼 스왑할 수 있습니다.

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

자바스크립트이는 선언되거나 사용되지 않는 추가 인수를 받아들이기 때문입니다. ★★a=b etc, 발, 그, 그, 생, 생, after, after, after, after 뒤에 발생하다a함수에 전달됩니다.

스와프에는, 다음의 1개의 흥미로운 방법이 있습니다.

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

(ES6 방식)

.list:

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

(질문이 투고된 2009년에는 이용할 수 없었던 언어 기능을 사용합니다.

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

var arr = [1, 2];
arr.splice(0, 2, arr[1], arr[0]);
console.log(arr); //[2, 1]

다음은 i1의 값을 i2와 arr로 스왑하는 컴팩트 버전입니다.

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

흐름

인스톨 솔루션 없음

let swap= (arr,i,j)=> arr.map((e,k)=> k-i ? (k-j ? e : arr[i]) : arr[j]);

let swap= (arr,i,j)=> arr.map((e,k)=> k-i ? (k-j ? e : arr[i]) : arr[j]);


// test index: 3<->5 (= 'f'<->'d')
let a= ["a","b","c","d","e","f","g"];
let b= swap(a,3,5);

console.log(a,"\n", b);
console.log('Example Flow:', swap(a,3,5).reverse().join('-') );

및 인플레이스

let swap= (arr,i,j)=> {let t=arr[i]; arr[i]=arr[j]; arr[j]=t; return arr}


// test index: 3<->5 (= 'f'<->'d')
let a= ["a","b","c","d","e","f","g"];

console.log( swap(a,3,5) )
console.log('Example Flow:', swap(a,3,5).reverse().join('-') );

이 솔루션에서는 다음과 같은 "흐름 패턴"을 사용합니다.swap는 결과적으로 에 의해, 닷을 해 간단하게 할 수 .이것에 의해, 닷을 사용해 간단하게 처리를 계속할 수 있습니다.. 것)reverse ★★★★★★★★★★★★★★★★★」join★★★★★★★★★★★★★★★★★★)

다음은 배열에 인덱스가 존재하는지 여부를 먼저 확인하는 변형입니다.

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 시 할 수

ES5에서 temp 변수를 사용하지 않는 경우 어레이 요소를 스왑하는 방법 중 하나입니다.

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 ]

기존 어레이를 변환하지 않고 어레이를 복제하는 타이프 스크립트 솔루션

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

어떤 이유로 인플레이스 스왑을 사용할 수 없는 경우 맵이 포함된 솔루션을 다음에 제시합니다.

function swapElements(array, source, dest) {
  return source === dest
? array : array.map((item, index) => index === source
  ? array[dest] : index === dest 
  ? array[source] : item);
}

const arr = ['a', 'b', 'c'];
const s1 = swapElements(arr, 0, 1);
console.log(s1[0] === 'b');
console.log(s1[1] === 'a');

const s2 = swapElements(arr, 2, 0);
console.log(s2[0] === 'c');
console.log(s2[2] === 'a');

다음은 빠른 복사 붙여넣기를 위한 타이프스크립트 코드입니다.

function swapElements(array: Array<any>, source: number, dest: number) {
  return source === dest
    ? array : array.map((item, index) => index === source
      ? array[dest] : index === dest 
      ? array[source] : item);
}

간결하게 하기 위해 위의 모든 콘센트나 슬라이스보다 약간 덜 못생긴 원라이너 버전을 소개합니다.받아들여지는 대답은 진정 바람직한 방법이고 훨씬 더 읽기 쉬운 방법입니다.

지정:

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 ]

#스플라이셰이터sarepunks:)

임시 변수 또는 ES6 스왑 방법 [a, b] = [b, a] 없이 배열의 첫 번째 요소와 마지막 요소를 스왑합니다.

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

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

function moveElement(array, sourceIndex, destinationIndex) {
    return array.map(a => a.id === sourceIndex ? array.find(a => a.id === destinationIndex): a.id === destinationIndex ? array.find(a => a.id === sourceIndex) : a )
}
let arr = [
{id: "1",title: "abc1"},
{id: "2",title: "abc2"},
{id: "3",title: "abc3"},
{id: "4",title: "abc4"}];

moveElement(arr, "2","4");

인플레이스 스왑

// array methods
function swapInArray(arr, i1, i2){
    let t = arr[i1];
    arr[i1] = arr[i2];
    arr[i2] = t;
}

function moveBefore(arr, el){
    let ind = arr.indexOf(el);
    if(ind !== -1 && ind !== 0){
        swapInArray(arr, ind, ind - 1);
    }
}

function moveAfter(arr, el){
    let ind = arr.indexOf(el);
    if(ind !== -1 && ind !== arr.length - 1){
        swapInArray(arr, ind + 1, ind);
    }
}

// dom methods
function swapInDom(parentNode, i1, i2){
    parentNode.insertBefore(parentNode.children[i1], parentNode.children[i2]);
}

function getDomIndex(el){
    for (let ii = 0; ii < el.parentNode.children.length; ii++){
        if(el.parentNode.children[ii] === el){
            return ii;
        }
    }
}

function moveForward(el){
    let ind = getDomIndex(el);
    if(ind !== -1 && ind !== 0){
        swapInDom(el.parentNode, ind, ind - 1);
    }
}

function moveBackward(el){
    let ind = getDomIndex(el);
    if(ind !== -1 && ind !== el.parentNode.children.length - 1){
        swapInDom(el.parentNode, ind + 1, ind);
    }
}

재미삼아 추가 변수를 사용하지 않는 또 다른 방법은 다음과 같습니다.

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]

언급URL : https://stackoverflow.com/questions/872310/javascript-swap-array-elements