Powiedz, że tworzę przedmiot w następujący sposób:

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

Jaki jest najlepszy sposób na usunięcie właściwości regex, aby skończyć z nowym {x1}} w następujący sposób?

let myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI"
};
6448
johnstok 16 październik 2008, 14:57

27 odpowiedzi

Najlepsza odpowiedź

Lubię to:

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

Próbny

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

console.log(myObject);

Dla każdego, kto jest zainteresowany czytaniem więcej o tym, stack użytkownik przepełnienia Kangax napisał niezwykle dogłębny wpis na blogu o {{{{ X0}} Oświadczenie na swoim blogu, Zrozumienie Usuń . Jest wysoce zalecany.

8672
Jonathan 9 październik 2017, 16:55

Korzystanie z ES6:

(Destrucing + Spread Operator)

const myObject = {
    regex: "^http://.*",
    b: 2,
    c: 3
};
const { regex, ...noRegex } = myObject;
console.log(noRegex); // => { b: 2, c: 3 }
36
kalehmann 6 czerwiec 2019, 13:25

Usuń operator jest najlepszym sposobem więc.

Przykład na żywo, aby pokazać:

var foo = {bar: 'bar'};
delete foo.bar;
console.log('bar' in foo); // Logs false, because bar was deleted from foo.
29
Peter Mortensen 11 luty 2016, 20:30

Możesz po prostu usunąć dowolną właściwość obiektu za pomocą słowa kluczowego {x0}}.

Na przykład:

var obj = {key1:"val1",key2:"val2",key3:"val3"}

Aby usunąć dowolną właściwość, powiedzmy key1, użyj słowa kluczowego delete:

delete obj.key1

Lub można również użyć nazwy podobnej do tablicy:

delete obj[key1]

REF: MDN.

7
Peter Mortensen 22 listopad 2016, 22:11

Rozważ tworzenie nowego obiektu bez właściwości {X0}}, ponieważ oryginalny obiekt może być zawsze odwoływany przez inne części programu. W ten sposób należy unikać manipulowania.

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

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

console.log(newMyObject);
6
ideaboxer 23 październik 2017, 10:06
const myObject = {
        "ircEvent": "PRIVMSG",
        "method": "newURI",
        "regex": "^http://.*"
    };

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

console.log(myObject)
console.log(regex)
console.log(other)
6
xiang 6 luty 2018, 04:28

Możesz użyć destrukcji ES6 z operatorem odpoczynku.

Właściwości można usunąć za pomocą destrukcjonowania w połączeniu z operatorem . W przykładzie regex jest zniszczony (ignorowany), a reszta właściwości jest zwracana jako odpoczynek.

const noRegex = ({ regex, ...rest }) => rest;
const myObject = {
  "ircEvent": "PRIVMSG",
  "method": "newURI",
  "regex": "^http://.*"
};

console.log(noRegex(myObjext)) //=> {  "ircEvent": "PRIVMSG","method": "newURI" }

Lub możesz dynamicznie wykluczyć tak, jak to w ten sposób,

const myObject = {
  "ircEvent": "PRIVMSG",
  "method": "newURI",
  "regex": "^http://.*"
};
const removeProperty = prop => ({ [prop]: _, ...rest }) => rest

const removeRegex = removeProperty('regex') //=> {  "ircEvent": "PRIVMSG","method":"newURI" }
const removeMethod = removeProperty('method') //=> {  "ircEvent": "PRIVMSG", "regex":"^http://.*" }
6
Bhargav Patel 10 kwiecień 2019, 20:40

Spróbuj tego

delete myObject['key'];
5
codemirror 26 maj 2017, 06:58

Witaj, możesz spróbować tego prostego rodzaju

var obj = [];

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

delete(obj.key1);
5
Gohel Dhaval 26 maj 2017, 09:28

Istnieje tutaj wiele dobrych odpowiedzi, ale chcę się tylko dzwonić, gdy używasz Usuń, aby usunąć nieruchomość w JavaScript, często jest mądry, aby najpierw sprawdzić, czy właściwość istnieje, aby zapobiec błędom.

Na przykład

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

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

Ze względu na dynamiczny charakter JavaScriptu często występują przypadki, w których po prostu nie wiesz, czy właściwość istnieje, czy nie. Sprawdzanie, czy OBJ istnieje, zanim && zapewnia również, że nie rzucisz błąd z powodu wywołania funkcji HasownProperty () na niezdefiniowanym obiekcie.

Przepraszam, jeśli nie dodano to do konkretnego przypadku, ale uważam, że jest to dobry projekt, aby dostosować się podczas zarządzania obiektami i ich właściwościami.

22
Willem 15 wrzesień 2014, 00:48

Ten post jest bardzo stary i uważam go za bardzo pomocne, więc postanowiłem dzielić się niepewną funkcją, którą napisałem na wypadek, gdyby ktoś inny zobaczył ten post i pomyśleć, dlaczego nie jest tak proste, jak w przypadku niepewnej funkcji PHP.

Powodem pisania tego nowego funkcji {x0}} jest utrzymanie indeksu wszystkich innych zmiennych w tym hash_mapie. Spójrz na poniższy przykład i zobacz, jak wskaźnik "Test2" nie zmienił się po usunięciu wartości z hash_map.

function unset(unsetKey, unsetArr, resort){
  var tempArr = unsetArr;
  var unsetArr = {};
  delete tempArr[unsetKey];
  if(resort){
    j = -1;
  }
  for(i in tempArr){
    if(typeof(tempArr[i]) !== 'undefined'){
      if(resort){
        j++;
      }else{
        j = i;
      }
      unsetArr[j] = tempArr[i];
    }
  }
  return unsetArr;
}

var unsetArr = ['test','deletedString','test2'];

console.log(unset('1',unsetArr,true)); // output Object {0: "test", 1: "test2"}
console.log(unset('1',unsetArr,false)); // output Object {0: "test", 2: "test2"}
22
CertainPerformance 30 styczeń 2021, 20:18

Korzystanie z Ramda # Discoc otrzymasz nowy obiekt bez atrybutu {x0}}:

const newObject = R.dissoc('regex', myObject);
// newObject !== myObject

Możesz także użyć innych funkcji, aby uzyskać ten sam efekt - pomiń, wybór ...

17
Amio.io 28 listopad 2016, 15:14

Wypróbuj następującą metodę. Przypisz wartość właściwości Object do undefined. Następnie stringify obiekt i {x3}}.

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

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

console.log(myObject);
16
Peter Mortensen 22 listopad 2016, 22:12

Jeśli chcesz usunąć nieruchomość głęboko zagnieżdżoną w obiekcie, możesz użyć następującej funkcji rekurencyjnej ze ścieżką do nieruchomości jako drugiego argumentu:

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

Przykład:

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

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

//Prints {level1: {level2: {}}}
13
ayushgp 23 czerwiec 2016, 09:38

Twierdzenie Dana, że "Usuń" jest bardzo powolny, a punkt benchmarku był wątpliwy. Tak więc przeprowadziłem test w Chrome 59. Wydaje się, że "usuwanie" ma około 30 razy wolniej:

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

Należy pamiętać, że zamierzam przeprowadzić więcej niż jedną "Usuń" operacje w jednym cyklu pętli, aby zminimalizować efekt spowodowany przez inne operacje.

9
Chong Lip Phang 26 lipiec 2017, 07:19

Usuwanie mienia w JavaScript

Na tej stronie przedstawiono wiele różnych opcji, a nie dlatego, że większość opcji jest błędna - lub ponieważ odpowiedzi są duplikaty - ale ponieważ odpowiednia technika zależy od sytuacji, w której jesteś i cele zadań, w których ty i / lub ty Zespół próbuje spełnić. Aby odpowiedzieć na pytanie jednoznacznie, trzeba wiedzieć:

  1. Wersja ECMASCRIPTE jesteś kierowany
  2. Zakres typów obiektów, które chcesz usunąć właściwości oraz typ nazw nieruchomości, które musisz być w stanie pominąć (tylko sznurki? )
  3. Programowanie etos / wzory, których używasz i twój zespół. Czy faworyzujesz podejścia funkcjonalne, a mutacja jest dosłowna w twoim zespole lub wykorzystujesz dzikie techniki zorientowane na obiekty Zachodnie?
  4. Czy chcesz to osiągnąć w czystym javascript lub jesteś chętny i w stanie korzystać z biblioteki 3RD-party?

Po odebraniu tych czterech zapytań jest zasadniczo cztery kategorie "usuwania nieruchomości" w JavaScript, aby wybrać, aby spełnić swoje cele. Oni są:

Usunięcie właściwości obiektów mutacyjnych, niebezpieczny

Ta kategoria służy do pracy na literówkach obiektów lub instancjach obiektów, gdy chcesz zachować / kontynuować korzystanie z oryginalnego odniesienia i nie używają bezpańskich zasad funkcjonalnych w kodzie. Przykładowy kawałek składni w tej kategorii:

'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

Ta kategoria jest najstarszym, najbardziej prostym & amp; Najczęściej obsługiwana kategoria usuwania mienia. Obsługuje Symbol & amp; Indeksy tablicy oprócz ciągów i działa w każdej wersji JavaScript, z wyjątkiem pierwszego wydania. Jednak jest mutacyjny, który narusza niektóre zasady programowania i ma implikacje wydajności. Może również skutkować wyjątkami nieaktusionymi, gdy są używane na nie konfigurowalny Właściwości w trybie ścisłym.

Pomijanie obiektów ciągowych opartych na odpoczynku

Ta kategoria służy do pracy na zwykłym obiekcie lub instancji tablicy w nowszych smakach ECMASCRIP, gdy pożądane jest podejście nietulatywne i nie musisz uwzględniać kluczy symboli:

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

Usunięcie właściwości obiektów objętego obiektów, sejf

Ta kategoria służy do pracy na literówkach obiektów lub instancji obiektowych, gdy chcesz zachować / kontynuować użycie oryginalnego odniesienia podczas ochrony przed wyrzucaniem wyjątków na nieskonfekuralne właściwości:

'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

Ponadto, przy jednoczesnym odwzorowaniu obiektów, nie można bezproblemowy, możesz użyć natury funkcjonalnej Reflect.deleteProperty do wykonywania częściowej aplikacji i innych technik funkcjonalnych, które nie są możliwe z instrukcjami delete.

Pomijanie obiektów ciągowych opartych na składniach

Ta kategoria służy do pracy na zwykłym obiekcie lub instancji tablicy w nowszych smakach ECMASCRIP, gdy pożądane jest podejście nietulatywne i nie musisz uwzględniać kluczy symboli:

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

Pomijanie nieruchomości na bazie biblioteki

Ta kategoria jest na ogół pozwala na większą elastyczność funkcjonalną, w tym rozliczanie symboli i pomijania więcej niż jednej nieruchomości w jednym oświadczeniu:

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"
9
james_womack 14 grudzień 2017, 02:35

Obiekt.Asign () i obiekt.keys () i array.map ()

const obj = {
    "Filters":[
        {
            "FilterType":"between",
            "Field":"BasicInformationRow.A0",
            "MaxValue":"2017-10-01",
            "MinValue":"2017-09-01",
            "Value":"Filters value"
        }
    ]
};

let new_obj1 = Object.assign({}, obj.Filters[0]);
let new_obj2 = Object.assign({}, obj.Filters[0]);

/*

// old version

let shaped_obj1 = Object.keys(new_obj1).map(
    (key, index) => {
        switch (key) {
            case "MaxValue":
                delete new_obj1["MaxValue"];
                break;
            case "MinValue":
                delete new_obj1["MinValue"];
                break;
        }
        return new_obj1;
    }
)[0];


let shaped_obj2 = Object.keys(new_obj2).map(
    (key, index) => {
        if(key === "Value"){
            delete new_obj2["Value"];
        }
        return new_obj2;
    }
)[0];


*/


// new version!

let shaped_obj1 = Object.keys(new_obj1).forEach(
    (key, index) => {
        switch (key) {
            case "MaxValue":
                delete new_obj1["MaxValue"];
                break;
            case "MinValue":
                delete new_obj1["MinValue"];
                break;
            default:
                break;
        }
    }
);

let shaped_obj2 = Object.keys(new_obj2).forEach(
    (key, index) => {
        if(key === "Value"){
            delete new_obj2["Value"];
        }
    }
);
8
10 listopad 2017, 06:36

Operator delete jest niesprawiedliwie powolny!

Spójrz na benchmark .

Usuń jest jedynym prawdziwym sposobem usuwania właściwości obiektu bez resztek, ale działa ~ 100 razy wolniej , W porównaniu z jego "alternatywną", ustawieniem object[key] = undefined.

Ta alternatywa nie jest prawidłową odpowiedzią na to pytanie! Ale jeśli używasz go z opieką, można znacznie przyspieszyć niektóre algorytmy. Jeśli używasz delete w pętlach i masz problemy z wydajnością, przeczytaj wyraźne wyjaśnienie.

Kiedy należy użyć delete i po ustawieniu wartości do undefined?

Obiekt może być postrzegany jako zestaw par kluczowych par. To, co nazywam "wartością", jest prymitywnym lub odniesieniem do innego obiektu, podłączony do tego "Klucz".

Użyj delete, , gdy przekazywasz obiekt wynikowy do kodu, na którym nie masz sterowania (lub gdy nie jesteś pewien swojego zespołu lub siebie).

IT Usuwa klucz z hashmapu .

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

Użyj ustawienia do undefined, , gdy zależy Ci na wydajności. Może dać poważne zwiększenie kodu.

Klucz pozostaje na swoim miejscu w Hashmap , tylko wartość zostanie zastąpiona undefined. Zrozum, że pętla for..in będzie nadal iteruje się nad tym kluczem.

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

Korzystając z tej metody, nie wszystkie sposoby określania istnienia właściwości będzie działać zgodnie z oczekiwaniami.

Jednak ten kod:

object.field === undefined

Zachowuje się równoważnie dla obu metod.

Testy

Podsumowując, różnice są o sposobach określania istnienia właściwości, a około for..in pętla.

 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. *');

Uważaj na wycieki pamięci!

Podczas stosowania obj[prop] = undefined jest szybszy niż robienie {x1}}, innym ważnym uwzględnieniem jest to, że obj[prop] = undefined może być zawsze odpowiednie. delete obj[prop] Usuwa prop z obj i usuwa go z pamięci, podczas gdy obj[prop] = undefined Po prostu ustawia wartość prop do undefined, która pozostawia {{x9} } Nadal w pamięci. W związku z tym w okolicznościach, w których istnieje wiele kluczy tworzonych i usuniętych, przy użyciu obj[prop] = undefined może wymusić kosztowne pojednanie pamięci (powodując, że strona będzie zamrażać) i potencjalnie niezwykłą błędy. Sprawdź następujący kod.

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

W powyższym kodzie po prostu wykonuje nodeRecords[i][lastTime] = undefined; spowoduje, że będzie masywny wyciek pamięci, ponieważ każda ramka animacji. Każda ramka, wszystkie elementy 65536 DOM zajmą kolejne 65536 pojedynczych szczelin, ale poprzednie szczeliny 65536 będą ustawione tylko do niezdefiniowanego, co pozostawia ich wiszące w pamięci. Idź dalej, spróbuj uruchomić powyższy kod w konsoli i zobaczyć sam. Po wymuszaniu błędu poza pamięcią, spróbuj uruchomić go ponownie z wyjątkiem następującej wersji kodu, który używa operatora 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 );
});

Jak widać w powyższym fragmencie kodu, istnieją rzadkie odpowiednie przypadki użycia dla operatora delete. Nie martw się jednak o ten problem. Spowoduje to tylko problem z długoterminowymi obiektami, które stale dodawały nowe klucze. W każdym innym przypadku (który jest prawie każdym przypadkiem w programowaniu rzeczywistym), jest najbardziej odpowiedni do użycia obj[prop] = undefined. Głównym celem tej sekcji jest tylko w celu zwrócenia uwagi, aby w rzadkiej szans, że stanie się to problemem w swoim kodzie, możesz łatwiej zrozumieć problem, a zatem nie musi trwać godzin rozpraszać swój kod, aby zlokalizować i zrozum ten problem.

Nie zawsze ustawiaj undefined

Jednym z aspektów JavaScript, który jest ważny do rozważenia jest polimorfizm. Polimorfizm polega na przypisywaniu tej samej zmiennej / gniazda in-obiektów różnych typów, jak widać poniżej.

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

Istnieją jednak dwa poważne nietypowe problemy z polimorficznych tablic:

  1. Są powolne i nieefektywne. Podczas uzyskiwania dostępu do określonego indeksu, zamiast po prostu uzyskać typ globalny dla tablicy, przeglądarka ma zamiast tego, aby uzyskać typ na zasadzie indeksu, przy czym każdy indeks przechowuje dodatkowe metadane tego typu.
  2. Po polimorficznym, zawsze polimorficznym. Gdy tablica jest polimorficzna, polimorfizm nie może zostać cofnięty w przeglądarkach WebKit. Tak więc, nawet jeśli przywrócisz polimorficzną tablicę, by być nie-polimorficznym, nadal będzie przechowywany przez przeglądarkę jako tablicę polimorficzną.

Można porównać polimorfizm do uzależnienia od narkotyków. Na pierwszy rzut oka wydaje się niesamowicie lukratywny: ładny ładny kodu puszysty. Następnie koder wprowadza swoją tablicę do leku polimorfizmu. Natychmiast, polimorficzna tablica staje się mniej wydajna, a nigdy nie może stać się tak skuteczne, jak było wcześniej, ponieważ jest narażeniowe. Aby korelować takie okoliczności do prawdziwego życia, ktoś na kokainie może nawet nie być w stanie obsługiwać prosty uchwyt drzwi, znacznie mniej w stanie obliczyć cyfry PI. Podobnie, tablica na leku polimorfizmu nie może być tak skuteczna jak monomorficzna tablica.

Ale w jaki sposób analogia wycieczki leku odnosi się do operacji delete? Odpowiedź dziedzi ostatnia linia kodu w fragmence powyżej. W ten sposób zostanie ponownie zrezygnowany, tym razem z niespodzianką.

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

Przestrzegać. bar[1] = "" nie należy docenić polimorfizmu, podczas gdy bar[1] = undefined robi. Dlatego należy zawsze, gdy tylko możliwe, użyj odpowiedniego typu dla ich przedmiotów, aby nie przypadkowo powodować polimorfizm. Jedna osoba może wykorzystywać poniższą listę jako ogólne odniesienie, aby jechać. Jednak nie używaj wyraźnie z poniższych pomysłów. Zamiast tego użyj wszystkiego, co działa dobrze dla swojego kodu.

  • Podczas stosowania tablicy / zmiennej wpisanej do prymitywu boolowskiego należy użyć false lub undefined jako pusta wartość. Unikanie niepotrzebnego polimorfizmu jest dobry, przepisując cały kod, aby wyraźnie zabronić, prawdopodobnie spowoduje zmniejszenie wydajności. Użyj zwykłego oceny!
  • Podczas używania tablicy / zmiennej wpisanej do numeru numeru, użyj 0 jako pustej wartości. Należy zauważyć, że wewnętrznie istnieją dwa typy liczb: szybkie liczby całkowite (2147483647 do -2147483648 włącznie) i powolny pływający punkt podwaja (cokolwiek innego niż to, w tym NaN i Infinity). Gdy liczba całkowita jest zdegradowana do podwójnego, nie może być awansowany z powrotem do liczby całkowitej.
  • Podczas stosowania tablicy / zmiennej wpisanej do prymitywnego ciągu, użyj "" jako pustej wartości.
  • Podczas korzystania z symbolu, poczekaj, dlaczego używasz symbolu?!?! Symbole są złym Juju dla wydajności. Wszystko zaprogramowane do użycia symboli można przeprogramować, aby nie używać symboli, co powoduje szybszy kod bez symboli. Symbole są naprawdę po prostu super nieefektywnym cukrem meta.
  • Używając czegoś innego, użyj null.

Jednak bądź uważny! Nagle nie zacznij robić tego z całym swoim wcześniejszym kodem, ponieważ prawdopodobnie przełamałby taki preexisting kod i / lub wprowadzić dziwne błędy. Raczej taka wydajna praktyka musi być wdrażana z rozpoczęcia, a podczas konwersji kodu PreteySting, zaleca się podwójne, potrójne, czteroosobowe sprawdzić wszystkie linie związane z tym, że próbując uaktualnić stary kod do tej nowej praktyki, może być jak ryzykowny, jak to jest satysfakcjonujące.

989
Ben Aston 18 kwiecień 2020, 19:28
var myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
    
delete myObject.regex;

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

Działa to w Firefox i Internet Explorerze i myślę, że działa we wszystkich innych.

268
str 1 czerwiec 2018, 16:29

Stare pytanie, nowoczesna odpowiedź. Korzystanie z niszczenia obiektów, ECMAScript 6 Funkcja, jest tak prosta jak:

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

Lub z próbą pytań:

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

Możesz go zobaczyć w akcji w edytorze trybu pracy Babel.


Edytuj:

Aby przypisać do tej samej zmiennej, użyj let:

let myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
({ regex, ...myObject } = myObject);
console.log(myObject);
236
Koen. 1 grudzień 2016, 20:51

Składnia rozprzestrzeniania (ES6)

Kto potrzebuje tego ...

Aby zakończyć @Koen Odpowiedź w tym wątku, na wypadek, gdybyś chcesz usunąć dynamiczną zmienną za pomocą składni Rozwiązywać, możesz to zrobić jak więc:

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

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

* foo będzie nową zmienną o wartości a (która jest 1).


.. rozszerzona odpowiedź 😇
Istnieje kilka zwykłych sposobów na usunięcie nieruchomości z obiektu "Rel =" NefEferr "> Sprawdź porównanie wydajności ):

operator usuń
Czytelny i krótki, jednak może nie być najlepszym wyborem, jeśli pracujesz na dużej liczbie obiektów, ponieważ jego wydajność nie jest zoptymalizowana.

delete obj[key];


.. przypisanie przypisania
Więcej niż 2x szybciej niż delete, jednak właściwość jest , a nie usunięta i może być iterowany.

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


.. operator spread
Ten operator ES6 umożliwia nam zwrócenie nowego obiektu, z wyłączeniem dowolnych właściwości, bez znaczenia istniejącego obiektu. Minusem jest to, że ma gorsze wyniki z powyższego i nie sugerowano, że należy użyć, gdy trzeba usunąć wiele właściwości na raz.

{ [key]: val, ...rest } = obj;
158
Lior Elrom 18 grudzień 2019, 15:36

Inną alternatywą jest użycie underscore.js biblioteka.

Należy pamiętać, że _.pick() i _.omit() Oba zwróci kopię obiektu i nie modyfikują bezpośrednio obiektu oryginalnego. Przypisanie wyniku do oryginalnego obiektu powinien wykonać sztuczkę (nie pokazano).

Odniesienie: link _. Pick (Obiekt, * Klucze)

Zwróć kopię obiektu, przesączono, aby mieć tylko wartości dla kluczy białej (lub tablicy prawidłowych kluczy).

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

_.pick(myJSONObject, "ircEvent", "method");
=> {"ircEvent": "PRIVMSG", "method": "newURI"};

Odniesienie: link _. Pomiń (obiekt, * klucze)

Zwróć kopię obiektu, przesączono, aby pominąć klawisze blacklistowane (lub tablicę kluczy).

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

_.omit(myJSONObject, "regex");
=> {"ircEvent": "PRIVMSG", "method": "newURI"};

Dla tablic, _.filter() i _.reject() może być używany w podobny sposób.

103
Thaddeus Albers 3 luty 2018, 19:51

Termin, którego używałeś w tytule pytania Remove a property from a JavaScript object, można interpretować na różne sposoby. Ten jest usunięcie go do całej pamięci i listę klawiszy obiektów lub drugi, aby usunąć go z obiektu. Jak wspomniano w innych odpowiedziach, słowo kluczowe delete jest główną częścią. Powiedzmy, że masz swój obiekt, taki jak:

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

Jeśli zrobisz:

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

Rezultat byłby:

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

Możesz usunąć ten konkretny klucz z kluczy obiektowych, takich jak:

delete myJSONObject["regex"];

Następnie klawisz obiektów przy użyciu Object.keys(myJSONObject) byłby:

["ircEvent", "method"]

Ale chodzi o to, że jeśli zależy Ci na pamięci i chcesz cały obiekt zostaje usunięty z pamięci, zaleca się ustawienie go do NULL przed usunięciem klucza:

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

Drugim ważnym punktem jest uważanie się na innych odniesieniu do tego samego obiektu. Na przykład, jeśli tworzysz zmienną jak:

var regex = myJSONObject["regex"];

Lub dodaj go jako nowy wskaźnik do innego obiektu jak:

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

Wtedy nawet jeśli usuniesz go z obiektu myJSONObject, ten konkretny obiekt nie zostanie usunięty z pamięci, ponieważ zmienna {x2}} i myOtherObject["regex"] nadal ma swoje wartości. Więc w jaki sposób możemy usunąć obiekt z pamięci na pewno?

Odpowiedź byłaby Usuń wszystkie odniesienia, które masz w swoim kodzie, wskazał na ten obiekt , a także nie używać instrukcji var, aby utworzyć nowe odniesienia do tego obiektu . Ten ostatni punkt dotyczący var, jest jednym z najważniejszych problemów, z którymi zazwyczaj stoimy, ponieważ za pomocą instrukcji var uniemożliwiłoby usunięcie utworzonego obiektu.

Co oznacza, że w tym przypadku nie będziesz mógł usunąć tego obiektu, ponieważ utworzono zmienną regex za pomocą oświadczenia var, a jeśli to zrobisz:

delete regex; //False

Wynik byłby false, co oznacza, że twoje oświadczenie usuwania nie zostało wykonane, jak się spodziewałeś. Ale jeśli nie stworzyłeś tego zmiennej wcześniej, a ty miałeś tylko myOtherObject["regex"] jako ostatnie istniejące odniesienie, mógłbyś to zrobić, usuwając go jak:

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

Innymi słowy, obiekt JavaScript zostanie zabity, gdy tylko nie ma żadnego odniesienia w kodzie, wskazał na ten obiekt.


Aktualizacja : Dzięki @Aagentme:

Ustawianie nieruchomości do NULL Przed usunięciem nie osiągnie niczego (chyba że obiekt został uszczelniony przez obiekt.Seal i usunięcie nie powiedzie się. Nie zazwyczaj nie jest to przypadek, chyba że specjalnie spróbujesz).

Aby uzyskać więcej informacji na temat Object.seal: Obiekt.seal ()

59
Mehran Hatami 2 czerwiec 2015, 22:18

ECMAScript 2015 (lub ES6) przyszedł z wbudowanym odzwierciedlają obiekt. Możliwe jest usuwanie właściwości obiektu dzwonując reflect.deleteproperty () Funkcja z obiektem docelowym i kluczem właściwości jako parametry:

Reflect.deleteProperty(myJSONObject, 'regex');

Co jest równoważne z:

delete myJSONObject['regex'];

Ale jeśli właściwość obiektu nie jest konfigurowalna, nie można go usunąć ani z funkcją deleteproperty, ani operatora usuwania:

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

Obiekt.Freeze () sprawia, że wszystkie właściwości obiektu nie jest konfigurowalne (Oprócz innych rzeczy). deleteProperty Funkcja (jak również Operator Usuń) false Gdy próbuje usunąć dowolne właściwości. Jeśli właściwość jest konfigurowalna, zwraca true, nawet jeśli właściwość nie istnieje.

Różnica między delete a deleteProperty jest przy użyciu ścisłego trybu:

"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
46
madox2 25 styczeń 2016, 17:22

Osobiście używam undercreor.js lub Lodash do manipulacji obiektów i tablicy:

myObject = _.omit(myObject, 'regex');
34
emil 21 styczeń 2019, 11:24

Korzystanie z Usuń Metoda jest najlepszym sposobem na to, zgodnie z opisem MDN, operator usuwania usuwa właściwość z obiektu. Więc możesz po prostu pisać:

delete myObject.regex;
// OR
delete myObject['regex'];

Operator usuwania usuwa daną właściwość z obiektu. W sprawie udanego usunięcia powróci prawdziwe, w przeciwnym razie zostanie zwrócona fałsz. Jednak ważne jest, aby wziąć pod uwagę następujące scenariusze:

  • Jeśli właściwość, którą próbujesz usunąć, nie istnieje, usuń nie będzie miał żadnego wpływu i zwróci true

  • Jeśli właściwość o tej samej nazwie istnieje na prototypie obiektu Łańcuch, a następnie, po usunięciu obiekt użyje nieruchomości z Łańcuch prototypowy (innymi słowy, usunięcie tylko ma wpływ na własny Właściwości).

  • Każda nieruchomość zadeklarowana z VAR nie może zostać usunięta z zakresu globalnego lub z zakresu funkcji.

  • jako takie, usunięcie nie może usunąć żadnych funkcji w zakresie globalnego (czy jest to część z definicji funkcji lub funkcji (ekspresji).

  • Funkcje, które są częścią obiektu (poza
    Globalny zakres) można usunąć za pomocą Usuń.

  • Każda nieruchomość zadeklarowana z pozwolą lub Const nie może zostać usunięta z zakresu, w którym zostały zdefiniowane. Nie można usunąć właściwości niekonfigurowalnych. Obejmuje to właściwości wbudowanych obiektów, takich jak matematyka, tablica, obiekt i właściwości tworzone jako nie konfigurowalne z metodami, takimi jak Object.DeFineProperty ().

Poniższy fragment daje kolejny prosty przykład:

var Employee = {
      age: 28,
      name: 'Alireza',
      designation: 'developer'
    }
    
    console.log(delete Employee.name);   // returns true
    console.log(delete Employee.age);    // returns true
    
    // When trying to delete a property that does 
    // not exist, true is returned 
    console.log(delete Employee.salary); // returns true

Aby uzyskać więcej informacji na temat i widząc więcej przykładu, odwiedź poniższy link:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete

28
Alireza 16 kwiecień 2019, 23:22

Innym rozwiązaniem, przy użyciu {{x0} } .

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

myObject = Object.keys(myObject).reduce(function(obj, key) {
  if (key != "regex") {           //key you want to remove
    obj[key] = myObject[key];
  }
  return obj;
}, {});

console.log(myObject);

Jednak będzie mutanem oryginalny obiekt. Jeśli chcesz utworzyć nowy obiekt bez określonego klawisza , wystarczy przypisać funkcję zmniejszenia do nowej zmiennej, np.:

(ES6)

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

const myNewObject = Object.keys(myObject).reduce((obj, key) => {
  key !== 'regex' ? obj[key] = myObject[key] : null;
  return obj;
}, {});

console.log(myNewObject);
25
kind user 24 październik 2017, 09:58