Za pomocą tablicy JavaScript mogę zresetować ją do pustego stanu za pomocą jednego przypisania:

array.length = 0;

To sprawia, że ​​tablica „wydaje się” pusta i gotowa do ponownego użycia, a o ile rozumiem, jest to pojedyncza „operacja” - to znaczy stały czas.

Czy istnieje podobny sposób na wyczyszczenie obiektu JS? Wiem, że mogę iterować jego pola, usuwając je:

for (var prop in obj) { if (obj.hasOwnProperty(prop)) { delete obj[prop]; } }

ale ma to złożoność liniową.

Mogę też po prostu wyrzucić obiekt i stworzyć nowy:

obj = {};

Ale „rozwiązłe” tworzenie nowych obiektów prowadzi do problemów z Garbage Collection w IE6. ( Jak opisano tutaj )

Myślę, że krótka odpowiedź na twoje pytanie brzmi: nie (możesz po prostu stworzyć nowy obiekt).

1. W tym przykładzie uważam, że ustawienie długości na 0 nadal pozostawia wszystkie elementy do czyszczenia pamięci.

2. Możesz dodać to do Object.prototype, jeśli jest to coś, czego często używasz. Tak, jest to liniowe pod względem złożoności, ale wszystko, co później nie usunie elementów bezużytecznych, będzie.

3. To najlepsze rozwiązanie. Wiem, że to nie jest związane z twoim pytaniem - ale jak długo musimy kontynuować obsługę IE6? Istnieje wiele kampanii mających na celu zaprzestanie korzystania z niego.

Zapraszam do poprawiania mnie, jeśli powyżej jest coś nieprawidłowego.

Cóż, ryzykując, że wszystko będzie zbyt łatwe ...

for (var member in myObject) delete myObject[member];

... wydawałby się całkiem skuteczny w czyszczeniu obiektu w jednej linii kodu z minimalną ilością przerażających nawiasów. Wszyscy członkowie zostaną naprawdę usunięci, a nie pozostawieni jako śmieci.

Oczywiście, jeśli chcesz usunąć sam obiekt, nadal będziesz musiał wykonać w tym celu oddzielną metodę delete ().

ES5

Rozwiązanie ES5 może być:

// for enumerable and non-enumerable properties
Object.getOwnPropertyNames(obj).forEach(function (prop) {
  delete obj[prop];
});

ES6

A rozwiązaniem ES6 może być:

// for enumerable and non-enumerable properties
for (const prop of Object.getOwnPropertyNames(obj)) {
  delete obj[prop];
}

Występ

Niezależnie od specyfikacji najszybszymi rozwiązaniami będą na ogół:

// for enumerable and non-enumerable of an object with proto chain
var props = Object.getOwnPropertyNames(obj);
for (var i = 0; i < props.length; i++) {
  delete obj[props[i]];
}

// for enumerable properties of shallow/plain object
for (var key in obj) {
  // this check can be safely omitted in modern JS engines
  // if (obj.hasOwnProperty(key))
    delete obj[key];
}

Powodem, dla którego for..inpowinno być wykonywane tylko na płytkim lub prostym obiekcie, jest to, że przechodzi on przez właściwości, które są prototypowo dziedziczone, a nie tylko przez własne właściwości, które można usunąć. W przypadku, gdy nie wiadomo na pewno, że obiekt jest jasny i właściwości są przeliczalne, forze Object.getOwnPropertyNamesjest lepszym wyborem.

Możesz tego spróbować. Poniższa funkcja ustawia wszystkie wartości właściwości obiektu na niezdefiniowane. Działa również z obiektami zagnieżdżonymi.

var clearObjectValues = (objToClear) => {
    Object.keys(objToClear).forEach((param) => {
        if ( (objToClear[param]).toString() === "[object Object]" ) {
            clearObjectValues(objToClear[param]);
        } else {
            objToClear[param] = undefined;
        }
    })
    return objToClear;
};

Podsumowując swoje pytanie: chcesz uniknąć, w miarę możliwości, problemów z błędem IE6 GC. Ten błąd ma dwie przyczyny:

1. Wyrzucanie elementów bezużytecznych odbywa się raz na wiele alokacji ; w związku z tym im więcej alokacji dokonasz, tym częściej GC będzie działać;
2. Im więcej obiektów masz „w powietrzu”, tym więcej czasu zajmuje każdy przebieg procesu Garbage Collection (ponieważ będzie przeszukiwał całą listę obiektów, aby zobaczyć, które są oznaczone jako śmieci).

Wydaje się, że rozwiązaniem przyczyny 1 jest: utrzymanie małej liczby przydziałów; przypisuj nowe obiekty i ciągi tak mało, jak to możliwe.

Wydaje się, że rozwiązaniem przyczyny 2 jest: ograniczenie liczby „żywych” obiektów; usuwaj ciągi i obiekty, gdy nie będziesz ich już potrzebować, i twórz je od nowa, gdy zajdzie taka potrzeba.

Do pewnego stopnia rozwiązania te są sprzeczne: utrzymanie małej liczby obiektów w pamięci pociągnie za sobą więcej alokacji i cofnięć. I odwrotnie, ciągłe ponowne wykorzystywanie tych samych obiektów może oznaczać przechowywanie w pamięci większej liczby obiektów, niż jest to absolutnie konieczne.

A teraz pytanie. Niezależnie od tego, czy zresetujesz obiekt, tworząc nowy, czy usuwając wszystkie jego właściwości: będzie to zależeć od tego, co chcesz z nim później zrobić.

Prawdopodobnie będziesz chciał przypisać do niego nowe właściwości:

• Jeśli zrobisz to natychmiast, sugeruję natychmiastowe przypisanie nowych właściwości i najpierw pomiń usuwanie lub czyszczenie. (Upewnij się jednak, że wszystkie właściwości zostały nadpisane lub usunięte!)
• Jeśli obiekt nie będzie używany od razu, ale zostanie ponownie zapełniony na późniejszym etapie, proponuję usunąć go lub przypisać mu wartość null, a później utworzyć nowy.

Nie ma szybkiego i łatwego w użyciu sposobu na wyczyszczenie obiektu JScript do ponownego użycia, tak jakby był to nowy obiekt - bez tworzenia nowego. Co oznacza, że ​​krótka odpowiedź na twoje pytanie brzmi „nie”, jak mówi jthompson.

Coś nowego do przemyślenia w oczekiwaniu na Object.observe w ES7 i ogólnie z wiązaniem danych. Rozważać:

var foo={
   name: "hello"
};

Object.observe(foo, function(){alert('modified');}); // bind to foo

foo={}; // You are no longer bound to foo but to an orphaned version of it
foo.name="there"; // This change will be missed by Object.observe()

W tej sytuacji nr 2 może być najlepszym wyborem.

Możesz usunąć właściwości, ale nie usuwaj zmiennych. delete abc;jest nieprawidłowy w ES5 (i wyrzuca z użyciem ścisłego).

Możesz przypisać go do wartości null, aby ustawić go do usunięcia w GC (nie będzie, jeśli masz inne odniesienia do właściwości)

Ustawienie lengthwłaściwości obiektu niczego nie zmienia. (tylko, cóż, ustawia właściwość)

To mnie niepokoiło przez wieki, więc oto moja wersja, ponieważ nie chciałem pustego obiektu, chciałem mieć taki, który ma wszystkie właściwości, ale został zresetowany do jakiejś domyślnej wartości. Coś jak nowa instancja klasy.

let object1 = {
  a: 'somestring',
  b: 42,
  c: true,
  d:{
    e:1,
    f:2,
    g:true,
    h:{
      i:"hello"
    }
  },
  j: [1,2,3],
  k: ["foo", "bar"],
  l:["foo",1,true],
  m:[{n:10, o:"food", p:true }, {n:11, o:"foog", p:true }],
  q:null,
  r:undefined
};

let boolDefault = false;
let stringDefault = "";
let numberDefault = 0;

console.log(object1);
//document.write("<pre>");
//document.write(JSON.stringify(object1))
//document.write("<hr />");
cleanObject(object1);
console.log(object1);
//document.write(JSON.stringify(object1));
//document.write("</pre>");

function cleanObject(o) {
  for (let [key, value] of Object.entries(o)) {
    let propType = typeof(o[key]);

    //console.log(key, value, propType);

    switch (propType) {
      case "number" :
        o[key] = numberDefault;
        break;

      case "string":
        o[key] = stringDefault;
        break;

      case "boolean":
        o[key] = boolDefault;    
        break;

      case "undefined":
        o[key] = undefined;   
        break;

      default:
        if(value === null) {
            continue;
        }

        cleanObject(o[key]);
        break;
    }
  }
}

// EXPECTED OUTPUT
// Object { a: "somestring", b: 42, c: true, d: Object { e: 1, f: 2, g: true, h: Object { i: "hello" } }, j: Array [1, 2, 3], k: Array ["foo", "bar"], l: Array ["foo", 1, true], m: Array [Object { n: 10, o: "food", p: true }, Object { n: 11, o: "foog", p: true }], q: null, r: undefined }
// Object { a: "", b: 0, c: undefined, d: Object { e: 0, f: 0, g: undefined, h: Object { i: "" } }, j: Array [0, 0, 0], k: Array ["", ""], l: Array ["", 0, undefined], m: Array [Object { n: 0, o: "", p: undefined }, Object { n: 0, o: "", p: undefined }], q: null, r: undefined }