javascript特性总结

arguments

   <script type="text/javascript">
        //函数在声明的时候没有“形参”，但是在调用的时候还给其传递参数
        //在函数内部有属性，我们可以通过这个属性获得函数的"实参"信息
        //arguments 属性
        //arguments是数组，下标0  1  2  3。。分别代表传递的参数信息
        //arguments通过length属性获得个数

        function getInfo(){
            var s1 = arguments[0];
            var s2 = arguments[1];
            //alert(s1+s2);
            //alert('hello world');
        }
        getInfo('xiaoming','beijing');
        getInfo("tom",23,'American');


        //在js里边没有函数"重载"
        //"函数重载"在java里边有存在，系统有同时存在多个函数，名字一样，参数个数或数据类型不一样
        //js是松散类型的程序语言，本身没有"重载"
        //但是我们可以利用arguments参数，使得函数使用有重载的效果
        /**
        getname(string addr,number num){}
        getname(number a, string b)
        */
        /*
        function f1(){
            //判断参数个数
            if(arguments.length==2){
                //其他逻辑
                alert("传递了两个参数，具体是"+arguments[0]+arguments[1]);
            } else if(arguments.length==1){
                //其他逻辑
                alert("传递了一个参数，具体是"+arguments[0]);
            } else {
                //其他逻辑
                alert("没有传递参数");   
            }
        }
        //f1('xiaoming',23);
        f1('xiaoming');
        f1();
        */

        //ECMAscript5 规定js里边的数组也是对象的一部分
        //arguments本身是一个对象，【对象里边有数组的成分】
        function f1(){
            console.log(arguments);
        }
        f1('dog','4');
        var fruit = ['apple','pear','banana'];
        console.log(fruit);

        </script>

callee

<script type="text/javascript">
        //函数实现n的阶乘
        //5的阶乘 = 5*4*3*2*1;
        //函数递归调用
        //通过arguments.callee是的程序有松耦合关系(不喜欢紧密耦合的程序)

	function jiecheng(n){
		if(n==1){
			return 1;
		} else {
			alert(typeof arguments.callee);		//function
			return n * arguments.callee(n-1);
		}
	}
	var cheng = jiecheng;
	//删除jiecheng变量
	jiecheng = null;
	alert(cheng(6));

        </script>

caller

 <script type="text/javascript">

        function cat(){
            //我想知道“我被谁调用”了 caller
            //caller，返回调用当前函数的函数【返回值是一个函数】
            //cat.caller.name 返回调用当前函数的函数名，主流浏览器使用
            alert(cat.caller.name);
            console.log("I am cat");
        }
        function pig(){
            cat();
            console.log("I am pig");
        }
        pig();

        function dog(){
            cat();
            console.log('I am dog');
        }
        dog()

        </script>

全局变量与局部变量

   <script type="text/javascript">
        //全局变量与局部变量

        //局部变量
        //在js里边定义局部变量,在函数内部使用“var”定义

        //全局变量
        //① 在js里边定义“全局变量”，在系统任何角落直接定义(不使用var关键字)
        //② 特殊情况，在函数外边通过var定义的变量也是“全局的”

        //在函数外边声明的var变量，相对于函数本身讲是有穿透力的(包括内部嵌套的函数也如此)

        var province = "河北";
        console.log(province);
        function cat(){
            //在函数内部定义的变量
            color = "white";        //全局
            var name = "kitty";     //是局部变量
            console.log(province);
        }
        //cat();
        //alert(color);   //访问全局变量

        function f1(){
            //以下name相对函数f2是全局的，相对函数f1是局部的
            var name = "xiaoming";
            function f2(){
                console.log(name);
                console.log(window.province);
            }
            f2();
        }
        window.f1();
        console.log(name);


        </script>

函数声明

 <script type="text/javascript">

        //普通函数声明和匿名函数声明有一点不同

        //普遍声明函数方式
        //普通方式是先编译函数，之后执行调用
        //① 先编译解析function
        //② 具体函数调用
        //f1();
        //function f1(){
        //    alert('普通函数声明方式');
        //}


        //匿名函数表达式
        //函数的名字是变量，对象
        // 没有函数提升一说，没有编译一说
        // 该方式函数调用 与 函数声明的关系是“平级关系”
        f2();
        var f2 = function(){
            alert("匿名函数声明使用");
        }
		//还有匿名函数 和 new Function()的声明方式
        </script>