第八章：Javascript函数

             //定义javascript函数
             //输出o的每个属性的名称和值，返回undefined
            function printprops(o) {
                for (p in o)
                    console.log(p + ":" + o[p] + "\n")
            }

             //计算两个迪卡尔坐标（x1,y1）和(x2,y2)之间的距离
            function distance(x1, y1, x2, y2) {
                var dx = x2 - x1;
                var dy = y2 - y1;
                return Math.sqrt(dx * dx + dy * dy)
            }

             //计算递归函数（调用自身的函数）
             //x!的值是从x到x递减（步长为1）的值的累乘
            function factorial(x) {
                if (x <= 1) return 1;
                return x * factorial(x - 1);
            }

             //这个函数表达式定义了一个函数用来求传入参数的平方
             //注意我们把它赋值了给一个变量
            var square = function(x) {
                return x * x
            }

             //函数表达式可以包含名称，这在递归时很有用
            var f = function fact(x) {
                if (x <= 1) return 1;
                else return x * fact(x - 1);
            };
             //f(7)=>5040

             //函数表达式也可以作为参数传给其它函数
            data.sort(function(a, b) {
                return a - b;
            });

             //函数表达式有时定义后立即使用
            var tensquared = (function(x) {
                return x * x;
            }(10))

            function hyuse(a, b) {
                function square(x) {
                    return x * x
                }
                return Math.sqrt(square(a) + square(b));
            }

            printprops({x: 1});
            var total = distance(0,0,2,1) + distance(2,2,3,5);
            var probality = factorial(5)/factorial(13);

             //定义并调用一个函数来确定当前脚本运行是否为严格模式
            var strict = (function() {return !this;}())

            o.m = f;

            o.m()

            o.m(x,y)

            var calcul = { //对象直接量
                oprand1: 1,
                oprand2: 1,
                add: function() {
                    //注意this关键字的用法，this指带当前对象
                    return this.result = this.oprand1 + this.oprand2;
                }
            };
            calcul.add(); //这个方法调用计算1+1的结果
            calcul.result; //=>2

        o["m"](x,y) //o.m(x,y)的另外一种写法
        a[0](z)//同样是一个方法调用(这里假设a[0]是一个函数)

            customer.surname.toUpperCase(); //调用customer.surname方法
            f().m(); //在f()调用结束后继续调用返回值中的方法m()

            rect.setSize(windth, height);
            setrectSize(rect, width, heigth);

    方法链
当方法的返回值是一个对象，这个对象还可以再调用它的方法。这种方法调用序列中（通常称为“链”或者“级联”）每次的调用结果都是另外一个表达式组成部分。比如基于jQuery（19章会讲到），我们常这样写代码：
        //找到所有的header，取得他们的id的映射，转换为数组并给它们进行排序
        $(":header").map(function(){return this.id}).get().sort();
当方法并不需要返回值时，最好直接返回this。如果在设计的API中一直采用这种方式(每个方法都返回this),使用API就可以进行“链式调用”风格的编程，在这种编程风格中，只要指定一次要调用的对象即可。余下的方法都看一基于此进行调用：
        shape.setX(100).setY(100).setSize(50).setOutline("red").setFill("blue").draw();

            var o = { //对象o
                m: function() { //对象中的方法m()
                    var self = this; //将this的值保存在一个变量中
                    console.log(this === o); //输出true，this就是这个对象o
                    f(); //调用辅助函数f()

                    function f() { //定义一个嵌套函数f()
                        console.log(this === o); //"false":this的值是全局对象undefied
                        console.log(self === o); //"true": slef指外部函数this的值
                    }
                }
            };
            o.m();//调用对象o的方法m

            var o = Object();
            var o = Object;

            var xx = {x: 1,y: 2,z: 3};
            var zz = []
                //将对象o中的可枚举属性名追加到数组a中，并返回这个数组a
                //如果省略a，则创建一个新数组并返回这个新数组

            function getPropertyNames(o, /*optional*/ a) {
                if (a === undefined) a = []; //如果a未定义，则使用新数组
                for (var property in o) a.push(property);
                return a;
            }

             //这个函数调用时可以使用两个实参
            getPropertyNames(xx); //将o的属性存储到一个新的数组中
            getPropertyNames(xx, zz); //将p的属性追加到数组a中

            a = a || [];

            function f(x, y, z) {
                //首先验证传入实参的个数是否正确
                if (arguments.leng != 3) {
                    throw new Error("function f() called with" + arguments.length + "arguments,but it ecxpects 3 arguments");
                }
                //再执行函数的其它逻辑
            }

            function max( /*...*/ ) {
                var max = Number.NEGATIVE_INFINITY;
                //遍历实参，查找并记住最大值
                for (var i = 0; i < arguments.length; i++)
                    if (arguments[i] > max) max = arguments[i];
                    //返回最大值
                return max;
            }
            max(1, 10, 222, 100); //=>222

            function f(x) {
                console.log(x); //输出实参的初始值
                arguments[0] = null; //修改实参组的元素同样会修改x的内容
                console.log(x); //输“null”
            }
            f(11);

            var factorial = function(x) {
                if (x <= 1) return 1;
                return x * arguments.callee(x - 1);
            }

             //将原始值数组的length元素复制至目标数组
             //开始复制原始数组的from_start元素
             //并且将其复制到目标数组to_start中
             //要记住实现的顺序并不容易
            function arrayCopy( /*array*/ from, /*index*/ from_start, /*array*/ to, /*index*/ to_start, /*integer*/ length) {
                    //逻辑
                }
                //这个版本的实现效率有些低，但你不必再记住实参的顺序
                //并且from_start和to_start都默认为0

            function easyCopy(args) {
                    arrayCopy(args.form,
                        args.form_start || 0, //注意，这里设置了默认值
                        args.to,
                        args.to_start || 0, args.length);
                }
                //来看如何调用easyCopy
            var a = [1, 2, 3, 4],
                b = [];
            easyCopy({
                from: a,
                to: b,
                length: 4
            });

            function max( /* number*/ ) { /*代码*/ }

             //判定o是否是一个类数组对象
             //字符串和函数都length属性，但是他们可以有typeOf检测将其排除
             //在客户端javascript中，DOM文本节点也有length属性，需要用额外的o.nodetype != 3将其排除
            function isArrayLike(o) {
                if (o && //o非null、undefined等
                    typeof o === "object" && //o是对象
                    isFinite(o.length) && //o.length是有限数
                    o.length >= o && //o.length是非负数
                    o.length === Math.floor(o.length) && //o.length是整数
                    o.length < 4294967296) //o.length < 2^32
                    return true;
                else
                    return fasle; //否则它不是
            }

             //返回数组（或类数组对象）a的元素累加和
             //数组a中必须为数字/ null undefined的元素都将忽略
            function sum(a) {
                if (isArrayLike(a)) {
                    var total = 0;
                    for (var i = 0; i < a.length; i++) { //遍历所有元素
                        var element = a[i];
                        if (element == null) continue; //跳过null和undefiend
                        if (isFinite(element)) total += element;
                        else throw new Error("sum():elements must be a finte numbers");
                    }
                    return total;
                } else throw new Error("sun():arguments mustbe array-like")
            };
            
            a = [1,2,4,5,3,6,7];
            sum(a)

            function flexisum(a) {
                var total = 0;
                for (var i = 0; i < arguments.length; i++) {
                    var element = arguments[i],
                        n;
                    if (element == null) continue; //忽略null和undefined
                    if (isArray(element)) //如果实参是数组
                        n = flexisum.apply(this, element); //递归的计算累加和
                    else if (typeof element === "function") //否则，如果是函数...
                        n = Number(element()); //调用它并做类型抓换
                    else
                        n = Number(element); //直接做类型抓换
                    if (isNaN(n)) //如果无法转换为数字，则抛出异常
                        throw Error("flexisum():can nont convent" + element + "to number");
                    total += n; //否则，将n累加到total
                }
                return total;
            }