JavaScript学习之路<十>

js函数学习
       //简单的函数 无返回值类型
       //参数相当于入口 return 相当于出口

 function test(a,b){
    return a+b;
}
 alert(test(1,2)); //3

函数的返回类型是function
alert(typeof test);//function

function test1(a){
    		a();
  }
    	
function test2(){
    alert("执行了");
  }
 test1(test2);//执行了
或者：
test1(function(){alert("执行了");}

三种定义函数的方式：
1、function形式  优先解析 静态

function test1(){
}
//test1();

2、函数直接量形式  顺序解析 静态

var test2 = function(){}
//tset2();

3、构造函数式  动态

var test3 = new Function("a","b","return a+b;");
test3(10,20);

解析顺序：

test1();//1111
    	function test1(){
    		alert("11111");
    	}
    	
    	test2();//not found
    	var test2 = function(){
    		alert("22222");
    	};

//解析顺序demo
    	/*
    	 *首先页面加载时，所有function f()类型首先加载到内存,
    	 先加载1号函数，往下走，加载4号函数，覆盖掉1号函数，其他不加载，所以第一次alert时
    	调用的是4号函数，输出4
    	顺序执行2号函数，覆盖掉刚才的4号函数，输出2
    	顺序执行3号函数，覆盖掉刚才的2号函数，输出3
    	顺序执行4号函数，发现已加载，就不再继续加载，输出上一次的函数3
    	顺序执行5号函数，覆盖掉3号函数，输出5
    	顺序执行6号函数，覆盖掉5号函数，输出6
    	 */
    	function f(){return 1;}//1
    	alert(f());
    	var f = new Function("return 2;");//2
    	alert(f());
    	var f = function(){return 3;};//3
    	alert(f());
    	function f(){return 4;}//4
    	alert(f());
    	var f = new Function("return 5;");//5
    	alert(f());
    	var f = function(){return 6;};//6
    	alert(f());

3、作用域

//作用域
    	var k = 1;
    	function t1(){
    		var k = 2;
    		//function test(){return k;}  2 函数块作用域
    		//var test = function(){return k; };  2 函数块作用域
    		//var test = new Function("return k;"); 1 顶级作用域
    		alert(test());
    	}
    	t1();

二、js中的函数参数

//形参列表
    	//js中，函数的参数  ：形参和实参
    	function test(a,b,c,d){
    		//alert(test.length);//返回形参个数
    		//函数的实际参数 内部就是用一个数组去接收函数的实际参数
    		//arguments 对象可以访问函数的实际参数
    		//arguments 对象只能在函数的内部访问和使用
    		alert(arguments.length);
    		alert(arguments[0]);//拿到第一个实参值
    		alert(arguments[1]);//拿到第二个实参值
    		for(var i=0;i<arguments.length;i++){
    			alert(arguments[i]);
    		}
    		//判断形参个数和实际参数个数是否一致
    		if(arguments.callee.length == arguments.length){
    			return a + b;
    		}else{
    			return '参数不正确';
    		}
    	}
    	alert(test(10,20));

//arguments.callee实例 指向函数自身，主要用于递归
function fact(num){
    		if(num <= 1){
    			return 1;
    		}else{
    			return num*arguments.callee(num-1);
    		}
    	}

四、this对象

//this：指在运行时期基于执行环境所绑定的
		//this 总是指向调用者
		
		var k = 10;
		
		function test(){
			this.k = 20;
		}    	
		test();
		alert(test.k);//undefined
		alert(window.k);//20
		alert(k);//20

五、call和apply

//call 和   apply  简单的用法是用来绑定一些函数 用于传递参数  调用
		
		function sum(x,y){
			return x + y;
		}
		
		function call1(num1,num2){
			return sum.call(this, num1,num2);
		}
    	
    	function apply1(num1,num2){
    		return sum.apply(this,[num1,num2]);
    	}
    	
    	alert(call1(10,20));
    	alert(apply1(20,40));

//扩充作用域
		
		window.color = 'red';
		
		var obj = {color:'blue'};
		
		function showColor(){
			alert(this.color);
		}
		
		//showColor.call(this);//red
		
		//showColor.call(obj);//blue

//call方法的简单模拟和实现
		
		//function
		function test1(a,b){
			return a + b;
		}
		
		//自定义的对象  大写表示对象
		function Obj(x,y){
			this.x = x;
			this.y = y;
			return x * y;
		}
		
		var o = new Object(10,20);
		alert(test1.call(o,o.x,o.y));

六、垃圾收集机制和块级作用域的概念
在js中没有块级作用域的概念

function test(){
    		for(var i=0;i<5;i++){
    			alert(i);
    		}
    		alert(i);
    	}
    	test();

函数可以正确执行，最后输出i 为 5

为了避免这一现象的产生，需要在test中独立声明一个块级作用域，即：用括号括起来

function test(){
    		(function(){
    			for(var i=0;i<5;i++){
    				alert(i);
    			}
    		})();
    		alert(i);
    	}
    	test();

七、闭包

var name = "xiaoA";
    	var obj = {
    		name: "xiaoB",
    		getName: function(){
    			return function(){	
    				return this.name;
    			};
    		}
    	};
		alert(obj.getName()());//xiaoA

//闭包：一个函数可以访问另一个函数作用域中的变量
		//封闭性：private起到一个保护变量的作用
		
		function f(x){
			var temp = x;
			return function(x){
				temp += x;
				alert(temp);
			};
		}
		
		var a = f(50);
		
		a(5);//55