Com uma matriz JavaScript, posso redefini-la para um estado vazio com uma única atribuição:

array.length = 0;

Isso faz com que o Array "pareça" vazio e pronto para reutilização, e até onde eu entendo é uma "operação" única - ou seja, tempo constante.

Existe uma maneira semelhante de limpar um objeto JS? Eu sei que posso iterar seus campos excluindo-os:

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

mas isso tem complexidade linear.

Também posso jogar o objeto fora e criar um novo:

obj = {};

Mas a criação "promíscuo" de novos objetos leva a problemas com a Coleta de Lixo no IE6. ( Como descrito aqui )

A resposta curta para sua pergunta, eu acho, é não (você pode apenas criar um novo objeto).

1. Neste exemplo, acredito que definir o comprimento como 0 ainda deixa todos os elementos para coleta de lixo.

2. Você pode adicionar isso ao Object.prototype se for algo que você usaria com frequência. Sim, é linear em complexidade, mas qualquer coisa que não faça coleta de lixo mais tarde será.

3. essa é a melhor solução. Sei que não está relacionado à sua pergunta - mas por quanto tempo precisamos continuar apoiando o IE6? Existem muitas campanhas para interromper o uso dela.

Fique à vontade para me corrigir se houver algo incorreto acima.

Bem, correndo o risco de facilitar as coisas ...

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

... parece ser bastante eficaz na limpeza do objeto em uma linha de código com um mínimo de colchetes assustadores. Todos os membros serão realmente excluídos em vez de deixados como lixo.

Obviamente, se você deseja excluir o objeto em si, ainda precisará fazer um delete () separado para isso.

ES5

A solução ES5 pode ser:

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

ES6

E a solução ES6 pode ser:

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

atuação

Independentemente das especificações, as soluções mais rápidas serão geralmente:

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

A razão pela qual for..indeve ser realizada apenas em objetos rasos ou simples é que ela percorre as propriedades herdadas prototipicamente, não apenas as propriedades próprias que podem ser excluídas. No caso, não se sabe ao certo que um objeto é simples e propriedades são enumeráveis, forcom Object.getOwnPropertyNamesé uma escolha melhor.

Você pode tentar isso. A função abaixo define todos os valores das propriedades do objeto como indefinidos. Funciona bem com objetos aninhados.

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

Então, para recapitular sua pergunta: você deseja evitar, tanto quanto possível, problemas com o bug do IE6 GC. Esse bug tem duas causas:

1. A coleta de lixo ocorre uma vez a cada tantas alocações ; portanto, quanto mais alocações você fizer, mais frequentemente o GC será executado;
2. Quanto mais objetos você tiver 'no ar', mais tempo cada corrida de Coleta de Lixo demora (pois ela percorre toda a lista de objetos para ver quais estão marcados como lixo).

A solução para causar 1 parece ser: mantenha o número de alocações baixo; atribua novos objetos e cadeias o mínimo possível.

A solução para causar 2 parece ser: mantenha o número de objetos "vivos" baixos; exclua suas strings e objetos assim que não precisar mais deles e crie-os novamente quando necessário.

Até certo ponto, essas soluções são contraditórias: manter baixo o número de objetos na memória exigirá mais alocações e desalocações. Por outro lado, reutilizar constantemente os mesmos objetos pode significar manter mais objetos na memória do que o estritamente necessário.

Agora a sua pergunta. Se você redefinirá um objeto criando um novo ou excluindo todas as suas propriedades: isso dependerá do que você deseja fazer com ele posteriormente.

Você provavelmente desejará atribuir novas propriedades a ele:

• Se você fizer isso imediatamente, sugiro atribuir as novas propriedades imediatamente e pular a exclusão ou a limpeza primeiro. (Certifique-se de que todas as propriedades sejam substituídas ou excluídas!)
• Se o objeto não for usado imediatamente, mas será repovoado em algum estágio posterior, sugiro excluí-lo ou atribuí-lo nulo e criar um novo posteriormente.

Não existe uma maneira rápida e fácil de limpar um objeto JScript para reutilização como se fosse um novo objeto - sem criar um novo. O que significa que a resposta curta para sua pergunta é 'Não', como jthompson diz.

Algo novo para se pensar em aguardar Object.observe no ES7 e com a ligação de dados em geral. Considerar:

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

Portanto, nessa circunstância 2, pode ser a melhor escolha.

Você pode excluir os objetos, mas não as variáveis. delete abc;é inválido no ES5 (e lança com o uso strict).

Você pode atribuí-lo a null para configurá-lo para exclusão no GC (isso não acontecerá se você tiver outras referências a propriedades)

Definir lengthpropriedade em um objeto não altera nada. (apenas define a propriedade)

Isso me incomodou por muito tempo, então aqui está minha versão, pois eu não queria um objeto vazio, queria um com todas as propriedades, mas redefinii para algum valor padrão. Como uma nova instanciação de uma classe.

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 }