Cómo se recogen los cierres de JavaScript

Por lo que puedo decir, esto no es un error, sino el comportamiento esperado.

Desde la página de administración de memoria de Mozilla : "A partir de 2012, todos los navegadores modernos envían un recolector de basura de marcado y barrido. Limitación"": los objetos deben ser explícitamente inalcanzables".

En sus ejemplos donde falla some todavía es accesible en el cierre. Probé dos maneras de hacerlo inalcanzable y ambas funcionan. O bien se establece some=null cuando ya no lo necesita, o usted establece window.f_ = null; y se habrá ido.

Update

Lo he probado en Chrome 30, FF25, Opera 12 y IE10 en Windows.

El estándar no dice nada sobre la recolección de basura, pero da algunas pistas de lo que debería suceder.

• Sección 13 Definición de función, paso 4:"Sea closure el resultado de crear un nuevo objeto de función como se especifica en 13.2"
• Sección 13.2 "Un Entorno léxico especificado por Scope" (scope = cierre)
• Sección 10.2 Entornos léxicos:

" La referencia externa de un Entorno Léxico (interno) es una referencia al Entorno Léxico que lógicamente rodea el Ambiente Léxico interno.

Un entorno léxico externo puede, por supuesto, tener su propio entorno Entorno Léxico. Un Entorno Léxico puede servir como el entorno externo para múltiples Léxicos internos Ambiente. Por ejemplo, si una Declaración de función contiene dos Declaraciones de función anidadas entonces el Léxico Los entornos de cada una de las funciones anidadas tendrán como Entorno Léxico externo el Léxico Entorno de la ejecución actual de la función circundante."

Entonces, una función tendrá acceso al entorno del padre.

Por lo tanto, some debe estar disponible en el cierre de la función de retorno.

Entonces, ¿por qué no está siempre disponible?

Parece que Chrome y FF es lo suficientemente inteligente como para eliminar la variable en algunos casos, pero tanto en Opera como en IE la variable some está disponible en el cierre (NB: para ver esto establezca un punto de interrupción en return null y verifique el depurador).

El GC podría mejorarse para detectar si some se usa o no en las funciones, pero será complicado.

Un mal ejemplo:

var someClass = function() {};

function f() {
  var some = new someClass();
  return function(code) {
    console.log(eval(code));
  };
}

window.f_ = f();
window.f_('some');

En el ejemplo anterior, el GC no tiene forma de saber si la variable se usa o no (código probado y funciona en Chrome30, FF25, Opera 12 e IE10).

La memoria se libera si la referencia al objeto se rompe asignando otro valor a window.f_.

En mi opinión esto no es un error.

La heurística varía, pero una forma común de implementar este tipo de cosas es crear un registro de entorno para cada llamada a f() en su caso, y solo almacenar los locales de f que están realmente cerrados (por algún cierre) en ese registro de entorno. Entonces cualquier cierre creado en la llamada a f mantiene vivo el registro de entorno. Creo que así es como Firefox implementa cierres, al menos.

Esto tiene los beneficios de un acceso rápido a variables cerradas y simplicidad de aplicación. Tiene el inconveniente del efecto observado, donde un cierre de corta duración el cierre sobre alguna variable hace que se mantenga vivo por cierres de larga duración.

Uno podría intentar crear múltiples registros de entorno para diferentes cierres, dependiendo de lo que realmente cierran, pero eso puede complicarse muy rápidamente y puede causar problemas de rendimiento y memoria propios...

1. Mantener el estado entre llamadas a funciones Digamos que tienes la función add () y te gustaría que agregara todos los valores pasados en varias llamadas y devolviera la suma.

Como add (5); / / devuelve 5

Add (20); / / devuelve 25 (5+20)

Add (3); / / devuelve 28 (25 + 3)

De dos maneras se puede hacer esto primero es normal definir una variable global Por supuesto, puede usar una variable global para mantener el total. Pero ten en cuenta que este tipo te comerá vivo si (ab)usas globals.

Ahora la última forma usando closure con out define variable global

(function(){

  var addFn = function addFn(){

    var total = 0;
    return function(val){
      total += val;
      return total;
    }

  };

  var add = addFn();

  console.log(add(5));
  console.log(add(20));
  console.log(add(3));
  
}());

function Country(){
    console.log("makesure country call");	
   return function State(){
   
    var totalstate = 0;	
	
	if(totalstate==0){	
	
	console.log("makesure statecall");	
	return function(val){
      totalstate += val;	 
      console.log("hello:"+totalstate);
	   return totalstate;
    }	
	}else{
	 console.log("hey:"+totalstate);
	}
	 
  };  
};

var CA=Country();
 
 var ST=CA();
 ST(5); //we have add 5 state
 ST(6); //after few year we requare  have add new 6 state so total now 11
 ST(4);  // 15
 
 var CB=Country();
 var STB=CB();
 STB(5); //5
 STB(8); //13
 STB(3);  //16

 var CX=Country;
 var d=Country();
 console.log(CX);  //store as copy of country in CA
 console.log(d);  //store as return in country function in d

(function(){

   function addFn(){

    var total = 0;
	
	if(total==0){	
	return function(val){
      total += val;	 
      console.log("hello:"+total);
	   return total+9;
    }	
	}else{
	 console.log("hey:"+total);
	}
	 
  };

   var add = addFn();
   console.log(add);  
   

    var r= add(5);  //5
	console.log("r:"+r); //14 
	var r= add(20);  //25
	console.log("r:"+r); //34
	var r= add(10);  //35
	console.log("r:"+r);  //44
	
	
var addB = addFn();
	 var r= addB(6);  //6
	 var r= addB(4);  //10
	  var r= addB(19);  //29
    
  
}());