Garbage collection mechanism

Garbage collection

js With automatic garbage collection mechanism , There is no need to manually clear

Clearly marked

principle ： When js When declaring a variable in , Mark variables as “ Enter the environment ”, Then the variable occupies a position in memory , When the variable is executed , It will be marked as “ Leaving the environment ”js The garbage collection mechanism detected “ Leaving the environment ” Will automatically recycle

This recycling method is commonly used in standard browsers , But the time interval is different

Reference count

principle ：js It will track the number of references of each variable , When variables are declared , And assign a value to the variable , Then the reference count will be labeled 1, If the variable execution element or has been assigned , Then the reference count is added 1, contrary , Assign variables to other variables , Or no more operations , Then the number of times is reduced 1, Until the number becomes 0, Recycle and destroy

If a circular reference occurs ,a call b,b call a, Then the memory will not be released , Prone to memory leaks

The difference between memory leak and overflow

Memory leak ： Dynamically allocate space to memory , After use , No release , Until the end of the program

out of memory ： Regardless of the data size allocated by the stack , Write too much data to memory , Cause the data to cross the boundary

Stack and heap destruction

Stack memory

Global variables ： Only when the browser is closed will it be recycled

local variable ： Only those defined in the function are local variables , Function will produce its own scope , When the function is finished ,js The memory mechanism will automatically release

Heap memory

Object or function opens up space in heap memory , Heap memory will generate a reference address , If a code references this address , Then the object will not be destroyed .

If you want to destroy , You need to set the reference to null that will do

for example ：

  varx=new Array()

x=null// Destroyed

Special cases of not being destroyed

1. Function execution time , Returned an object , And call... Outside the function , Private variables will not be destroyed

 function fun(){// Extend scope chain

            var x=[1,2,3]

            return x

        }

        var arr=fun()

        console.log(arr)// Arrays can be accessed within functions , Will not be destroyed

1. In a private scope , to dom Element binding events , This private scope is not destroyed

var btn=document.getElementById("btn")

            btn.οnclick=function(){

               var num=11

                alert(num)

            }

1. Closure ( Special scope )

Closures are functions that have access to private variables inside other functions , It can be understood as function nesting function .

The following characteristics must be met , Be short of one cannot ：

1. Function nested function
2. Internal functions access variables of external functions
3. Variables are not recycled by the garbage mechanism

for example ：

function fun(){

                  var a=22

                  console.log("fun")

               return  function (){

var b=1

  return ++a+(++b)

            }

      }

             var f=fun()

             var v2=f()

             console.log(v2)// Output 14

             var v3=f()

             console.log(v3)// Output 15

Be careful :fun Only once ,a Not destroyed , Closure execution multiple selection ,b Each execution is reassigned to 1

The function of closures ：

1. You can simulate private methods
2. Used to implement the encapsulation of objects
3. You can access the cache with closures ( There is a local ), When code execution takes too long , You can read from the cache first