函数

  • 定义
    • 函数声明
    • 函数表达式
  • 组成形式
    • 函数名称
    • 参数
      • 形参
      • 实参
    • 返回值

函数声明

  1. // 第一种方式
  2. function box (参数){
  3.     // 内容
  4. };
  6. // 第二种叫命名函数表达式
  7. var box = function test(参数){
  8.     // 内容
  9. }
  10. // 在浏览器console上输出 box.name --> test
  12. // 第二种写法function后面就成了表达式,有没有名字无所谓,所以延伸出了第三种写法
  14. // 第三种叫匿名函数表达式-->函数表达式
  15. var box = function (参数){
  16.     //内容
  17. }
  18. // 在浏览器console上输出 box.name --> box
  21. //函数执行
  22. box();

参数

  • 参数也叫参变量，是一个变量，是在函数中一个非常重要的组成部分，能使函数格外灵活。

形式参数与实际参数

  1. // 形式参数 --> 形参
  2. function test1(a,b){
  3.     var c= a+b
  4.     console.log(c); 
  5. }
  6. // 实际参数 --> 实参
  7. test1(1,2); //    输出3   // (1,2)作为参数传进去

不定参数

  • 我们通常使用可变参函数来构造API，可变参函数可接受任意数量的参数，我们一般称使用 arguments 为可变参或不定参
  2. // 不定参数 例子一
  3. function test2(a){
  4.     // a 就等于1
  5.     // 2,3不用管
  6.     // 隐式的方法arguments[1,2,3]实参列表
  7.     // 找到多余的实际参数
  8. }
  9. test2(1,2,3); //执行tset2之后(1,2,3)作为参数传进去
  11. // 不定参数 例子二
  12. function test3(a,b,c,d){
  13.     // a 等于1
  14.     // b 等于2
  15.     // c 等于3
  16.     // d 等于undefined
  17.     找到形参的长度sum.length
  18. }
  20. test3(1,2,3); // 执行tset3之后(1,2,3)作为参数传进去

不定参的好处如：

  1. var result = 0;
  2. function sum(){
  3.     for(var i = 0; i<arguments.length;){
  4.         result += arguments[i];
  5.         i++;
  6.     }
  8.     console.log(result);
  10. }
  11. sum(1,2,3,4,5,6,7,8,9);

JS 的映射规则

  1. function sum(a,b){
  2.     a = 2;
  3.     console.log(arguments[0]);        // 打印出2，参数a改变了
  4. }
  5. sum(1,2);
  7. function sum(a,b){
  8.     a = 2;
  9.     arguments[0] = 3
  10.     console.log(arguments[0]);        // 打印出3,参数a改变了,可以相互改变
  11. }
  12. sum(1,2);
  1. function sum(a,b){
  2.   //arguments[1]没值
  3.     b = 2;
  4.     console.log(arguments[1]);
  5. }
  6. sum(1);
  • 打印出 undefined
  • 实参列表传进来的时候他就有几个，就算我让b等于2，它也不会往 arguments 里面加了。
  • 函数根本就没有，这个时候 b 就当一个变量用了。
  • b 实参不映射，因为形参比实参多了一位 b，只有他们相等的时候他们才会有映射的规则，不相等的时候，形参多了他不对应实参了，他们之间不映射。

结束条件加返回值return

  • 结束函数,如果没有写,系统默认自带return
  • 把值返回到函数外部
  1. function sum(){
  2.     return 123
  3. }
  5. var box = sum();-->返回123

作用域初探

  • 作用域定义： 变量(变量作用域又称上下文)和函数生效(能被访问)的区域。

  • 全局、局部变量。

  • 作用域的访问顺序。

函数里面可以访问函数外面的东西在 script 标签上定义的变量叫全局变量，在函数内部定义的变量叫局部变量。

  1. // a 是全局变量
  3. var a = 123;
  4. function test(){
  5.     console.log(a);            // 打印出来是123
  6.     // b 是局部变量
  7.     var b = 123;
  8.     function demo(){
  9.         var c = 234;
  10.         console.log(a);
  11.         console.log(b);
  12.     }
  13.     console.log(c);            //报错c is not defined;
  14. };
  15. test();
  16. console.log(b);                    //报错b is not defined
  1. function test(){
  2.     var a = 123;
  3. }
  5. function demo(){
  6.     var b = 12;
  7. }
  8. // test 和 demo 不能相互访问

后续会用专门的一章来介绍函数的作用域，这里只是简单地介绍一下