1 /*    函数的声明
  2
  3 //声明一个函数，没有参数和返回值
  4     function func(){
  5         alert('diao yong di shi hou zhi xin');
  6     }
  7     func();
  8
  9 //声明一个函数，带有两个参数，由于JS是弱类型的语言，故函数的参数时不需要使用var的
 10     function func(num1,num2){
 11         alert(num1+num2);
 12     }
 13     func(10,20);
 14
 15 //声明一个函数，带有两个参数和返回值，JS中返回值直接用return即可，函数名前不需要标注带有返回值
 16     function func(num1,num2){
 17         return num1+num2;
 18     }
 19     alert(func(10,20));//30
 20
 21 //可以把函数的返回值直接赋值给一个变量，然后直接操作变量
 22     function func(num1,num2){
 23         return num1+num2;
 24     }
 25     var a=func(10,20);
 26     alert(a);    //11
 27
 28 //return还有一个功能就是，结束函数的执行
 29     function func(num1,num2){
 30         if(num1>10){
 31             return 11;
 32         }
 33         return num1+num2;
 34     }
 35     alert(func(13,20));    //11
 36
 37 // JS 调用的时候传递的参数个数和函数原型中参数个数可以不一样
 38     function func(num1,num2){
 39         return num1+num2;
 40     }
 41
 42     alert(func(20,'ahc',9));
 43
 44 //ECMAScript 函数不介意传递进来多少参数，也不会因为参数不统一而错误。实际上，
 45 函数体内可以通过 arguments 对象来接收传递进来的参数，arguments 可以用数组来取值
 46     function func(){
 47         var res=0;
 48         for(var i=0;i<arguments.length;i++){
 49             res+=arguments[i]+" | ";
 50         }
 51         return res;
 52     }
 53
 54     alert(func(20,30,40));
 55
 56 // JS 中没有函数重载的说法，函数和变量等的调用都是就近原则
 57     function func(num1,num2){
 58         return num1+num2;
 59     }
 60     function func(num1){
 61         return num1;
 62     }
 63     alert(20,30);//20    执行的第二个函数，就近原则
 64
 65 //将一个函数的返回结果值作为另外一个函数的参数进行传递
 66     function sum(num1,num2){
 67         return num1+num2;
 68     }
 69
 70     function func(num1){
 71         return num1+10;
 72     }
 73     alert(sum(func(10),10));//30
 74
 75 //用变量初始化的方式声明一个函数，然后用变量名加参数列表来调用这个函数
 76 //这种声明方法，就是给变量名注册一个事件的形式
 77     var box=function(num1,num2){
 78         return num1+num2;
 79     }
 80     alert(box(10,10));//20
 81
 82 //使用析构函数来声明一个函数，但是这种方法效率低，因为会解析两次
 83 //第一次解析整个表达式(ECMAScript常规代码)，第二次就是解析传入构造函数中的字符串
 84 //用这种方式能够更好的理解函数是对象，函数名是一个指针的概念
 85     var box=new Function('num1','num2','return num1+num2');
 86     alert(box(10,10));20
 87
 88 */
 89
 90 /*
 91 //将一个函数作为结果返回    其实就相当于执行这个函数，然后把这个函数的返回值给返回
 92     function sum(num1,num2){
 93         return num1+num2;
 94     }
 95     function func(num1){
 96         return sum(num1,10);
 97     }
 98     alert(func(10));//20
 99
100 //Function类型其实也是一个对象，既然是对象，那也就具有和其他对象一样的属性方法等，
101 //其实函数名，也就是一个对象的变量，执行的是函数的地址，相当于一个指针
102 //将函数名当做一个参数传递给另外一个函数，
103     function sumFunc(num1,num2){
104         return num1+num2;
105     }
106     function func(sum,num1){
107         return sum(num1,10);
108     }
109     alert(func(sumFunc,10));//20
110
111 */
112
113 /*    函数的内部属性   arguments 和 this
114 //函数的递归
115     function box(num){
116         if(num<=1){
117             return 1;
118         }else{
119             return num*box(num-1);//自己调用自己
120         }
121     }
122     alert(box(3));//6
123
124 //arguments 是一个类数组，用来保存函数传递过来的参数，数组类型
125 //arguments.callee    是一arguments的一个属性，是一个指针变量，
126 //指向的是拥有这个argumens属性的函数，也就是说代表了他所在的这个函数本身
127 //用arguments.callee的好处是，当函数名改变了以后，不需要改动递归出的函数，
128     function box(num){
129         if(num<=1){
130             return 1;
131         }else{
132             return num*arguments.callee(num-1);
133             //arguments.callee代表的是函数的本身，故和上面是同样的效果
134         }
135     }
136     alert(box(3));//6
137
138 // this 对象代表的是对象的本身
139 // 和 C# 中的this差不多，C# 中的this代表的也是实例化的对象的本身
140 //默认情况下 this 带表的是window对象，window是JS中最大的一个对象
141 //从下面可以看出  在window对象下 this就等于window
142     alert(window);            //object Window
143     alert(typeof window);    //object
144     alert(this);            //object Window
145     alert(typeof this);        //onject
146
147     var color='hong se';    // color 是window的一个属性
148     alert(window.color);    //hong se    输出window的属性
149     alert(this.color);        //hong se    和上面结果相等，说明this在此处代表的是window对象的本身
150
151 // this 代表的是坐在的对象本身，下面在对象box中的this，就代表对象box
152     var color='红色';    // window对象的属性，
153
154     var box={
155         color:'蓝色',
156         run:function(){
157             alert(this.color);//蓝色
158             return this.color;
159         }
160     }
161     alert(window.color);//红色
162     alert(this.color);    //红色    此处this代表的是window对象，故this.color是代表的window的属性
163     alert(box.run());    //蓝色
164
165     window.co='hh';        //和上面的color是等价的，都属于window对象的属性
166     alert(this.co);
167
168 // 下面是通过给对象添加方法来改变this的作用域
169     window.color='红色';    //等价于  var color='红色'
170
171     var box={
172         color:'蓝色'
173     };
174
175     function sayColor(){
176         alert(this.color);
177     }
178
179     sayColor();        // 红色
180     box.sayColor=sayColor;    //给对象添加一个方法，
181     //上面这句话改变了 sayColor 的作用域在box对象里面，故这个方法里面的this也就是指的box对象
182     box.sayColor();    // 蓝色
183
184 */
185
186 /*    函数的属性和方法  length，prototype[原型，标准]
187
188 // 函数中的length属性返回的是函数的参数的个数
189     function box(nm1,num2){};
190     alert(box.length);    // 2
191     function func(num1,num2,num3,num4){};
192     alert(func.length);    // 4
193 // prototype 属性是保存实例方法的真正所在的位置，也就是保存的原型
194 //包含两个非继承而来的方法 apply()和call()方法，都是用在特定的作用域中调用，
195 //相当于改变函数的this，也就是说改变函数所处的对象，有点像C#中的反射调用对象方法
196
197 // box.apply()方法，两个参数，第一个参数是要操作的对象，第二个参数是方法的参数数组
198     function sum(num1,num2){
199         return num1+num2;
200     }
201
202     function saySum1(num1,num2){
203         //第一个参数时代表的是要调用的是哪一个对象的sum方法，后面是这个方法的参数列表，注意传递的是一个数组
204         return sum.apply(this,[num1,num2]);//this相当于window
205     }
206     function saySum2(num1,num2){
207         return sum.apply(this,arguments);
208         //arguments 代表的是当前函数[saySum2]的参数列表，是一个类函数，直接传递给函数sum
209     }
210     alert(saySum1(10,20));    //30
211     alert(saySum2(10,20));    //30
212
213 //第一个参数的不同，函数的作用域是不一样的
214     function sum(num1,num2){
215         return num1+num2;
216     }
217
218     function saySum1(num1,num2){
219         return sum.apply(this,arguments);//是在window对象中执行的
220     }
221     function saySum2(num1,num2){
222         return sum.apply(box,arguments);//是执行在box对象中的方法
223     }
224     var box ={
225         num1:'acd',
226         num2:'ddd',
227     }
228     alert(saySum1(10,20));    //30
229     alert(saySum2(10,10));    //20
230
231 //方法 call()和上面的apply()方法是一样的，仅仅在于接收参数的方式不同
232 //call()第一个参数同样是传递作用域对象，其余的参数是直接传给函数的，而不是传递一个数组
233
234     function sum(num1,num2){
235         return num1+num2;
236     }
237
238     function saySum1(num1,num2){
239         return sum.call(this,num1,num2)
240     }
241
242     function saySum2(num1,num2){
243         return sum.call(box,num1,num2);
244     }
245     var box={};
246
247     alert(saySum1(10,20));//30
248     alert(saySum2(20,20));//40
249
250 //call()和apply()方法最主要的是用于扩展函数依赖的作用域
251
252 var color='red';
253 var box={
254     color:'green'
255 }
256
257 function sayColor(){
258     return this.color;
259 }
260
261 alert(sayColor());                //red        对象是window
262 alert(sayColor.call(this));        //red        对象是window
263 alert(sayColor.apply(this));    //red        对象是window
264 alert(sayColor.call(window));    //red        对象是window
265 alert(sayColor.apply(window));    //red        对象是window
266 alert(sayColor.call(box));        //green        对象是box
267 alert(sayColor.apply(box));        //green        对象是box
268 */