JavaScript CollectGarbage Function Example

First, let's look at an example of memory release:

<SCRIPT LANGUAGE="JavaScript">
<!--
strTest = "1";
for ( var i = 0; i < 25; i ++ )
{
 strTest += strTest;
}
alert(strTest);
delete strTest;
CollectGarbage();
//-->
</SCRIPT>

CollectGarbage is a unique property of IE, which is used to release memory. The usage should be to set the variable or reference object to null or delete, and then release it. Before doing CollectGarbage, two necessary conditions must be clear:

- An object becomes invalid outside of the context in which it lives.
- A global object will become invalid if it is not used (referenced).

//---------------------------------------------------------
// When does the JavaScript object become invalid//---------------------------------------------------------


function testObject() {
var _obj1 = new Object();
}

function testObject2() {
var _obj2 = new Object();
return _obj2;
}

// Example 1
testObject();

// Example 2
testObject2()

// Example 3
var obj3 = testObject2();
obj3 = null;

// Example 4
var obj4 = testObject2();
var arr = [obj4];
obj3 = null;
arr = [];

In these four examples:

- "Example 1" constructs _obj1 in the function testObject(), but when the function exits,
It has left the context of the function, so _obj1 is invalid;

- In "Example 2", an object _obj2 is also constructed and passed out in testObject2(), so the object has a context environment (and life cycle) "outside the function". However, since the return value of the function is not "held" by other variables, _obj2 is immediately invalidated;

- In "Example 3", _obj2 constructed by testObject2() is used by the external variable obj3.
At this time, until the line of code "obj3 = null" takes effect, _obj2 will become invalid because the reference relationship disappears.

- For the same reason as in Example 3, _obj2 in Example 4 becomes invalid after the line "arr = []".

However, the "invalidation" of an object does not mean it will be "released". Inside the JavaScript runtime, there is no way to tell the user exactly when an object will be released. This relies on JavaScript
Memory recycling mechanism. ——This strategy is similar to the recycling mechanism in .NET.

In the previous Excel operation sample code, the owner of the object, that is, the process "EXCEL.EXE", can only occur after the "ActiveX Object instance is released". The file lock and operating system permission credentials are related to the process. So if the object is only "invalidated" instead of "released",
This will cause problems for other processes handling files and referencing the operating system's permission credentials.

——Some people say this is a bug in JavaScript or COM mechanism. Actually, it is not. This is OS and IE.
This is caused by a complex relationship between javascript and JavaScript, rather than being an independent problem.

Microsoft has disclosed a strategy to solve this problem: proactively calling the memory recycling process.

In (Microsoft's) JScript, a CollectGarbage() procedure (usually referred to as the GC procedure) is provided.
The GC process is used to clean up the "failed object instances" in the current IE, that is, the destruction process of the calling object.

The code to call the GC process in the above example is:

//---------------------------------------------------------
// When processing ActiveX Object, the standard calling method of GC process //---------------------------------------------------------

function writeXLS() {
//(slightly...)

excel.Quit();
excel = null;
setTimeout(CollectGarbage, 1);
}

The first line of code calls the excel.Quit() method to terminate the excel process and exit.
The environment holds the Excel object instance, so the Excel process is not actually terminated.

The second line of code makes excel null to clear the object reference, thus making the object "invalid". However, since the object is still in the function context, if the GC process is called directly, the object will still not be cleaned up.

The third line of code uses setTimeout() to call the CollectGarbage function, and the time interval is set to '1', which only makes the GC process occur after the writeXLS() function is executed. In this way, the Excel object satisfies the requirement of "being
There are two conditions for "GC cleanup": no references and leaving the context.

The use of the GC process is very effective in the JS environment using ActiveX Object. Some potential ActiveX
Object includes XML, VML, OWC (Office Web Component), flash, and even VBArray in JS.
From this point of view, since the ajax architecture uses XMLHTTP and at the same time meets the characteristic of "not switching pages", actively calling the GC process at the appropriate time will obtain better efficiency and UI experience.

In fact, even with the GC process, the excel problem mentioned above will still not be completely solved. Because IE also caches the permission credentials. The only way to update the page's credentials is to "switch to a new page".
Therefore, in fact, in the SPS project mentioned above, the method I used was not GC, but the following code:

//---------------------------------------------------------
//Page switching code used when processing ActiveX Object//---------------------------------------------------------

function writeXLS() {
//(slightly...)

excel.Quit();
excel = null;

// The following code is used to solve a BUG in IE call Excel, the method provided in MSDN:
// setTimeout(CollectGarbage, 1);
// Since the trusted state of the web page cannot be cleared (or synchronized), methods such as SaveAs() will be invalid the next time they are called.
location.reload();
}

The delete operator is described in the manual

References

Removes a property from an object, or an element from an array.

delete expression

The expression parameter is a valid JScript expression, usually a property name or array element.

illustrate

If the result of expression is an object, and the attribute specified in expression exists, and the object does not allow it to be deleted, then false is returned.

In all other cases, return true.

Finally, a supplementary note about GC: when the IE window is minimized, IE will actively call the CollectGarbage() function once. This will significantly improve memory usage after the IE window is minimized.

This is the end of this article about the detailed case of JavaScript CollectGarbage function. For more relevant js CollectGarbage function content, please search 123WORDPRESS.COM's previous articles or continue to browse the following related articles. I hope everyone will support 123WORDPRESS.COM in the future!