day03原生js 函数

函数

函数是一个容器。可以复用代码。

函数的定义

函数声明

    function fun() {}

函数表达式

    var fun = function() {}

函数的调用

一定是通过 函数名() 来调用

• 如果是函数表达式 只可以在函数定义结束之后调用

    fun(); // fun is not a function
    var fun = function() {}
    fun(); // 成功

• 如果是函数声明 可以在任何地方调用

    fun(); // 成功
    function fun() {}
    fun(); // 成功

函数的参数

• 形参
  函数在定义的时候给的参数
  等价于定义在函数内的变量
• 实参
  函数在调用的时候给的参数

    function fun(a, b, c) { // a b c 都是形参 

    }
    fun(1, 2, 3); // 1 2 3 都是实参 

函数的参数关系

• 数量一致
  一一对应 每一个形参都可以接受到值
• 形参比实参多
  前面的一一对应 多出来的形参都是undefined
• 实参比形参多
  所有的形参都有值 但是有一些实参没有形参接收 等于没传

arguments

函数体内的一个对象 用于获取实参的个数

• arguments
  它是一个类数组对象 可以通过[数字]来获取里面的对应的实参

    function demo() {
        console.log(arguments[0]); // "a"
        console.log(arguments[1]); // "b"
        console.log(arguments[2]); // "c"
    }
    demo("a", "b", "c");

return关键字

用于让函数拥有“返回值”

    function demo(a, b) {
        return a + b;
    }
    var result = demo(1, 3);
    // result 就是 4

预解析

    // 预解析会发生在全局代码执行时 
    // 也会发生在函数代码执行时
    // function fun() {
    //     console.log(a);
    //     var a = 10;
    // }
    // fun();


    // 真实执行的时候函数中的代码
    // function fun() {
    //     var a;
    //     console.log(a); // undefined
    //     a = 10;
    // }
    // fun();


    /* 私有作用域中函数的预解析 */
    function fun() {
        f(); // 输出123 说明私有作用域中的提升规则与全局作用域一致
        function f() {
            console.log("123")
        }
    }
    fun();

作用域

 // 写代码的位置有两个： script标签之间、 function函数里

    var a = 10;
    function fun() {
        var a = 11;
        console.log(a); // 全局中有一个a变量 10 函数内部也有一个a变量是11
        // 这条代码是在函数内部执行的 所以自然会使用函数内部的a
    }
    fun();
    // 其实: JS中有一个作用域的概念,整个script标签之间是全局作用域.也就是script之间的代码是运行在全局作用域中的.
    // 包括 src请求回来的代码
    // 函数会单独开辟一个私有的作用域,叫做私有作用域,也叫做局部作用域.

    // 变量在被使用到时,会查找这个变量. 查找时根据作用域的就近原则.使用的是离自己最近的那个变量

函数的属性

递归函数

// 递归: 指的是一种特殊的函数用法 函数自己调用自己
// var i = 0;
// function demo() {
// // 一定要有停止条件 否则就是死循环
// i++;
// console.log(i);
// if(i > 10) {
// return;
// }
// demo();
// }

    // demo();



    // 递归的简单应用 计算阶乘

    function jc(num) {
        if (num === 1) {
            return 1;
        }
        return num * jc(num - 1);
    }

    // 假设传递的num为5 
    console.log(jc(5));
    // 第一次执行 返回 5 * jc(4)
    // jc(4) 执行返回 4* jc(3)
    // jc(3) 执行 返回 3 * jc(2)
    // jc(2) 执行 返回 2 * jc(1)  
    // jc(1) 执行  返回 1
    // 2 * jc(1) => 2 * 1
    // 3 * jc(2) => 3 * 2 * 1
    // 4 * jc(3) => 4 * 3 * 2 * 1
    // 5 * jc(4) => 5 * 4 * 3 * 2 * 1