JS 函数

函数就是定义一次可以无限次调用和执行的一段JS代码。

下面简单说一下函数的创建及函数的使用。

        function testF(x) {  //testF 函数名   ，  x为参数
            return x * x;     //函数体，内容的处理
        }
        testF(5);     //函数的使用 


//函数直接量
        var testa = function (x) { return x * x; };  //这是一个未命名的函数，将它储存在一个变量之中。
        testa(5);

函数的参数，由于函数是宽松类型的，所以它没有办法声明所期望的参数类型，任何类型的参数传递都是合法的。

js本身不会检测参数的正确性，如果传递的参数比需要的多，则多余的会忽略，如果传递的参数比需要的少，则缺少的参数被赋予undefined值。

关于参数的检测，一般用typeof检测它的类型，防止出错。

在JS中有一个arguments对象，argument代表当前函数的参数数组。

        function arg() {
            var args = "";
            if (arguments.length > 0) {  //获取参数的总数
                for (var i = 0; i < arguments.length; i++) {
                    args += arguments[i];      //取出每个参数
                }
            } else {
                args = "没有参数";
            }
            alert(args);                   //输出参数
        }
        arg("sf", 22, 3, 4, 4, 5, 5, 6);      

同时我们也可以根据参数的数量，用arguments重载函数。

function hi(){
if(arguments.length==1){
    alert(arguments[0]);
}
else if(arguments.length==2){
    alert(arguments[0] + arguments[1]);
}
}

arguments.callee表示引用当前正在执行的函数，可以用来允许未命名的函数递归调用自身。

        function fn1(n,g,f,d,a) {
          // alert( fn1.length);
            if (n > 1) {
                return n * fn1(n - 1);     //实际运行是3*2*1
            }
            else {

                return 1;
            }
        }
        alert(fn1(3));    //输出6

        var a = function (x) {
            if (x > 1) { return x * arguments.callee(x - 1) }
            else { return 1 };
        }
       alert( a(3));     //输出6
   //上下两个函数是等效的，arguments.callee实际就是当前调用的函数

还可以将一个对象的属性用做参数传递

        function perso(age, name, sex) {
            alert(age + " " + name + " " + sex);
        }
        function addaa(args) {
            perso(args.age, args.name, args.sex);
        }
        var objt = { name: "qqj", age: "25", sex: "boy" };    //属性名要保持一致
        addaa(objt);

作为数据的函数。

将函数作为数据，在对象属性或者变量，或者函数参数之间传递。

        function add(x,y) {
            return x + y;
        }
        function all(fn1,a,b) {
           return fn1(a, b);
        }
        var total = all(add, 5, 6);    //add函数
        alert(total);

作为方法的函数，同样，函数可以作为一个对象的方法。

方法就是储存在一个对象内的属性中并且通过对象属性调用这个函数。

        var obj = {
            aa: 3,
            bb: 4,
            cc: function () {                             //函数作为一个对象的属性，又称是这个函数的方法
                this.total = this.aa + this.bb;
            }
        }
        obj.cc();
        alert(obj.total);           //输出7

构造函数

一般用于初始化一个对象的属性，要用NEW关键字声明。

        function obj2(a,b) {
            this.q = a;
            this.w = b;
            this.e = function () {
                alert(a + b);
            }
        }
        var obj3 = new obj2(2, 3);      //初始化对象的属性
        obj3.e();   //调用属性 输出5

函数有自己的属性和方法。

内置的length属性，是获取自己函数声明的形式参数的数量。它与arguments的length不同，arguments指的是实际传入的参数的数量。

同样我们也可以定义自己的函数的属性。整个函数可以使用，避免过多的全局变量定义。

        uniq.counter = 0;           //这是一个函数的属性   
        function uniq() {
            return uniq.counter++;
        }
       alert( uniq());

函数定义了两个方法call(),和apply().

它们的第一个参数都是要调用的对象，在函数体内这个参数的关键字是this的值。

call（）剩余的参数是函数要使用的参数的值，apply()剩余参数也是参数的值，不过是数组的形式。

        var obj5 = {};
        function fn(c,n) {
            this.color = c;
            this.num = n;
        }

        fn.apply(obj5, ["red", 6]);  //apply()方法这样就通过函数给对象添加属性。
        //fn.call(obj5, "red",6);  //call()方法这样就通过函数给对象添加属性。
        alert(obj5.color+obj5.num);