Detailed explanation of Javascript closures and applications

<script>
			function person(){
				var name='marshal';
				function student(){ //Declare child function console.log(name);//reference the variable name in the parent function scope
				}
			}
			person(); //Function execution, generating closure </script>      

	<script>
			function person(){
				var name='marshal'; //When js executes this line, a closure is generated function student(){ //Declare child function console.log(name); //Reference variable name in parent function scope
				}
				student(); //Internal function is called in external function }
			person(); //Function execution, although the closure condition is met, no closure is generated </script>

<script>
			function person(){
				var name='marshal';
				function student(){
					console.log(name); //This method contains closure code }
				return student;
			}
			var p=person();//Because the sub-function object is created, the first closure is generated at this time, and the sub-function student is returned to p. Since p does not disappear, the variable name referenced by the sub-function is stored in the memory until p=null is recycled p();//Execute the closure code block of the sub-function and output "marhsal"
			p(); //Execute the closure code block of the subfunction for the second time and output "marhsal"
			person(); //The second sub-function is created to call the object. At this time, the second closure is generated, but the sub-function student code block is not executed. </script>

<script>
			function setTimeoutTest(message,time){
				setTimeout(function(){
					alert(message); //The nested child function references the parent function variable message, generating a closure }, time);
			}  
			setTimeoutTest('prompt message',1000);
		</script>

<script>
				function count(){
					var i=1;
					function add(){
						i++;
						console.log(i);
					}
					return add;
				}
				var c=count();//Production closure c();//2
				c();//3
				c();//4
		</script>

<script>
			function count(){
				var i=1;
				function add(){
					i++;
					console.log(i);
				}
				return add;
			}
			var c=count();
			c();//2
			c(); //3 i's life cycle is extended </script>

External js code out.js implements self-increment and self-decrement (function count(){
	var i=1;
	function add(){
		i++;
		console.log(i);
	}
	function subtract(){
		i--
		console.log(i);
	}
	window.count={
		add:add,
		subtract:subtract
	}
})();

Reference out.js code <script src=out.js></script>
		<script>
			count.add(); //2
			count.subtract(); //1
			count.subtract(); //0
		</script>

<script>
     var name="marshal"; //Create global variables var person={
		 name:"leo",
		 getName:function(){ //Return anonymous function return function(){ //Return this.name
				return this.name; //Return string }
		 }
	 };
	 alert(person.getName()()); // Output marshal, internal functions cannot directly access external function this
	 
</script>

<script>
	     var name="marshal";
			 var person = {
				 name:"leo",
				 getName:function(){
					 var that=this; //Save this to another variable that the closure can access return function(){
						return that.name;
					 }
				 }
			 };
			 alert(person.getName()()); //that points to person, not window
	</script>