javascript - 자바스크립트 - 제이 쿼리 배열 빼기




JavaScript 객체에서 속성을 제거하려면 어떻게해야합니까? (20)

다음과 같이 객체를 생성한다고합시다.

var myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI",
    "regex": "^http://.*"
};

다음과 같이 새로운 myObject 로 끝나는 속성 regex 을 제거하는 가장 좋은 방법은 무엇입니까?

var myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI"
};

2 (ES6)

그것을 필요로하는 사람에게 ...

이 스레드에서 @Koen 응답을 완료하려면 확산 구문을 사용하여 동적 변수를 제거하려는 경우 다음과 같이 할 수 있습니다.

const key = 'a';

const { [key]: foo, ...rest } = { a: 1, b: 2, c: 3 };

console.log(rest); // { b: 2, c: 3 }

* foo는 값 a이 1 인 새로운 변수가 됩니다.


업데이트 :
개체에서 속성을 제거하는 몇 가지 일반적인 방법이 있습니다.
각자는 장단점이 있습니다 ( 이 성능 비교를 확인하십시오 ) :

developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
읽기 쉽고 짧지 만 성능이 최적화되지 않은 많은 수의 객체에서 작업하는 경우에는 최선의 선택이 아닐 수도 있습니다.

delete obj[key];


Reassignment
2 배 이상의 속도보다 빠르지 만delete속성은삭제되지 않고반복 될 수 있습니다.

obj[key] = null;
obj[key] = false;
obj[key] = undefined;


운영자 확산
ES6기존 개체를 돌연변이 않고, 운전자가 우리가 어떤 속성을 제외하고, 새로운 객체를 반환 할 수 있습니다. 단점은 위의 성능이 떨어지고 한 번에 여러 속성을 제거해야 할 때 사용하지 않는 것이 좋습니다.

{ [key]: val, ...rest } = obj;

JavaScript에서 속성 제거

대부분의 옵션이 잘못되었거나 답변이 중복되어 있기 때문에가 아닌 여러 가지 옵션이이 페이지에 나와 있습니다. 적절한 기술은 현재 상황이나 당신이나 당신의 목표에 달려 있기 때문입니다. 팀이 성취하려고 노력하고있다. 질문에 대한 답을 명확히하기 위해 알아야 할 사항은 다음과 같습니다.

  1. 타겟팅하는 ECMAScript 버전
  2. 속성을 제거하려는 객체 유형의 범위와 생략 할 수 있어야하는 속성 이름의 유형 (문자열 만? 기호? 임의의 객체에서 매핑 된 약한 참조? 이들은 모두 JavaScript에서 몇 년 동안 속성 포인터 유형이었습니다 )
  3. 귀하와 귀하의 팀이 사용하는 프로그래밍 정신 / 패턴. 당신은 기능적 접근법을 선호하고 당신의 팀에서 돌연변이가 일어나거나 야생형 돌연변이 객체 지향 기술을 사용합니까?
  4. 순수한 자바 스크립트에서 이것을 달성하고 싶습니까? 아니면 타사 라이브러리를 사용할 의향이 있습니까?

이 네 개의 쿼리가 응답되면, 목표를 달성하기 위해 JavaScript에서 "속성 제거"의 네 가지 카테고리가 기본적으로 선택됩니다. 그들은:

변이 형 개체 속성 삭제, 안전하지 않음

이 범주는 원래 참조를 유지 / 계속 사용하고 코드에서 상태 비 저장 기능 원리를 사용하지 않을 때 객체 리터럴 또는 객체 인스턴스에서 작동하기위한 범주입니다. 이 카테고리의 구문 예는 다음과 같습니다.

'use strict'
const iLikeMutatingStuffDontI = { myNameIs: 'KIDDDDD!', [Symbol.for('amICool')]: true }
delete iLikeMutatingStuffDontI[Symbol.for('amICool')] // true
Object.defineProperty({ myNameIs: 'KIDDDDD!', 'amICool', { value: true, configurable: false })
delete iLikeMutatingStuffDontI['amICool'] // throws

이 카테고리는 가장 오래되고 가장 간단하며 가장 널리 지원되는 부동산 제거 카테고리입니다. Symbol첫 번째 버전을 제외한 모든 버전의 JavaScript에서 작동하며 문자열 외에도 인덱스를 지원합니다 . 그러나 일부 프로그래밍 원칙을 위반하고 성능에 영향을 미치는 것은 돌연변이입니다. developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… 사용될 때 캐치되지 않는 예외가 발생할 수도 있습니다 .

나머지 기반 문자열 속성 누락

이 카테고리는 비 변형 접근법이 필요하고 기호 키를 고려할 필요가 없을 때 새로운 ECMAScript 형식의 일반 객체 또는 배열 인스턴스에서 작동하기위한 것입니다.

const foo = { name: 'KIDDDDD!', [Symbol.for('isCool')]: true }
const { name, ...coolio } = foo // coolio doesn't have "name"
const { isCool, ...coolio2 } = foo // coolio2 has everything from `foo` because `isCool` doesn't account for Symbols :(

변경 객체 속성 삭제, 안전

이 범주는 구성 할 수없는 속성에서 throw되는 예외를 방지하면서 원래 참조를 유지 / 계속 사용하려는 경우 개체 리터럴 또는 개체 인스턴스에서 작동합니다.

'use strict'
const iLikeMutatingStuffDontI = { myNameIs: 'KIDDDDD!', [Symbol.for('amICool')]: true }
Reflect.deleteProperty(iLikeMutatingStuffDontI, Symbol.for('amICool')) // true
Object.defineProperty({ myNameIs: 'KIDDDDD!', 'amICool', { value: true, configurable: false })
Reflect.deleteProperty(iLikeMutatingStuffDontI, 'amICool') // false

또한 개체를 제자리에서 돌연변이시키는 것은 stateless가 아니지만 함수의 성격을 사용하여 명령문에서 Reflect.deleteProperty불가능한 부분 적용 및 기타 기능적 기술을 수행 할 수 있습니다 delete.

구문 기반 문자열 속성 누락

이 카테고리는 비 변형 접근법이 필요하고 기호 키를 고려할 필요가 없을 때 새로운 ECMAScript 형식의 일반 객체 또는 배열 인스턴스에서 작동하기위한 것입니다.

const foo = { name: 'KIDDDDD!', [Symbol.for('isCool')]: true }
const { name, ...coolio } = foo // coolio doesn't have "name"
const { isCool, ...coolio2 } = foo // coolio2 has everything from `foo` because `isCool` doesn't account for Symbols :(

라이브러리 기반 속성 생략

이 카테고리는 일반적으로 Symbol에 대한 회계 및 하나의 명세서에서 둘 이상의 속성을 생략하는 것을 포함하여 더 큰 기능적 유연성을 허용합니다.

const o = require("lodash.omit")
const foo = { [Symbol.for('a')]: 'abc', b: 'b', c: 'c' }
const bar = o(foo, 'a') // "'a' undefined"
const baz = o(foo, [ Symbol.for('a'), 'b' ]) // Symbol supported, more than one prop at a time, "Symbol.for('a') undefined"

운영자 delete 가 예기치 않게 느립니다!

benchmark 보세요.

삭제는 객체의 속성을 남은 부분없이 제거하는 유일한 방법이지만 "대체" object[key] = undefined 비해 ~ 100 배 느리게 작동 object[key] = undefined 설정 object[key] = undefined .

이 대안은이 질문에 정답이 아닙니다! 그러나주의해서 사용하면 일부 알고리즘의 속도를 크게 높일 수 있습니다. delete in 루프를 사용하고 있고 성능에 문제가 있다면 자세한 설명을 읽으십시오.

하나는 delete 사용해야하고 undefined 값으로 설정해야하는 경우는 언제입니까?

객체는 키 - 값 쌍의 집합으로 볼 수 있습니다. 내가 '가치'라고 부르는 것은 '키'에 연결된 다른 객체에 대한 프리미티브 또는 참조입니다.

결과 객체를 제어 할 수없는 코드에 전달할 때 (또는 팀 또는 자신에 대해 확실하지 않은 경우) delete 사용하십시오 .

해시 맵에서 키를 삭제합니다 .

 var obj = {
     field: 1     
 };
 delete obj.field;

퍼포먼스에 신경 undefined , undefined 대한 설정을 사용하십시오 . 그것은 당신의 코드를 심각하게 향상시킬 수 있습니다.

키는 해시 맵의 해당 위치에 그대로 있으며 값만 undefined 로 바뀝니다. 이 for..in 루프는 여전히 해당 키를 반복합니다.

 var obj = {
     field: 1     
 };
 obj.field = undefined;

이 방법을 사용하면 속성 존재를 결정하는 모든 방법이 예상대로 작동하지는 않습니다.

그러나이 코드는 다음과 같습니다.

object.field === undefined

두 가지 방법 모두에서 동등하게 작동합니다.

테스트

요약하면, 차이점은 모두 재산의 존재를 결정하는 방법과 약 for..in 루프에 관한 것입니다.

 console.log('* -> "Takes prototype inheritance into consideration, that means it lookups all over prototype chain too."');

 console.log(obj.field === undefined, 'obj.field === undefined', 'You get "undefined" value when querying for "field" in object-hashmap. *');

 console.log(obj["field"] === undefined, 'obj["field"] === undefined', 'Just another way to query (equivalent). *');

 console.log(typeof obj.field === "undefined", 'typeof obj.field === "undefined"', 'Get the value attached to "field" key, and check it\'s type is "undefined". *');

 console.log("field" in obj, '"field" in obj', 'This statement returns true if "field" key exists in the hashmap. False otherwise. *');

 console.log(obj.hasOwnProperty("field"), 'obj.hasOwnProperty("field")', 'This statement returns true if \'field\' key exists in the hashmap. The ONLY way NOT to lookup for property in the prototype chain!');
 //Object.keys().indexOf() is an overkill that runs much slower :)

 var counter = 0,
     key;
 for (key in obj) {
     counter++;
 }
 console.assert(counter === 0, 'counter === 0', '"field" is not iterated using "for .. in" loop. *');

기억 누출에주의하십시오!

obj[prop] = undefined 것이 delete obj[prop] 하는 것보다 빠르지 만, 또 다른 중요한 고려 사항은 obj[prop] = undefined 가 항상 적절하지 않을 수 있다는 것입니다. delete obj[prop]obj 에서 prop 를 제거하고 메모리에서 지우는 반면 obj[prop] = undefinedprop 의 값을 obj[prop] = undefined 로 설정하고 prop 를 메모리에 남겨 둡니다. 따라서 많은 키가 생성되고 삭제되는 상황에서 obj[prop] = undefined 하면 값 비싼 메모리 조정 (페이지가 멈추는 원인이 될 수 있음)과 잠재적으로 메모리 부족 오류가 발생할 수 있습니다. 다음 코드를 검사하십시오.

"use strict";
var theNodeList=[], i, current, numberOfNodes=65536, body=document.body, nodeRecords=[];
for (i = 0; i !== numberOfNodes; i++) {
    nodeRecords[i] = [];
    current = theNodeList[i] = document.createElement("div");
    current.textContent = i;
    document.body.appendChild( current );
}
var lastTime = -1;
requestAnimationFrame(function recordUpdates(){
    var currentTime = Math.round( performance.now()*1000 )
    for (i = 0; i !== numberOfNodes; i++) {
        if (lastTime !== -1) {
            // the previously collected data is no longer in use
            /*************************************************/
            /****/ nodeRecords[i][lastTime] = undefined; /****/
            /*************************************************/
        }
        nodeRecords[i][currentTime] = theNodeList[i].outerHTML;
    }
    lastTime = currentTime;
    requestAnimationFrame( recordUpdates );
});

위의 코드에서 간단히 nodeRecords[i][lastTime] = undefined; 각 애니메이션 프레임 때문에 막대한 메모리 누수가 발생합니다. 각 프레임, 모든 65536 DOM 요소는 65536 개의 개별 슬롯을 차지하지만 이전 65536 슬롯은 메모리에 매달려있는 undefined로만 설정됩니다. 먼저 콘솔에서 위의 코드를 실행하고 직접 확인해보십시오. 메모리 부족 오류가 발생한 후에는 delete 연산자를 대신 사용하는 다음 버전의 코드를 제외하고 다시 실행하십시오.

"use strict";
var theNodeList=[], i, current, numberOfNodes=65536, body=document.body, nodeRecords=[];
for (i = 0; i !== numberOfNodes; i++) {
    nodeRecords[i] = [];
    current = theNodeList[i] = document.createElement("div");
    current.textContent = i;
    document.body.appendChild( current );
}
var lastTime = -1;
requestAnimationFrame(function recordUpdates(){
    var currentTime = Math.round( performance.now()*1000 )
    for (i = 0; i !== numberOfNodes; i++) {
        if (lastTime !== -1) {
            // the previously collected data is no longer in use
            /********************************************/
            /****/ delete nodeRecords[i][lastTime]; /****/
            /********************************************/
        }
        nodeRecords[i][currentTime] = theNodeList[i].outerHTML;
    }
    lastTime = currentTime;
    requestAnimationFrame( recordUpdates );
});

위의 코드 스 니펫에서 볼 수 있듯이 delete 연산자에는 드문 적절한 사용 사례가 있습니다. 그러나이 문제에 대해 너무 걱정하지 마십시오. 이것은 새로운 키가 끊임없이 추가되는 긴 수명의 오브젝트에만 문제가됩니다. 다른 모든 경우 (실제 프로그래밍의 거의 모든 경우)에는 obj[prop] = undefined 를 사용하는 것이 가장 적절합니다. 이 섹션의 주된 목적은 코드를 코드에 해독하는 시간을 낭비 할 필요가 없도록 코드에서 문제가되는 드문 기회에 문제를보다 쉽게 ​​이해할 수 있도록주의를 기울이는 것입니다. 이 문제를 이해하십시오.

항상 undefined 않음으로 설정 undefined

자바 스크립트의 한 가지 측면은 다형성입니다. 다형성 (Polymorphism)은 아래에서 볼 수있는 것과 같이 동일한 변수 / 슬롯 내 개체 유형을 할당 할 때입니다.

var foo = "str";
foo = 100;          // variable foo is now labeled polymorphic by the browser
var bar = ["Some", "example"];
bar[2] = "text";    // bar is a monomorphic array here because all its entries have the
                    // same type: string primitive
bar[1] = undefined; // bar is now a polymorphic array

그러나 다형성 배열에는 두 가지 주요 고정 할 수없는 문제가 있습니다.

  1. 그들은 느리고 메모리 비효율적입니다. 특정 인덱스에 액세스 할 때 배열의 전역 유형을 가져 오는 대신 브라우저는 각 인덱스가 해당 유형의 추가 메타 데이터를 저장하는 인덱스 단위로 유형을 가져와야합니다.
  2. 다형성, 항상 다형성. 배열을 다형성으로 만들면 Webkit 브라우저에서 다형성을 취소 할 수 없습니다. 따라서 다형성 배열을 비 다형성으로 복원하더라도 브라우저에서 다형성 배열로 저장됩니다.

다형성을 마약 중독에 비유 할 수 있습니다. 언뜻보기에, 그것은 굉장히 수익성이있는 것처럼 보입니다. 멋지고 예쁜 코드. 그런 다음 코더는 다형성 약물에 배열을 도입합니다. 즉각적으로 다형성 배열의 효율성이 떨어지며 마약 복용 이래로 이전처럼 효율적으로 사용할 수 없습니다. 이러한 상황을 실제 상황과 관련 지으려면 코카인을 사용하는 사람이 간단한 문 손잡이를 조작 할 능력이 없어도 PI의 자릿수를 계산할 수 없을 수도 있습니다. 마찬가지로 다형성 약물에 대한 배열은 단일 형 배열만큼 효율적일 수 없습니다.

그러나 마약 여행 비유는 delete 작업과 어떤 관련이 있습니까? 그 답은 위의 스 니펫에서 마지막 코드 행을 나타냅니다. 따라서 재검토하자. 이번은 뒤틀려있다.

var bar = ["Some", "example"];
bar[2] = "text";    // bar is not a polymorphic array here because all its entries have the
                    // same type: string primitive
bar[1] = "";        // bar is still a monomorphic array
bar[1] = undefined; // bar is now a polymorphic array

준수하십시오. bar[1] = "" 는 다형성을 강요하지 않지만 bar[1] = undefined 는 다형성을 강요하지 않습니다. 따라서 실수로 다형성을 일으키지 않도록 가능한 한 항상 객체에 해당하는 유형을 사용해야합니다. 그러한 사람은 일반적으로 다음 목록을 참고할 수 있습니다. 그러나 명시 적으로 아래의 아이디어를 사용하지 마십시오. 대신 코드에서 잘 작동하는 것을 사용하십시오.

  • 부울 프리미티브에 형식화 된 배열 / 변수를 사용하는 경우 빈 값으로 false 또는 undefined 를 사용합니다. 불필요한 다형성을 피하는 것이 좋지만 모든 코드를 명시 적으로 다시 작성하면 실제로 성능이 저하 될 수 있습니다. 일반적인 판단을 사용하십시오!
  • 수 프리미티브에 유형이 지정된 배열 / 변수를 사용하는 경우 0 을 빈 값으로 사용하십시오. 내부적으로는 두 가지 유형의 숫자가 있습니다. 즉, 빠른 정수 (2147483647에서 -2147483648까지)와 느린 부동 소수점 두 개 ( NaNInfinity 를 포함한 다른 정수)입니다. 정수가 double 값으로 강등되면 integer로 다시 승격 될 수 없습니다.
  • 문자열 프리미티브에 형식이 지정된 배열 / 변수를 사용할 때는 "" 을 빈 값으로 사용하십시오.
  • Symbol을 사용할 때 잠깐, 왜 Symbol을 사용하고 있습니까?!?! 기호는 성능에 나쁜 주주입니다. Symbols를 사용하도록 프로그래밍 된 모든 프로그램은 Symbol을 사용하지 않도록 다시 프로그래밍 할 수 있으므로 Symbol이없는 더 빠른 코드가 생성됩니다. 기호는 실제로 매우 비효율적 인 메타 설탕입니다.
  • 다른 것을 사용할 때는 null 사용하십시오.

그러나주의하십시오! 그러한 기존 코드를 깨뜨리고 이상한 버그를 일으킬 가능성이 있기 때문에 갑자기 모든 기존 코드를 사용하여 갑자기 시작하지 마십시오. 오히려 이러한 효율적인 연습은 처음부터 구현해야하며 기존 코드를 변환 할 때 이전 코드를이 새로운 연습으로 업그레이드하려고 할 때 두 번, 세 번, 네 번 모두 체크하는 것이 좋습니다. 그것은 보람있는만큼 위험합니다.


다음과 같은 객체가 있다고 가정 해보십시오.

var Hogwarts = {
    staff : [
        'Argus Filch',
        'Filius Flitwick',
        'Gilderoy Lockhart',
        'Minerva McGonagall',
        'Poppy Pomfrey',
        ...
    ],
    students : [
        'Hannah Abbott',
        'Katie Bell',
        'Susan Bones',
        'Terry Boot',
        'Lavender Brown',
        ...
    ]
};

객체 속성 삭제

전체 staff배열 을 사용하려는 경우 적절한 방법은 다음과 같습니다.

delete Hogwarts.staff;

또는 다음과 같이 할 수도 있습니다.

delete Hogwarts['staff'];

마찬가지로, 전체 학생의 배열을 제거하는 것은 호출하여 수행 될 수 delete Hogwarts.students;또는delete Hogwarts['students']; .

배열 인덱스 삭제

이제 직원 한 명이나 학생 한 명을 제거하려는 경우 프로 시저가 약간 다릅니다. 두 속성이 모두 배열이기 때문입니다.

직원의 색인을 알고 있다면 간단히 이렇게 할 수 있습니다.

Hogwarts.staff.splice(3, 1);

색인을 모른다면 색인 검색을해야 할 것입니다.

Hogwarts.staff.splice(Hogwarts.staff.indexOf('Minerva McGonnagall') - 1, 1);

노트

delete배열 을 기술적으로 사용할 수는 있지만 , 예를 들어 Hogwarts.staff.length나중에 호출 할 때 잘못된 결과가 발생 합니다. 즉, delete요소를 제거하지만 length속성 값을 업데이트하지는 않습니다 . 사용하면 delete색인 생성이 엉망이됩니다.

따라서 객체에서 값을 삭제할 때 항상 객체 속성을 처리하는지 또는 배열 값을 처리하는지 여부를 먼저 고려하고 그에 따라 적절한 전략을 선택하십시오.

이것을 실험하고 싶다면 이 피 들을 출발점으로 사용할 수 있습니다 .


매우 간단합니다 :

var myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI",
    "regex": "^http://.*"
};

delete myObject.regex;

오래 된 질문, 현대 대답입니다. ECMAScript 6 기능인 객체 파괴 기능을 사용하면 다음과 같이 간단합니다.

const { a, ...rest } = { a: 1, b: 2, c: 3 };

또는 질문 샘플을 사용하십시오.

const myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
const { regex, ...newObject } = myObject;
console.log(newObject);

바벨 (Babel) 시험판 편집기에서 실제로 작동하는지 확인할 수 있습니다.

편집하다:

동일한 변수에 재 할당하려면 let 사용 let .

let myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
({ regex, ...myObject } = myObject);
console.log(myObject);

이렇게 :

delete myObject.regex;
// or,
delete myObject['regex'];
// or,
var prop = "regex";
delete myObject[prop];

데모

var myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI",
    "regex": "^http://.*"
};
delete myObject.regex;

console.log(myObject);

kangax 사용자 인 kangax 는 블로그에 대한 delete 문에 대한 엄청난 심층적 인 블로그 게시물 인 Understanding delete를 작성했습니다 . 적극 추천합니다.


질문 제목에 사용한 용어 Remove a property from a JavaScript object 다른 방법으로 해석 할 수 있습니다. 하나는 전체 메모리와 객체 키 목록에서 제거하는 것이고 다른 하나는 객체에서 제거하는 것입니다. 다른 답변에서 언급했듯이 delete 키워드가 주요 부분입니다. 다음과 같이 객체를 가지고 있다고 가정 해 봅시다.

myJSONObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};

당신이하는 일 :

console.log(Object.keys(myJSONObject));

결과는 다음과 같습니다.

["ircEvent", "method", "regex"]

다음과 같이 객체 키에서 특정 키를 삭제할 수 있습니다.

delete myJSONObject["regex"];

Object.keys(myJSONObject) 사용하는 객체 키는 다음과 같습니다.

["ircEvent", "method"]

그러나 요점은 당신이 메모리에 관심이 있고 그 객체 전체가 메모리에서 제거되기를 원한다면 키를 삭제하기 전에 객체를 null로 설정하는 것이 좋습니다.

myJSONObject["regex"] = null;
delete myJSONObject["regex"];

다른 중요한 점은 동일한 객체에 대한 다른 참조에주의해야한다는 것입니다. 예를 들어, 다음과 같은 변수를 생성하면 :

var regex = myJSONObject["regex"];

또는 다음과 같이 다른 객체에 대한 새 포인터로 추가합니다.

var myOtherObject = {};
myOtherObject["regex"] = myJSONObject["regex"];

그런 다음 myJSONObject 객체에서 제거하더라도 해당 regex 객체와 myOtherObject["regex"] 여전히 값이 있으므로 특정 객체는 메모리에서 삭제되지 않습니다. 그렇다면 우리는 어떻게 그 물체를 확실히 기억에서 제거 할 수 있습니까?

대답은 코드에서 가지고있는 모든 참조삭제하고 그 바로 그 객체를 가리키며 var 문을 사용하여 해당 객체에 대한 새로운 참조를 작성하는 것 입니다. var 문에 관한이 마지막 사항은 우리가 일반적으로 직면하는 가장 중요한 문제 중 하나입니다. 왜냐하면 var 문을 사용하면 생성 된 개체가 제거되지 않기 때문입니다.

즉, var 문을 통해 regex 변수를 작성 했으므로 해당 객체를 제거 할 수 없으며 다음과 같은 경우에 해당 객체를 제거 할 수 없습니다.

delete regex; //False

결과는 false . 이는 삭제 명령문이 예상 한대로 실행되지 않았 음을 의미합니다. 그러나 이전에 변수를 작성하지 myOtherObject["regex"] 를 마지막 참조로 사용했다면 다음과 같이 제거하면됩니다.

myOtherObject["regex"] = null;
delete myOtherObject["regex"];

즉, 해당 객체를 가리키는 코드에 참조가 남아 있지 않으면 JavaScript 객체는 즉시 삭제됩니다.

업데이트 : @AgentME 에게 감사드립니다.

객체를 삭제하기 전에 null로 설정하면 아무 것도 수행하지 않습니다 (객체가 Object.seal에 의해 봉인되지 않고 삭제되지 않는 한). 특별히 시도하지 않는 한 일반적으로 그렇지 않습니다.

Object.seal 에 대한 자세한 정보를 얻으려면 : Object.seal()


ES6 사용 :

(소멸 + 스프레드 연산자)

    const myObject = {
      regex: "^http://.*",
      b: 2,
      c: 3
    };
    const { regex, ...noRegex } = myObject;
    console.log(noRegex); // => { b: 2, c: 3 }

객체에 깊이 중첩 된 속성을 삭제하려는 경우 두 번째 인자로 속성에 대한 경로와 함께 다음 재귀 함수를 사용할 수 있습니다.

var deepObjectRemove = function(obj, path_to_key){
    if(path_to_key.length === 1){
        delete obj[path_to_key[0]];
        return true;
    }else{
        if(obj[path_to_key[0]])
            return deepObjectRemove(obj[path_to_key[0]], path_to_key.slice(1));
        else
            return false;
    }
};

예:

var a = {
    level1:{
        level2:{
            level3: {
                level4: "yolo"
            }
        }
    }
};

deepObjectRemove(a, ["level1", "level2", "level3"]);
console.log(a);

//Prints {level1: {level2: {}}}

안녕하세요 당신은이 간단한 정렬을 시도 할 수 있습니다.

var obj = [];

obj.key1 = {name: "John", room: 1234};
obj.key2 = {name: "Jim", room: 1234};

delete(obj.key1);

여기에 좋은 답변이 많이 있지만 단지 자바 스크립트에서 속성을 삭제하기 위해 delete를 사용할 때 오류를 방지하기 위해 해당 속성이 있는지 먼저 확인하는 것이 좋습니다.

예 :

var obj = {"property":"value", "property2":"value"};

if (obj && obj.hasOwnProperty("property2")) {
  delete obj.property2;
} else {
  //error handling
}

자바 스크립트의 동적 특성 때문에 속성이 존재하는지 여부를 모르는 경우가 종종 있습니다. && 앞에 obj가 있는지 확인하면 정의되지 않은 객체에서 hasOwnProperty () 함수를 호출하기 때문에 오류가 발생하지 않습니다.

죄송합니다. 특정 유스 케이스에 추가되지는 않았지만 객체 및 속성을 관리 할 때 적용 할 수있는 좋은 디자인이라고 생각합니다.


var myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
    
delete myObject.regex;

console.log ( myObject.regex); // logs: undefined

이것은 파이어 폭스와 인터넷 익스플로러에서 작동하며, 나는 다른 모든 것들에서 작동한다고 생각한다.


const myObject = {
        "ircEvent": "PRIVMSG",
        "method": "newURI",
        "regex": "^http://.*"
    };

const { regex, ...other } = myObject;

console.log(myObject)
console.log(regex)
console.log(other)



"regex"원래 개체는 항상 프로그램의 다른 부분에서 참조 할 수 있으므로 속성 없이 새 개체를 만드는 것이 좋습니다. 그러므로 당신은 그것을 조작하는 것을 피해야합니다.

const myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI",
    "regex": "^http://.*"
};

const { regex, ...newMyObject } = myObject;

console.log(newMyObject);


Dan의 주장 인 '삭제'는 매우 느리고 게시 한 벤치 마크는 의심 스럽습니다. 그래서 Chrome 59에서 직접 테스트를 수행했습니다. '삭제'가 약 30 배 느린 것처럼 보입니다.

var iterationsTotal = 10000000;  // 10 million
var o;
var t1 = Date.now(),t2;
for (let i=0; i<iterationsTotal; i++) {
   o = {a:1,b:2,c:3,d:4,e:5};
   delete o.a; delete o.b; delete o.c; delete o.d; delete o.e;
}
console.log ((t2=Date.now())-t1);  // 6135
for (let i=0; i<iterationsTotal; i++) {
   o = {a:1,b:2,c:3,d:4,e:5};
   o.a = o.b = o.c = o.d = o.e = undefined;
}
console.log (Date.now()-t2);  // 205

다른 작업에 의한 영향을 최소화하기 위해 하나의 루프 사이클에서 하나 이상의 '삭제'작업을 의도적으로 수행했습니다.


ECMAScript 2015 (또는 ES6)에는 Reflect 개체 가 내장되어 있습니다. Reflect.deleteProperty() 함수를 대상 객체 및 속성 키를 매개 변수 로 호출하여 객체 속성을 삭제할 수 있습니다 .

Reflect.deleteProperty(myJSONObject, 'regex');

이는 다음과 같습니다.

delete myJSONObject['regex'];

그러나 객체의 속성을 구성 할 수없는 경우 deleteProperty 함수 또는 delete 연산자를 사용하여 삭제할 수 없습니다.

let obj = Object.freeze({ prop: "value" });
let success = Reflect.deleteProperty(obj, "prop");
console.log(success); // false
console.log(obj.prop); // value

Object.freeze() 는 객체의 모든 속성을 구성 할 수 없게 만듭니다 (다른 것들과 함께). deleteProperty함수 (및 developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… )는 false해당 속성 중 하나를 삭제하려고하면 반환 됩니다. 속성이 구성 true가능하면 속성이없는 경우에도 반환 됩니다.

의 차이 delete와는 deleteProperty엄격 모드를 사용하는 경우 :

"use strict";

let obj = Object.freeze({ prop: "value" });
Reflect.deleteProperty(obj, "prop"); // false
delete obj["prop"];
// TypeError: property "prop" is non-configurable and can't be deleted

개인적으로 Underscore.js 를 객체 및 배열 조작에 사용합니다.

myObject = _.omit(myObject, 'regex');

다음 방법을 시도해보십시오. 에 Object속성 값을 할당하십시오 undefined. 그런 다음 stringify객체와 parse.

 var myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};

myObject.regex = undefined;
myObject = JSON.parse(JSON.stringify(myObject));

console.log(myObject);





object-properties