javascript面向对象一：函数

Arguments对象

<script type="text/javascript">
    /*
        Arguments对象:
         * 在Java中存在函数的重载现象.
            * 节省了函数的命名空间.
            * 降低了编码难度.
            * 性能较好.
         * 在javascript中也能实现函数的重载?
            * 不存在函数的重载.
            * 定义多个同名的函数时,只有最后一个是起作用.
         * Arguments对象的作用:
            * 在javascript中,函数定义没有任何参数,调用该函数时可以传递任意参数.
            * Arguments对象是数组对象.
            * Arguments对象的length属性:获取函数的实参的个数.
            * 利用Arguments对象特性,实现模拟函数的重载的效果.
     */
    function add(a, b){
        return a + b;
    }
    function add(a, b, c){
        return a + b + c ;
    }
    alert(add(1,2));    //output    NaN:表示当前值不是一个数字.isNan():返回Boolean,判断是否不是数字.
    alert(add(1,2,3))   //output    6
    function fn(){
        alert(arguments.length);
    }
    fn();               //output    0
    fn("a");            //output    1
    fn("a","b");        //output    2
    fn("a","b","c");    //output    3
    function add2(){
        if(arguments.length==2){
            return arguments[0] + arguments[1];
        }else if(arguments.length==3){
            return arguments[0] + arguments[1] + arguments[2];
        }
    }
    alert(add2(1,2));        //output    3
    alert(add2(1,2,3));      //output    6
</script>

变量的作用域

/*
    javascript中的变量作用域:
     * 全局变量:全局域+函数域.
     * 局部变量:当前函数域.
 */
var a = "a";
function fn(){
    var b = "b";
    alert(a);       //output    a
    alert(b);       //output    b
}
fn();
alert(a);           //output    a
alert(b);           //未输出

/*
   在javascript定义变量可以不使用"var".
   在定义局部变量时,没有使用"var":
    * javascript会自动将没有var的局部变量,定义为全局变量
   需要注意的是:
    * 依旧不建议大家这样编写代码.
 */
var a = "a";
function fn(){
    b = "b";
    alert(a);   //output    a
    alert(b);   //output    b
}
fn();
alert(a);       //output    a
alert(b);       //output    b

/*
   解读代码:
    * 定义一个全局变量a,并初始化为a.
    * 定义一个函数fn(),但该函数没有被调用(函数中的代码是不执行的)
      * 该函数中,定义了局部变量a,但没有初始化.
    * 调用函数fn(),执行该函数中的代码.
      * 第一次打印变量a,打印的是局部变量a.
      * 第二次打印变量a,打印的是局部变量a.
   javascript的特点:
    * javascript一次性定义代码中所有变量.
    * 全局变量与局部变量同名时,在函数域中:只能访问局部变量.
 */
var a = "a";
function fn(){
    alert(a);   //output    undefined
    var a = "b";
    alert(a);   //output    b
}
fn();
alert(a);       //output    a

特殊函数

/*
    匿名函数:没有名的函数
      * 定义函数的一种方式:var 函数名 = function(){}
      * 将匿名函数作为参数,传递给另一个函数.
      * 将匿名函数用来完成一次性任务.
    回调函数:
      * 将一个函数作为参数传递给另一个函数,而作为参数的函数,就叫做回调函数.
      * 将一个匿名函数作为参数传递给另一个函数,而作为参数的匿名函数,就叫做匿名回调函数.
 */
var one = function(){return 1;}
var two = function(){return 2;}
// 形参a, b是一个函数.
function fn(a, b){
    return a() + b();
}
alert(fn(one, two));        //output    3
// 将以上代码进行改写
alert(fn(function(){return 1;}, function(){return 2;}));    //output    3

/*
    什么是一次性:只能使用一次的.
      * 一次性函数:
        * 用来完成页面初始化工作的函数(不严格)
        * 定义即调用的函数(不严格)
        * 语法规定只能使用一次的.
      * 自调函数:
        * 第一个小括号:封装函数
        * 第二个小括号:调用函数
 */
(
    function(){
        alert("this is javascript.");
    }
)();
(
    function(str){
        alert(str + "this is javascript.");
    }
)("hello ");

/*
  内部(私有)函数:
     * 与Java中的内部类很相似.
     * 好处:保证了私有性.
     * 与局部变量的作用是一样的.
 */
function fn(){
    var a = "a";
    function n(){
        var b = "b";
        alert(a);
        alert(b);
    }
    n();
}
fn();//a    b

/*
   (了解)返回函数的函数(内部函数的一种特殊用法)
      * 定义一个函数,可以执行两个逻辑体
 */
function fn(){
    var a = "a";
    return function(){
        return a;
    }
}
alert(fn());        //output    function(){return a;}
alert(fn()());       //output    a

预定义函数