第6章 JavaScript函数-优快云博客

本文详细介绍了JavaScript函数的各种定义方式，包括普通定义、变量定义及指针调用，并探讨了arguments对象、函数返回类型、构造函数、函数嵌套及this关键字的使用。通过具体示例，展示了如何在实际编程中灵活运用这些概念。

函数的普通定义方式：

function 函数名( [参数1, 参数2], 参数N] ] ] ]) {
    [语句组];
    [return [表达式] ];
}

<body>
<input id="text1", type="text" style="width: 84px" maxlength="20" />
+<input id="text2", type="text" style="width: 75px" maxlength="20" />
=<input id="text3", type="text" style="width: 69px" maxlength="20" />
<input id="button1" type="button" value="计算" onclick="Button1_onclic()">
<script type="text/javascript">
    function Sum(arg1, arg2) {
        var sarg1 = new String(arg1);
        var sarg2 = new String(arg2);
        if ((sarg1 == "") || (sarg2 == "")) {
            var e0 = new Error();
            if (sarg1 == "") {
                e0.message = "Sum函数参数非法，第1个参数为空";
            } else {
                e0.message = "Sum函数参数非法，第2个参数为空";
            }
            throw e0;
        }
        for (i = 0; i < sarg1.length; i++) {
            for (j = 0; j < 10; j++) {
                if ((sarg1.charAt(i)) == j) {
                    break;
                } else {
                    if (j == 9) {
                        var e1 = new Error();
                        e1.message = "Sum函数参数：" + sarg1 + "是非常数字！";
                        throw e1;
                    }
                }
            }
        }
        for (k = 0; k < sarg2.length; k++) {
            for (l = 0; l < 10; l++) {
                if ((sarg1.charAt(l)) == j) {
                    break;
                } else {
                    if (k == 9) {
                        var e2 = new Error();
                        e2.message = "Sum函数参数：" + sarg2 + "是非常数字！";
                        throw e2;
                    }
                }
            }
        }
        return Number(arg1) + Number(arg2);
    }
    function Button1_onclic() {
        try{
            var text1 = document.getElementById("text1");
            var text2 = document.getElementById("text2");
            var text3 = document.getElementById("text3");
            var sum = Sum(text1.value, text2.value);
            text3.value = sum;
        } catch (e) {
            alert(e.message);
            e = null; // 断开对错误对象的引用
        }
    }
</script>
</body>

函数的变量定义方式：

var 变量名 = new Function([参数1, [参数2, [参数N] ] ], [函数体]);
◆函数体：可选择项，一个字符串。相当于函数体内的程序语句序列

<script type="text/javascript">
    var cirularityArea = new Function("r", "return r*r*Math.PI");
    var R = 2;
    var area = cirularityArea(R);
    alert("半径为" + R + "的圆的面积为：" + area);
</script>

函数的指针调用方式：

通过指针来调用函数。回调函数按照调用者的约定实现函数的功能，由调用者调用。通常使用在自己定义功能而由第三方实现的场合。

<script type="text/javascript">
    function SortNumber(obj, func) {
        if(!(obj instanceof Array) || !(func instanceof Function)){
            var e = new Error();
            e.message = "参数无效";
            throw e;
        }
        for (n in obj) {
            for(m in obj) {
                if(func(obj[n], obj[m])){
                    var tmp = obj[n];
                    obj[n] = obj[m];
                    obj[m] = tmp;
                }
            }
        }
        return obj;
    }
    function greaterThan(arg1, arg2) {
        return arg1 > arg2;
    }
    try {
        var numAry = new Array(5, 8, 6, 32, 1, 45, 7, 25);
        document.write("<li>排序前：" + numAry);
        SortNumber(numAry, greaterThan);
        document.write("<li>排序后：" + numAry);
    } catch (e) {
        alert(e.message);
    }
</script>

arguments对象：

<script type="text/javascript">
    function sum(arg1, arg2) {
        var realArgAccount = arguments.length;
        var frmArgCount = sum.length;
        if (realArgAccount < frmArgCount) {
            var e = new Error();
            e.message = "实际参数个数不符合要求！";
            throw e;
        }
        return arguments[0] + arguments[1];
    }

    try {
        document.write("<p><h1>arguments对象测试</h1></p>");
        document.write("正确调用的结果：" + sum(10, 20));
        document.write("<br>不符合规则的调用结果：");
        document.write(sum(10));
    } catch (e) {
        alert(e.message);
    }
</script>

函数返回类型：值类型和引用类型

function sum(a, b) {
    return a + b;
}
var c = sum(1, 2); // 值类型
————————————————————————————————
function getNameList() {
    var List = new Array("Lily", "Petter", "Jetson");
    return List;
}
var nameList = getNameList(); // 引用类型
nameList = null; // 删除引用

构造函数：

<script type="text/javascript">
    function Employee(name, sex, adr) {
        this.name = name;// 姓名属性
        this.sex = sex;// 性别属性
        this.adr = adr;// 地址属性
        this.getName = getName;// 方法：获得雇员姓名
    }
    function getName() {// 定义一个普通函数作为Employee对象的方法
        return this.name;
    }
    var e = new Employee("sunsir", "男", "贵州贵阳");
    var n = e.getName();
    alert(n);
</script>

函数可以嵌套：要注意作用域

<script type="text/javascript">
    function a() {
        function b() {
            function c() {
                document.write("<li>C");
            }// end c()
            document.write("<li>B");
        }// end b()
        document.write("<li>A");
        b();
        try {
            c();// 尝试调用b的私有函数，将发生一个错误
        } catch (e) {
            alert(e.message);
        }
    }// end a()
    a();
</script>

使用this关键字：

this关键字引用运行上下文中的当前对象，JavaScript的函数调用通常发生于某一个对象的上下文中。如果尚未指定当前对象，则调用函数的默认当前对象是Global，使用call方法可以改变当前对象为指定的对象。

<script type="text/javascript">
    var chair = "公园的椅子";
    function TomHome() {
        this.chair = "汤姆家的椅子";
    }
    function useChair() {
        document.write("<li>此时使用的是：" + this.chair + "<br>");
    }
    var th = new TomHome();
    useChair();
    useChair.call(th);
</script>