삭제하는 배열 요소에 자바스크립트 삭제 vs 스플라이스

Question

의 차이점은 무엇입 사용 이 delete 연산자 에 배열 요소와 반대로 사용하는 이 Array.splice 방법?

예를 들어:

myArray = ['a', 'b', 'c', 'd'];

delete myArray[1];
//  or
myArray.splice (1, 1);

유도 결합 방법으면 나는 삭제할 수 있는 배열 요소는 다음과 같이고 가까?

Answer 1

delete 객체 속성을 삭제하지만 배열을 다시 표시하거나 길이를 업데이트하지는 않습니다. 마치 정의되지 않은 것처럼 보입니다.

> myArray = ['a', 'b', 'c', 'd']
  ["a", "b", "c", "d"]
> delete myArray[0]
  true
> myArray[0]
  undefined

실제로 값으로 설정되지 않았습니다. undefined, 오히려 속성이 배열에서 제거되어 나타나다 한정되지 않은. Chrome Dev 도구는 인쇄 하여이 차이점을 명확하게합니다. empty 배열을 기록 할 때.

> myArray[0]
  undefined
> myArray
  [empty, "b", "c", "d"]

myArray.splice(start, deleteCount) 실제로 요소를 제거하고 배열을 다시 표시하고 길이를 변경합니다.

> myArray = ['a', 'b', 'c', 'd']
  ["a", "b", "c", "d"]
> myArray.splice(0, 2)
  ["a", "b"]
> myArray
  ["c", "d"]

Answer 2

Array.remove () 메소드

John Resig, jQuery의 제작자는 매우 편리했습니다 Array.remove 항상 프로젝트에서 사용하는 방법.

// Array Remove - By John Resig (MIT Licensed)
Array.prototype.remove = function(from, to) {
  var rest = this.slice((to || from) + 1 || this.length);
  this.length = from < 0 ? this.length + from : from;
  return this.push.apply(this, rest);
};

그리고 여기에 어떻게 사용될 수 있는지에 대한 몇 가지 예가 있습니다.

// Remove the second item from the array
array.remove(1);
// Remove the second-to-last item from the array
array.remove(-2);
// Remove the second and third items from the array
array.remove(1,2);
// Remove the last and second-to-last items from the array
array.remove(-2,-1);

존의 웹 사이트

Answer 3

삭제는 배열의 요소에서 객체 만 제거하므로 배열의 길이는 변경되지 않습니다. 스플 라이스는 물체를 제거하고 배열을 단축시킵니다.

다음 코드는 "a", "b", "undefined", "d"를 표시합니다.

myArray = ['a', 'b', 'c', 'd']; delete myArray[2];

for (var count = 0; count < myArray.length; count++) {
    alert(myArray[count]);
}

"A", "B", "D"가 표시되는 반면

myArray = ['a', 'b', 'c', 'd']; myArray.splice(2,1);

for (var count = 0; count < myArray.length; count++) {
    alert(myArray[count]);
}

Answer 4

나는 비틀거에 이 질문을 하는 동안 이해를 제거하는 방법을 발생한 모든 요소에서 훌륭한 기능들을 가지고 있습니다. 여기의 비교 의 splice 고 delete 을 위해 제거하마 'c' 서 items 배열입니다.

var items = ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd'];

while (items.indexOf('c') !== -1) {
  items.splice(items.indexOf('c'), 1);
}

console.log(items); // ["a", "b", "d", "a", "b", "d"]

items = ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd'];

while (items.indexOf('c') !== -1) {
  delete items[items.indexOf('c')];
}

console.log(items); // ["a", "b", undefined, "d", "a", "b", undefined, "d"]
​

Answer 5

에서 Core JavaScript 1.5 참조> 운영자> 특수 연산자> 운영자 삭제 :

배열 요소를 삭제하면 배열 길이가 영향을받지 않습니다. 예를 들어, [3]을 삭제하면 [4]는 여전히 [4]이고 [3]은 정의되지 않습니다. 배열의 마지막 요소를 삭제하더라도 ([a.length-1] 삭제).

Answer 6

splice 숫자 지수와 함께 작동합니다.

반면 delete 다른 종류의 지수에 사용할 수 있습니다 ..

예시:

delete myArray['text1'];

Answer 7

스플 라이스는 배열에서만 작동한다는 것을 언급 할 가치가 있습니다. (일관된 순서를 따르기 위해 객체 속성을 의존 할 수 없습니다.)

객체에서 키 값 쌍을 제거하려면 Delete가 실제로 원하는 것입니다.

delete myObj.propName;     // , or:
delete myObj["propName"];  // Equivalent.

Answer 8

위에서 여러 번 언급했듯이 사용 splice() 완벽하게 맞는 것 같습니다. 모질라 문서 :

그만큼 splice() 방법은 기존 요소를 제거하거나 새 요소를 추가하여 배열의 내용을 변경합니다.

var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];

myFish.splice(2, 0, 'drum'); 
// myFish is ["angel", "clown", "drum", "mandarin", "sturgeon"]

myFish.splice(2, 1); 
// myFish is ["angel", "clown", "mandarin", "sturgeon"]

통사론

array.splice(start)
array.splice(start, deleteCount)
array.splice(start, deleteCount, item1, item2, ...)

매개 변수

시작

배열 변경을 시작하는 색인. 배열의 길이보다 크면 실제 시작 인덱스가 배열의 길이로 설정됩니다. 부정적인 경우 끝까지 많은 요소를 시작합니다.

deletecount

제거 할 기존 배열 요소의 수를 나타내는 정수. deleteCount가 0이면 요소가 제거되지 않습니다. 이 경우 적어도 하나의 새 요소를 지정해야합니다. DeleteCount가 시작시 시작될 때 배열에 남은 요소 수보다 큰 경우 배열 끝을 통한 모든 요소가 삭제됩니다.

deleteCount가 생략되면 deleteCount가 동일합니다. (arr.length - start).

item1, item2, ...

시작 인덱스에서 시작하여 배열에 추가 할 요소. 요소를 지정하지 않으면 splice() 배열에서 요소 만 제거합니다.

반환 값

삭제 된 요소를 포함하는 배열. 하나의 요소 만 제거되면 하나의 요소 배열이 반환됩니다. 요소가 제거되지 않으면 빈 배열이 반환됩니다.

[...]

Answer 9

대 스플 라이스를 삭제하십시오

배열에서 항목을 삭제할 때

var arr = [1,2,3,4]; delete arr[2]; //result [1, 2, 3:, 4]
console.log(arr)

당신이 스플 라이스 할 때

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

경우 삭제 그만큼 요소가 삭제됩니다 하지만 색인은 비어 있습니다

경우에 접착 요소가 삭제되고 이에 따라 REST 요소의 색인이 줄어 듭니다

Answer 10

삭제 비 실제 상황처럼 행동하고 단지 제거합니다 항목이지만 배열 길이는 동일하게 유지됩니다.

노드 터미널의 예 :

> var arr = ["a","b","c","d"];
> delete arr[2]
true
> arr
[ 'a', 'b', , 'd', 'e' ]

다음은 인덱스별로 배열의 항목을 제거하는 기능입니다. 일부분(), ARR은 첫 번째 Arg와 두 번째 인수로 삭제하려는 멤버의 색인으로 취합니다. 보시다시피, 실제로 배열의 멤버를 삭제하고 배열 길이를 1 씩 줄입니다.

function(arr,arrIndex){
    return arr.slice(0,arrIndex).concat(arr.slice(arrIndex + 1));
}

위의 기능은 모든 멤버를 색인으로 끌어 올리고 인덱스 후 모든 구성원을 연결하고 함께 연결하고 결과를 반환하는 것입니다.

다음은 위의 기능을 노드 모듈로 사용하는 예입니다. 터미널이 유용합니다.

> var arr = ["a","b","c","d"]
> arr
[ 'a', 'b', 'c', 'd' ]
> arr.length
4 
> var arrayRemoveIndex = require("./lib/array_remove_index");
> var newArray = arrayRemoveIndex(arr,arr.indexOf('c'))
> newArray
[ 'a', 'b', 'd' ] // c ya later
> newArray.length
3

indexof ( "c")가 첫 번째 발생을 얻고 첫 번째 "c"를 분할하고 제거하기 때문에 Dupes와 함께 하나의 배열이 작동하지 않습니다.

Answer 11

큰 배열을 반복하고 선택적으로 요소를 선택적으로 삭제하려면 Splice ()가 매번 후속 요소를 다시 표시해야하기 때문에 모든 삭제에 대해 Splice ()을 호출하는 것이 비싸다. 배열은 JavaScript와 연관되어 있으므로 개별 요소를 삭제 한 다음 나중에 배열을 다시 표시하는 것이 더 효율적입니다.

새 배열을 만들어서 할 수 있습니다. 예를 들어

function reindexArray( array )
{
       var result = [];
        for( var key in array )
                result.push( array[key] );
        return result;
};

그러나 원래 배열에서 키 값을 수정할 수는 없다고 생각합니다. 이는 더 효율적입니다. 새 배열을 만들어야 할 것 같습니다.

실제로 존재하지 않으므로 "정의되지 않은"항목을 확인할 필요가 없으며 FOR 루프가 반환되지 않습니다. 배열 인쇄의 아티팩트로 정의되지 않은 것으로 표시됩니다. 그들은 기억에 존재하지 않는 것 같습니다.

Slice ()와 같은 것을 더 빨리 사용할 수는 있지만 다시 표시되지는 않습니다. 더 나은 방법을 아는 사람이 있습니까?

---

실제로, 당신은 아마도 더 효율적이고 성능 측면에서 다음과 같이 할 수 있습니다.

reindexArray : function( array )
{
    var index = 0;                          // The index where the element should be
    for( var key in array )                 // Iterate the array
    {
        if( parseInt( key ) !== index )     // If the element is out of sequence
        {
            array[index] = array[key];      // Move it to the correct, earlier position in the array
            ++index;                        // Update the index
        }
    }

    array.splice( index );  // Remove any remaining elements (These will be duplicates of earlier items)
},

Answer 12

이와 같은 것을 사용할 수 있습니다

var my_array = [1,2,3,4,5,6];
delete my_array[4];
console.log(my_array.filter(function(a){return typeof a !== 'undefined';})); // [1,2,3,4,6]

Answer 13

왜 필터 만하지 않습니까? JS의 배열을 고려하는 가장 분명한 방법이라고 생각합니다.

myArray = myArray.filter(function(item){
    return item.anProperty != whoShouldBeDeleted
});

Answer 14

function remove_array_value(array, value) {
    var index = array.indexOf(value);
    if (index >= 0) {
        array.splice(index, 1);
        reindex_array(array);
    }
}
function reindex_array(array) {
   var result = [];
    for (var key in array) {
        result.push(array[key]);
    }
    return result;
}

예시:

var example_arr = ['apple', 'banana', 'lemon'];   // length = 3
remove_array_value(example_arr, 'banana');

바나나가 삭제되고 배열 길이 = 2입니다

Answer 15

그것들은 다른 목적을 가진 다른 것들입니다.

splice 배열과 관련이 있으며 삭제에 사용될 때 배열에서 항목을 제거합니다. 그리고 갭을 채우기 위해 이전의 모든 항목을 움직입니다. (또한 항목을 동시에 삽입하는 데 사용될 수도 있습니다.) splice 변경합니다 length 배열의 (No-OP 호출이 아니라고 가정합니다. theArray.splice(x, 0)).

delete 배열 별이 아닙니다. 객체에서 사용하도록 설계되었습니다. 사용하는 객체에서 속성 (키/값 쌍)을 제거합니다. JavaScript의 표준 (예 : 비 유형) 배열이기 때문에 배열에만 적용됩니다. 실제로 배열이 아닙니다*, 그들은 이름이 "배열 인덱스"( 한정된 문자열 이름으로 "... 숫자 값 i 범위에 있습니다 +0 ≤ i < 2^32-1") 그리고 length. 당신이 사용할 때 delete 배열 항목을 제거하려면 항목을 제거하기 만하면됩니다. 간격을 채우기 위해 다른 항목을 움직이지 않으므로 배열이 "스파스"가됩니다 (일부 항목이 완전히 누락됨). 그것은 영향을 미치지 않습니다 length.

이 질문에 대한 현재 답변 몇 개는 delete "입장을 설정합니다 undefined". 그것은 맞지 않습니다. 그것은 제거합니다 항목 (재산)은 전적으로 격차를 남깁니다.

차이점을 설명하기 위해 일부 코드를 사용해 봅시다.

console.log("Using `splice`:");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
a.splice(0, 1);
console.log(a.length);            // 4
console.log(a[0]);                // "b"

console.log("Using `delete`");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
delete a[0];
console.log(a.length);            // still 5
console.log(a[0]);                // undefined
console.log("0" in a);            // false
console.log(a.hasOwnProperty(0)); // false

console.log("Setting to `undefined`");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
a[0] = undefined;
console.log(a.length);            // still 5
console.log(a[0]);                // undefined
console.log("0" in a);            // true
console.log(a.hasOwnProperty(0)); // true

---

* (그것은 내 빈혈 작은 블로그의 게시물입니다)

Answer 16

현재이 작업을 수행하는 두 가지 방법이 있습니다

1. 스플 라이스 사용 ()

   arrayObject.splice(index, 1);

2. 삭제 사용

   delete arrayObject[index];

그러나 삭제가 배열 길이를 업데이트하지 않기 때문에 항상 배열 객체에 스플 라이스를 사용하고 객체 속성에 대해 삭제하는 것이 좋습니다.

Answer 17

차이는 다음 배열의 길이를 기록하여 볼 수 있습니다. delete 운영자 및 splice() 방법이 적용됩니다. 예를 들어:

연산자 삭제

var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
delete trees[3];

console.log(trees); // ["redwood", "bay", "cedar", empty, "maple"]
console.log(trees.length); // 5

그만큼 delete 연산자는 배열에서 요소를 제거하지만 요소의 "자리 표시 자"는 여전히 존재합니다. oak 제거되었지만 여전히 어레이에서 공간을 차지합니다. 이 때문에 배열의 길이는 5로 남아 있습니다.

스플 라이스 () 방법

var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
trees.splice(3,1);

console.log(trees); // ["redwood", "bay", "cedar", "maple"]
console.log(trees.length); // 4

그만큼 splice() 메소드는 대상 값을 완전히 제거합니다 그리고 "자리 표시 자"도 마찬가지입니다. oak 배열에서 점유하는 데 사용 된 공간뿐만 아니라 제거되었습니다. 배열의 길이는 이제 4입니다.

Answer 18

좋아, 아래 에이 배열이 있다고 상상해보십시오.

const arr = [1, 2, 3, 4, 5];

먼저 삭제합시다 :

delete arr[1];

그리고 이것이 결과입니다.

[1, empty, 3, 4, 5];

비어 있는! 그리고 그것을 얻자 :

arr[1]; //undefined

따라서 삭제 된 가치만을 의미합니다 한정되지 않은 이제 길이는 동일합니다. 진실...

이번에는 배열을 재설정하고 스플 라이스로 수행합시다.

arr.splice(1, 1);

그리고 이것은 이번에 결과입니다.

[1, 3, 4, 5];

보시다시피 배열 길이가 변경되었습니다 arr[1] ~이다 3 지금...

또한 삭제 된 항목을 배열에서 반환합니다. [3] 이 경우 ...

Answer 19

가장 쉬운 방법은 아마도입니다

var myArray = ['a', 'b', 'c', 'd'];
delete myArray[1]; // ['a', undefined, 'c', 'd']. Then use lodash compact method to remove false, null, 0, "", undefined and NaN
myArray = _.compact(myArray); ['a', 'c', 'd'];

도움이 되었기를 바랍니다. 참조: https://lodash.com/docs#compact

Answer 20

사용하고 싶은 사람들을 위해 Lodash 사용할 수 있습니다 :myArray = _.without(myArray, itemToRemove)

또는 내가 Angular2에서 사용하는대로

import { without } from 'lodash';
...
myArray = without(myArray, itemToRemove);
...

Answer 21

삭제: 삭제는 객체 속성을 삭제하지만 배열을 다시 표시하거나 길이를 업데이트하지는 않습니다. 마치 정의되지 않은 것처럼 보입니다.

접착: 실제로 요소를 제거하고 배열을 다시 표시하고 길이를 변경합니다.

마지막으로 요소를 삭제하십시오

arrName.pop();

먼저 요소를 삭제합니다

arrName.shift();

중간에서 삭제하십시오

arrName.splice(starting index,number of element you wnt to delete);

Ex: arrName.splice(1,1);

마지막으로 하나의 요소를 삭제하십시오

arrName.splice(-1);

배열 인덱스 번호를 사용하여 삭제합니다

 delete arrName[1];

Answer 22

삭제하려는 원하는 요소가 중간에있는 경우 (인덱스 인 'C'를 삭제하려는 경우) : 사용할 수 있습니다.

var arr = ['a','b','c'];
var indexToDelete = 1;
var newArray = arr.slice(0,indexToDelete).combine(arr.slice(indexToDelete+1, arr.length))

Answer 23

IndexOf 참조 유형도 허용합니다. 다음 시나리오를 가정하십시오.

var arr = [{item: 1}, {item: 2}, {item: 3}];
var found = find(2, 3); //pseudo code: will return [{item: 2}, {item:3}]
var l = found.length;

while(l--) {
   var index = arr.indexOf(found[l])
      arr.splice(index, 1);
   }
   
console.log(arr.length); //1

다르게:

var item2 = findUnique(2); //will return {item: 2}
var l = arr.length;
var found = false;
  while(!found && l--) {
  found = arr[l] === item2;
}

console.log(l, arr[l]);// l is index, arr[l] is the item you look for

Answer 24

function deleteFromArray(array, indexToDelete){
  var remain = new Array();
  for(var i in array){
    if(array[i] == indexToDelete){
      continue;
    }
    remain.push(array[i]);
  }
  return remain;
}

myArray = ['a', 'b', 'c', 'd'];
deleteFromArray(myArray , 0);

// 결과 : myArray = [ 'b', 'c', 'd'];