1.函数的创建

函数是把相同的代码设计成一个代码块，需要的时候调用，可以避免代码冗余

  1. function 函数名(参数1,参数2,...){函数体}
  1. var abc = function(参数1,参数2,...){函数体}

2.函数的调用

调用函数的场景：1.当发生事件时 2.js代码调用时 3.函数创建完成后，自动调用

  1. 函数名(参数....);
  2. (函数)();

3.函数的参数

1.函数传参：若需要给函数传参，则必须在定义函数时，给function传递参数，在调用时传入参数

  1. function cook(tool,water,rice){
  2.     console.log("煮饭需要:",tool,water,"和",rice)
  3. }
  4. cook("电饭煲","水","大米")
  1. 煮饭需要: 电饭煲 水 和 大米

2.函数的形参与实参：在上述案例中，tool,water,rice代表形参，电饭煲,水,大米代表实参 意义：形参只会作用于函数内部，函数外部无法使用，实参的个数和形参一一对应(不能多，更不能少)

4.函数的返回值

用return接收函数的返回值，需要在函数外部赋值给一个变量，接收return的返回值，当函数中有return时，函数会终止执行，返回函数值，若在return后还有代码，则后面的代码不会被执行。

  1. function cook(tool,water,rice){
  2.         var condition = "煮饭需要:"+tool+"、"+water+"和"+rice
  3.         return condition
  4. }
  5. var finish = cook("电饭煲","水","大米")
  6. console.log(finish)
  1. 煮饭需要:电饭煲、水和大米

5.函数中调用函数

需求：实现(5+6)*9，有两种方式，第一种：分别运算，第二种：可以根据已有函数进行相互调用计算

  1. function sum(sp1, sp2) {
  2.     var sum = sp1 + sp2;
  3.     return sum;
  4. }
  6. function mp(mp1, mp2) {
  7.     var mp = mp1 * mp2;
  8.     return mp;
  9. }
  12. function combination(cp1, cp2, cp3) {
  13.     var a = sum(cp1, cp2)
  14.     var b = mp(a, cp3)
  15.     return b;
  16. }
  18. var value = combination(5, 6, 9);
  19. console.log(value)
  1. 99

6.全局变量及局部变量

全局变量：在函数外部声明的变量，函数内部可以使用，叫做全局变量 局部变量：在函数内部用var声明的变量，函数外部不可以使用，叫做局部变量 局部变量在函数执行完后，会从内存中删除 函数内部不用var声明，直接赋值方式声明的变量是全局变量

  1. var a = "全局变量"
  2. function globalVariable(){
  3.     console.log(a)
  4. }
  5. globalVariable()
  7. function localVariable(){
  8.     var b = "局部变量"
  9.     console.log(b)
  10. }
  11. localVariable()
  12. console.log(a)
  13. console.log(b)
  1. 全局变量
  2. 局部变量                                                                                 
  3. 全局变量 
  4. ReferenceError: b is not defined

7.匿名函数

匿名函数：没有函数名的函数 第一种方式：通过变量接收，调用时必须放在函数之后，否则会出现错误 第二种方式：在函数外围加括号，实现自调用 第三种方式：事件发生时调用 第四种方式：函数中调用

  1. var fun = function () {
  2.     console.log("通过变量接收匿名函数")
  3. }
  4. fun();
  6. (function () {
  7.     console.log("第一种调用方式，函数自调用")
  8. })();
  10. window.onload = function (){
  11.     console.log("第二种调用方式：通过触发事件来调用函数")
  12. }
  14. setTimeout(function (){
  15.     console.log("第三种调用方式：通过函数来调用函数")
  16. },3000)
  1. 第一种:通过变量接收
  2. 第二种:通过自调用

8.回调函数

回调函数：需要有主次关系：主函数执行完毕后，会执行次函数

  1. function ma(se){
  2.     se();
  3. }
  5. function se(){
  6.     console.log("我是次函数，我需要在主函数执行完后，再执行")
  7. }
  9. ma(se)
  1. 我是次函数，我需要在主函数执行完后，再执行

9.递归函数

递归函数：自己调用自己，类似于循环，需要设置跳出循环的条件，否则会进入死循环

  1. var i = 0;
  2. function rec(){
  3.     console.log("递归函数");
  4.     i++;
  5.     if (i<10){
  6.         rec();
  7.     }
  8. }
  9. rec();
  1. 递归函数
  2. 递归函数
  3. 递归函数
  4. 递归函数
  5. 递归函数
  6. 递归函数
  7. 递归函数
  8. 递归函数
  9. 递归函数
  10. 递归函数

10.内置功能函数

内置函数：js自带的函数