JS 函数总结

函数的定义

(1) 函数的声明：
function add(x, y) {
	return x + y;
}

(2)函数表达式
var add = function (i, j) {
	reutrn i + j;
}

(3)对象实例化（实际编程一般不会用），定义在全局。
var add = new Function ('i', 'j', "return (i + j)");

函数的属性：
　　prototype:add
　　constructor:function add(i, j)
　　__proto__ : Object, 来自于实例初始化的prototype

构造函数：
prototype是函数的专利，只有函数才有prototype属性。
构造函数与普通函数的区别
(1)本质上没有什么区别。
(2)构造函数通常会有this指定实例属性，原型对象上面通常有一些公用方法
(3)构造函数命名通常第一个字母大写。

函数的调用
(1)构造函数调用模式
　　var person1 = new Person('hg');
　　var person2 = new Person('wj');

(2)方法调用模式,就是调用对象的方法
　　person1.say();

(3)函数调用模式

例子（1）
    function aaa() {
        this.a = 1;
        alert(this + "  aaa  " + this.a);
        function bbb() {
            alert(this + "  bbb  " + this.a);
        }
        bbb();
    }

	//这里都可以弹出1. 因为 this.a = 1, 这个this ＝＝ window。所以a挂在window上面了。
    aaa();		//注意：两个this指向的都是window。

例子（2）
    //获取对象构造函数名称
    function type(obj) {
        return obj && obj.constructor && obj.constructor.toString().match(/functions*([^(]*)/)[1];
    }

    function AAA() {
        this.aa = 1;
        alert(this + "  aaa  " + this.aa);
        this.bbb = function () {
            alert(type(this));		//AAA
            alert(this + "  bbb  " + this.aa);
        }
    }


    var A = new AAA();		//[object Object]  aaa  1
    A.bbb();				//[object Object]  bbb  1
    alert(window.A.aa);		//1
    alert(window.aa);		//undefined

例子（3）

    //获取对象构造函数名称
    function type(obj) {
        return obj && obj.constructor && obj.constructor.toString().match(/functions*([^(]*)/)[1];
    }

    function AAA() {
        this.aa = 1;
        alert(this + "  aaa  " + this.aa);
        function bbb() {
            alert(type(this));      //Window
            alert(this + "  bbb  " + this.aa);
        }
        bbb();      //[object Window]  bbb  undefined
    }


    var A = new AAA();  //[object Object]  aaa  1
    // A.bbb(); 无法调用，因为是bbb局部函数，
    alert(window.A.aa);     //1
    alert(window.aa);       //undefined

 (4)apply,call调用模式

Function.prototype.apply；
apply是函数上面的方法。所有的函数都可以调用这个方法。

如果获取一个对象类型的函数：
　　Object.prototype.toString.apply(obj);

　　Object.prototype.toString.apply(1234); //number

apply是一个借用的功能。

　　A.apply(B, args); // B函数-->>借用-->>A函数. 操作参数args。

　　call(this, x, y); //call 后面的参数，分开传入，apply传入的是一个数组。

(5) bind方法！！！
var test = B.bind(A, argus);
test();
bind绑定了对象和参数。返回一个函数，需要的时候，执行就好了。

二，arguments

(1) Array-like
只是长得像数组，但不是数组，可以有arguments[index]
和arguments.length的方法，但其他数组方式无法使用。

function test(x, y, z) {
　　alert(type(arguments));　　//object
　　var args = Array.prototype.slice.apply(arguments);
　　alert(type(args));　　　　　//Array
}

test(1,3,4,5,6);
弹出： 第一个是Object对象，第二个是Array数组。

用这个把参数给转换为数组，也可以。
var args = Array.prototype.slice.apply(arguments);

(2) arguments.callee
指向函数本身. arguments.callee()；调用函数本身。
进行递归的方式。

	var hga = 3;
	function test(a) {
	    if (a != 0) {
	        alert(a);
	        a--;
	    }
	    else {
	        return ;
	    }

	    arguments.callee(a);
	}
	test(hga);

三，递归 

 不用arguments.callee();就要防止，函数名被篡改。

四，闭包:在函数中定义函数，而被定义的函数，调用了父函数中的变量。

(function() {
	var a = 0;
	function b() {
		a = 1;
		debugger;
	}
})();

闭包的使用场景：改变作用域，将函数的变量，变为私有变量。

 后期会专门写一篇关于闭包的问题。

五，First-class function.

 　　JS的函数，可以作为变量保存，可以作为参数传递，可以作为返回值返回。

(1)函数颗粒化。
	比如实现一个add(num1)(num2)(num3);的这种作用链调用的函数。
一个不定量，累加的。回调。

	function add(value) {
		
		var helper =  function (next) {
			value = typeof(value) === 'undefined' ? value : value + next;
			return helper;
		}

		helper.valueOf = function () {
			return value;
		}
		
		return helper;
	}

	console.log(add(1)(2)(3));

//实现方式是，首先在函数内定义一个函数，helper，判断传入的参数是否是undefined.
//如果是，value值就不变，如果不是，就更新value值。
//函数返回的是一个helper的函数。

(2)回调，做异步回调

在ajax中，在success返回成功时，做function（）

//封装了一个ajax的异步调用。
	function ajax.get(url, callback) {

		var createXHR = function () {
			var xhr;
			if (window.XMLHttpRequest) {
				xhr = new XMLHttpRequest();
			}
			else if (window.ActiveXObject) {
				xhr = new ActiveXObject('Microsoft.XMLHTTP');
			}
			return xhr;
		}
		var xhr = createXHR();
		if (xhr) {
			xhr.open('get', url, true);
			xhr.onreadystatechange = function () {
				if (xhr.readyState == 4) {
					if (xhr.status == 200) {
						callback.success(xhr);
					}
					else {
						callback.fail(xhr);
					}
				}
			}

			xhr.send(null);
		}

	}