JavaScript函数

开始之前我们要知道为什么使用函数？ 函数有什么用
1、能够对代码进行复用：只要定义一次代码，就可以多次使用它。
2、能够多次向同一函数传递不同的参数，以产生不同的结果。

函数的创建：两种方式
1. 声明式函数
语法—> function 函数名() {}
2.赋值式函数
语法—> var 函数名 = function () {}

   // 1. 声明式函数
    function weibolu() {
      // 下面就是叫做 weibolu 的这个函数里面封装的代码
      console.log('我有加热的功能')
    }
    weibolu（）

 // 2. 赋值式函数
    var bingxiang = function () {
      // 下面就是叫做 bingxiang 的这个函数里面封装的代码
      console.log('我有制冷的功能')
    }
    bingxiang （）

      => function: 函数的关键字
      => 函数名: 就是我们自己定义的一个名字, 遵循变量命名规则和规范
      => (): 形参,
      => {}: 大括号里面就是我们这个函数帮我们保存的一段 JS 代码
      
       函数调用上的区别:
   		 声明式函数可以在声明之前调用, 也可以在声明之后调用
         赋值式函数只能在声明之后调用, 声明之前调用会报错

函数的参数()
参数分成两种
一、形参: 函数 定义 的时候写在小括号里面的内容

  就是一个在函数里面使用的变量
  只不过这个变量的值由调用函数的时候的实参决定

二、实参: 函数调用的时候写在小括号里面的内容， 就是在调用函数的时候给形参进行赋值的
多个参数

1、 一个函数定义形参时 ，多个形参之间用逗号分隔，不建议写太多
2、 一个函数调用的时候,多个实参之间用 逗号 分隔，不建议写太多, 和形参一一对应

 实参和形参一样多
 	形参和实参按照 从左到右 的顺序一一对应
     实参多： 在函数内部没有形参接收这个传递进来的值，我们不能直接使用
     形参多： 在函数内部的时候, 多余出来的形参被实参赋值时得到的是 undefined, 是一个声明了, 但是没有赋值的状态

例子

    // 1. 一样多
        function fn(a, b, c) {
            console.log(a)
            console.log(b)
            console.log(c)
        }
        fn(10, 20, 30)

        // 2. 实参多
        function fn2(a, b) {
            console.log(a)
            console.log(b)
                // 你想用那个 30, 那么你需要再写一个形参
                // 不然的话不能直接使用, 因为没有形参在接收
        }
        fn2(10, 20, 30)

        // 3. 形参多
        function fn3(a, b, c, d) {
          console.log(a)
          console.log(b)
          console.log(c)
          console.log(d) // 因为没有实参进行赋值, 所以 d 的值就是 undefined
        }
        fn3(10, 20, 30)

封装一个函数, 把两个数字求和在控制台打印出来

    function and(n1, n2) {
      // 函数里面写我要做的事情
      var result = n1 + n2
      console.log(result)
    }
    // 使用这个函数
    and(10, 20) // 本次调用传递的是 10 和 20, 控制台打印的就是 10 + 20 的结果

    and(-30, -50) // 本次调用控制台打印的就是 -30 + -50 的结果

函数的返回值：return
一个函数的结果, 我们专业名称叫做返回值：我们把一个函数的结果叫做这个函数的返回，我们函数内部的返回值使用 return 来表示
return 的两个功能
可以给函数一个返回值之
打断函数的继续执行，当函数内部的代码执行到 return 后， 直接结束函数

例子1： 传递任意个数字，判断是否为质数
- 返回值： 一个布尔值, 判断这个数字是不是质数

     // 准备一个函数
    function isPrime(n) {
    
    // 判断 n 是不是质数
    // 1. 假设是一个质数
      var flag = true

    // 2. 循环
      for (var i = 2; i < n; i++) {
        if (n % i === 0) {
          flag = false
          break
        }
      }
      // 不是质数, 可以不等到循环结束就知道
      // 是质数, 需要等到循环结束才能知道
      return flag
    }
    // 使用这个函数
    var res = isPrime(111)
    console.log(res)

例子2：不需要返回值，直接在控制台打印 两个数字 之间的所有闰年

function run(a, b) {
      // a === 1000, b === 2000
      // 就要找到 1000 ~ 2000 之间的闰年

      // 如果我传递的 a 比 b 还大, 让两个变量交换一下
      if (a > b) {
        var c = a
        a = b
        b = c
      }

      for (var i = a; i <= b; i++) {
        if (i % 4 === 0 && i % 100 !== 0 || i % 400 === 0) {
          console.log(i)
        }
      }
    }
    run(2000, 1000)

声明提升
1、变量声明提升：不管变量在函数体里的什么位置进行定义（声明），
那么在预解析（预编译）时，浏览器会先把变量的声明提升到函数体的最开始
如下

//解析原js
function fn(){
    console.log(a);//undefined
    var a;
}       

// 经过与解析后，是如下代码（即：浏览器真正执行js代码时，代码已经变成了如下）：
function fn(){
    var a;
    console.log(a);//undefined
}   

function fn(){
    console.log(a);
    var a=10;// 两个意思：1）、定义（声明）了一个变量。2）、给变量赋值为10.
}       

// 以上代码，经过与解析后，是如下代码（即：浏览器真正执行js代码时，代码已经变成了如下）：

function fn(){
    var a;//声明进行的提升
    console.log(a);//undefined
    a=10; //赋值不会提升。
}