ด้วย JavaScript Array ฉันสามารถรีเซ็ตเป็นสถานะว่างด้วยการมอบหมายครั้งเดียว:

array.length = 0;

สิ่งนี้ทำให้ Array "ปรากฏ" ว่างเปล่าและพร้อมที่จะนำมาใช้ใหม่และเท่าที่ฉันเข้าใจคือ "การดำเนินการ" เดียว - นั่นคือเวลาคงที่

มีวิธีที่คล้ายกันเพื่อล้างวัตถุ JS หรือไม่ ฉันรู้ว่าฉันสามารถย้ำฟิลด์ของมันเพื่อลบพวกเขา:

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

แต่นี่มีความซับซ้อนเชิงเส้น

ฉันยังสามารถโยนวัตถุออกไปและสร้างวัตถุใหม่ได้:

obj = {};

แต่การสร้าง "ใหม่" ของวัตถุใหม่จะทำให้เกิดปัญหากับ Garbage Collection ใน IE6 ( ตามที่อธิบายไว้ที่นี่ )

ฉันคิดว่าคำตอบสั้น ๆ สำหรับคำถามของคุณไม่ใช่ (คุณสามารถสร้างวัตถุใหม่ได้)

1. ในตัวอย่างนี้ฉันเชื่อว่าการตั้งค่าความยาวเป็น 0 ยังคงทิ้งองค์ประกอบทั้งหมดไว้สำหรับการรวบรวมขยะ

2. คุณสามารถเพิ่มสิ่งนี้ลงใน Object.prototype ถ้าเป็นสิ่งที่คุณใช้บ่อย ใช่มันเป็นเชิงเส้นในความซับซ้อน แต่สิ่งใดก็ตามที่ไม่ทำเก็บรวบรวมขยะในภายหลังจะเป็น

3. นี่คือทางออกที่ดีที่สุด ฉันรู้ว่ามันไม่เกี่ยวข้องกับคำถามของคุณ - แต่เราต้องสนับสนุน IE6 ต่อไปอีกนานแค่ไหน? มีหลายแคมเปญที่จะยุติการใช้งาน

อย่าลังเลที่จะแก้ไขฉันหากมีสิ่งใดที่ไม่ถูกต้องด้านบน

ความเสี่ยงของการทำสิ่งต่าง ๆ ง่ายเกินไป ...

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

... ดูเหมือนว่าจะมีประสิทธิภาพในการทำความสะอาดวัตถุในโค้ดหนึ่งบรรทัดโดยมีวงเล็บน่ากลัวน้อยที่สุด สมาชิกทั้งหมดจะถูกลบอย่างแท้จริงแทนที่จะเป็นขยะ

เห็นได้ชัดว่าหากคุณต้องการลบวัตถุเองคุณจะต้องทำการลบ () แยกต่างหากสำหรับสิ่งนั้น

ES5

โซลูชัน ES5 สามารถ:

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

ES6

และโซลูชั่น ES6 สามารถ:

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

ประสิทธิภาพ

การแก้ปัญหาที่รวดเร็วที่สุดโดยทั่วไปจะเป็น:

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

เหตุผลที่for..inควรดำเนินการเฉพาะกับวัตถุที่ตื้นหรือธรรมดาก็คือมันผ่านคุณสมบัติที่ได้รับมาจากต้นแบบไม่ใช่แค่คุณสมบัติของตัวเองที่สามารถลบได้ ในกรณีที่ไม่ทราบว่าวัตถุนั้นเป็นวัตถุธรรมดาและมีคุณสมบัติมากมายforพร้อมด้วยObject.getOwnPropertyNamesเป็นตัวเลือกที่ดีกว่า

คุณสามารถลองสิ่งนี้ ฟังก์ชั่นด้านล่างตั้งค่าทั้งหมดของคุณสมบัติของวัตถุเป็นไม่ได้กำหนด ทำงานได้ดีกับวัตถุที่ซ้อนกัน

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

เพื่อสรุปคำถามของคุณ: คุณต้องการหลีกเลี่ยงปัญหา IE6 GC มากที่สุดเท่าที่จะทำได้ จุดบกพร่องนั้นมีสองสาเหตุ:

1. การเก็บขยะมูลฝอยเกิดขึ้นหนึ่งครั้งในทุกจำนวนมากดังนั้นการจัดสรร ; ดังนั้นยิ่งคุณจัดสรรจัดสรรมากเท่าใด GC oftener จะทำงาน
2. ยิ่งคุณมีวัตถุ 'ลอยอยู่ในอากาศ' มากเท่าไหร่เวลาของการรวบรวมขยะก็จะยิ่งมากขึ้นเท่านั้น

วิธีแก้ปัญหาสำหรับสาเหตุที่ 1 น่าจะเป็น: รักษาจำนวนการจัดสรรลง กำหนดวัตถุและสตริงใหม่ให้น้อยที่สุด

วิธีแก้ปัญหาที่ทำให้ 2 ดูเหมือนจะเป็น: รักษาจำนวนวัตถุ 'สด' ลง; ลบสตริงและวัตถุของคุณทันทีที่คุณไม่ต้องการอีกต่อไปและสร้างพวกเขาอีกครั้งเมื่อจำเป็น

ในระดับหนึ่งการแก้ปัญหาเหล่านี้ขัดแย้งกัน: เพื่อให้จำนวนวัตถุในหน่วยความจำเหลือน้อยจะทำให้เกิดการจัดสรรและยกเลิกการจัดสรรมากขึ้น ในทางกลับกันการนำวัตถุเดิมมาใช้ซ้ำอาจหมายถึงการเก็บรักษาวัตถุไว้ในหน่วยความจำมากกว่าที่จำเป็นอย่างเคร่งครัด

ตอนนี้สำหรับคำถามของคุณ ไม่ว่าคุณจะรีเซ็ตวัตถุโดยการสร้างขึ้นใหม่หรือลบคุณสมบัติทั้งหมด: ขึ้นอยู่กับสิ่งที่คุณต้องการจะทำในภายหลัง

คุณอาจต้องการกำหนดคุณสมบัติใหม่ให้:

• หากคุณทำทันทีฉันแนะนำให้กำหนดคุณสมบัติใหม่ทันทีและข้ามการลบหรือล้างข้อมูลก่อน (ตรวจสอบให้แน่ใจว่าคุณสมบัติทั้งหมดเขียนทับหรือลบ แต่!)
• หากวัตถุจะไม่ถูกใช้งานทันที แต่จะได้รับการ repopulated ในระยะต่อมาฉันแนะนำให้ลบหรือกำหนดให้เป็นโมฆะและสร้างใหม่ในภายหลัง

ไม่มีวิธีที่รวดเร็วและใช้งานง่ายในการล้างวัตถุ JScript เพื่อนำมาใช้ใหม่ราวกับว่าเป็นวัตถุใหม่ - โดยไม่ต้องสร้างใหม่ ซึ่งหมายความว่าคำตอบสั้น ๆ สำหรับคำถามของคุณคือ 'ไม่' อย่างที่ jthompson พูด

สิ่งใหม่ที่คิดเกี่ยวกับการรอคอยที่จะ Object.observe ใน ES7 และมีผลผูกพันข้อมูลโดยทั่วไป พิจารณา:

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

ดังนั้นภายใต้สถานการณ์ # 2 จึงเป็นตัวเลือกที่ดีที่สุด

คุณสามารถลบอุปกรณ์ประกอบฉาก แต่ไม่ต้องลบตัวแปร delete abc;ไม่ถูกต้องใน ES5 (และใช้งานอย่างเข้มงวด)

คุณสามารถกำหนดให้เป็นโมฆะเพื่อตั้งค่าการลบให้กับ GC (ไม่ใช่หากคุณมีการอ้างอิงอื่น ๆ ถึงคุณสมบัติ)

การตั้งค่าlengthคุณสมบัติบนวัตถุจะไม่เปลี่ยนแปลงอะไร (มันเท่านั้นดีตั้งค่าคุณสมบัติ)

สิ่งนี้ทำให้ฉันมีอายุนานขึ้นดังนั้นนี่คือรุ่นของฉันเนื่องจากฉันไม่ต้องการวัตถุที่ว่างเปล่าฉันต้องการสิ่งที่มีคุณสมบัติทั้งหมด แต่รีเซ็ตเป็นค่าเริ่มต้นบางอย่าง ชนิดของอินสแตนซ์ใหม่ของคลาส

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 }