js函数

函数

        function say(){}
            say()
        funciton run(){}
        Number()
        new Object()

调用函数

        js中，所有函数的内部结构都是一样的

普通函数：

            function say(){}
            Number()

构造函数

            new Object()


        函数就是一个对象

1.创建函数

1.函数字面量

                var say=function(){}

2.函数声明

                function say(){}

3.匿名函数

                (function(){})()                        

                function say(){
                     alert("hello-say---");
                 }

                 var run=function(){
                     alert("run-------");
                 }
                 say()
                 run()

4.解析顺序

        1.   优先解析函数的声明，然后解析使用var操作符声明的变量
        2.函数的参数	
            形式参数（形参）
            实际参数（实参）

              function enjoy(a,b){                        
                   console.log(a,b);
               }
                   enjoy(34,4,5,6,"hello");// 34,4
           function say(a,b){
               console.log(a+b);
           }
           say(1);

js中只要函数名相同，即为重写

                function say(){}
                function say(a,b){}
                say();

js中实际参数个数可以和形式参数个数不一致，数据类型也可以不一致，

2.函数的调用

            普通函数：
                     函数名()
            构造函数：
                    new 函数名()
            .call    可以改变this指向
            .apply

3.函数的内部属性

1.arguments:类数组对象

                    用来保存实际参数列表
                    length:实际参数的个数
                    callee:用来从函数内部指向函数本身

	                function enjoy(a,b){
	                //1.var a; var b;
	                console.log(arguments.length);     //输出个数 5 
	                console.log(arguments.callee); }//ƒ enjoy(a,b){
	                enjoy(34,4,5,6,"hello");         
	                //1.vara; var b;console.log(arguments.length);       
 //console.log(arguments.callee);  }   

2.this:

                    vi：兜底对象global
                    html：兜底对象window

                        函数赖以执行的环境对象
                    1.什么时候确定？
                        当拥有当前this的函数被调用的时候确定
                    2.指向
                        谁调用当前拥有this的函数，this指向谁

                                例子
                            		function say(){
                                        console.log(this);//window
                                    }

                                    say();//window.say()


                                    var obj={
                                        say:function(){
                                            console.log(this);
                                        }
                                    }

		                            obj.say();//obj

3. 形参

                        形式参数：
                                在声明函数时，写在function后的（）中
                        实际参数：
                                在调用函数时，写在函数名后（）中
                                js中没有重载概念，所有函数名相同的函数，均为重写
                                实际参数可以和形式参数的个数不一致 类型也可以随意

4.作为值的函数和作为返回值的函数

作为值：

                    function say(){//1001
                        console.log("hello");
                    }
                    function sayHello(fn){
                        //var fn;
                        //say->arguments[0]:1001->
                        //arguments[0]->fn
                        //fn:1001
                        
                        fn();   //俩个fn都是形参
                    } 

                    sayHello(say);//say为实参

作为返回值

                	function say(){
                    return function(){
                        console.log("hello");
                    }
                }

                var result=say();
                result();
                console.log(result);

5. 函数的属性

            say.length:形式参数个数
        函数的调用：
            this->指定函数内部this值
            call(this,实参列表)
            apply(this,[实参列表])

            prototype:原型对象

          		function say(a,b){                            
                      console.log(arguments);
                      console.log(this);
                  }
                  //say(1,2,3,4,5);
                  //say.call({},3,4,5);   //把this指向改为{}，给a赋值3，给b赋值4

                  var obj={
                      say:say
                  }

                  //obj.say.call(window,4,5,6);//把this指向改为window，给a赋值4，b赋值5
                  obj.say.apply([],[5,6,7,8]);//把this指向[]，把类数组对象给arguments
                  console.log(say.length);//打印形参个数2(a,b)