006day函数的执行符，属性，arguments对象，递归

一、函数的执行符
函数的执行符：（）
对象的引用
立即自执行匿名函数
函数作为实参使用

<script>
//第二种定义函数的方式
//log 对象变量、对象引用。指向了堆内存中的一个匿名函数。
var log = function(msg){
     console.log(msg);
}
function show(){
console.log(”可是你却并不在意“);
}
//如何让匿名函数执行。通过对象引用+执行符。来执行匿名函数。
      log("千万里我追寻着你");
//调用其他方法的方法   funName 方法的名字，或者是方法的对象引用。
function invokeFunction(funName){
funName();
}
invokeFunction(show);
invokefunction(log);
//立即自执行匿名函数。就是希望函数定义之后立即执行。而且我只需要执行一次。
(function(msg){
   console.log (msg);
})("你不想在我梦里，在梦里你是我的唯一！");
 ~function test(){
 console.log("helloworld!")
 }();
</script>

二、函数的属性和方法介绍
函数是一种引用数据类型。
是我们接触到的第一种引用数据类型。
函数是一种特殊的对象，对象就是可以具有属性和功能（函数、方法）。
函数的属性：
name:函数的名字
length：代表了函数的形参的个数。是个整数。
函数的方法：
toString():得到函数的字符串表示形式。

<script>
    function show() {
        console.log ("我今生注定要独行，热情以被你耗尽！");
    }
    console.log (typeof show);//function

    var log = function(){
        console.log ("我已经变的不再是我，而你却依然是你！");
    }
    console.log (show.name);//show
    console.log (log.name);//log

    //调用其他方法的方法。
    function invokeFunction(fnName) {
       if(fnName.name === "show"){
           console.log ("*************");
       }else if(fnName.name === "log"){
           console.log ("-----------");
       }
    }

    invokeFunction(log);
    invokeFunction(show);

    console.log (invokeFunction.length);//1
    console.log (show.length);

   /* ƒ (){
        console.log ("我已经变的不再是我，而你却依然是你！");
    }*/
    console.log (log);


    /*function(){
        console.log ("我已经变的不再是我，而你却依然是你！");
    }*/
    console.log (log.toString());
</script>

三、函数的arguments对象
函数的arguments对象
1：arguments 参数的意思。
2：arguments 是一个对象，是函数的一个对象，只能在函数体中使用。
3: arguments 是一个集合。类数组对象。可以像访问数组一样去访问它。通过下标。
下标从0开始。 arguments[下标] 访问。
4：有一个length属性。代表了元素的个数。
5：arguments 还有一个属性是一个对象。callee。是当前函数自身。主要用于递归调用。
6：arguments 对象中的元素是实参的内容。可以通过该对象来访问传入的实参的内容。
7：通常情况下都是使用方法的形参来接收实参的，不建议使用arguments来访问实参。
8：如果传入的实参的个数不确定。可以使用arguments来访问传入的实参。
补充：arugments不太建议使用。因为在严格模式下，arguments无效。
arguments 在一定程度上弥补了js不存在重载的问题。

<script>
    function show(msg) {
        console.log (msg);
        // ["time time again,you ask me", callee: ƒ, Symbol(Symbol.iterator): ƒ]
        console.log (arguments);
        console.log (arguments.callee);
    }

    show ("time time again,you ask me");

    //实现任意个数的累加和的方法。就可以使用arguments来处理。
    function add(num1, num2) {
        return num1 + num2;
    }

    function add(num1, num2, num3) {
        return num1 + num2 + num3;
    }

    function add() {
        //在方法的内部使用arguments来访问所有的实参。
        const LEN = arguments.length;
        if (LEN === 0)
            return NaN;
        //遍历arguments中的所有的内容。累加返回
        var sum = 0;
        for (let i = 0; i < LEN; i++) {
            sum += arguments[i];
        }
        return sum;
    }

    console.log (add());//NaN
    console.log (add(1,2,3,4,5));//15
    console.log (add(1,2,2,1,1,2,3,4,4));//20
</script>

四、递归
递归：recursion 指的就是函数调用。
概念：函数直接的或者是间接的调用了自身。
使用递归的解决的问题特点：
1：问题可以分解为若干个子问题。
2：子问题的解决的方案和问题本身的解决方案一致。
3：最终一定存在某一个子问题可以直接解决。
4：最终问题的解决要依赖于所有的子问题的解决。
求 n! n的阶乘。
n! == n*(n-1)(n-2)…321;
n!= n(n-1)!
5! = 54321;
5! = 54!;
4! = 43!
3! = 32!
2! = 21！
1！ = 1;

<script>
    function test(n) {
        //直接递归调用
        // test(n-1);
        //间接递归调用。
        test2 ();
    }

    function test2() {
        test (1);
    }
    // Maximum call stack size exceeded
    // test(1);

    //使用递归求n的阶乘
    /**
     * 求n的阶乘。返回n的阶乘的结果。
     * @param n
     */
    function factorial(n) {
        let result = 1;
        if (n === 1)
            return result;
        result = n * factorial (n - 1);
        return result;
    }

    console.log (factorial (5));//120
    console.log (factorial (6));//720

    //斐波那切数列，第一个和第二个数为1，从第三个数开始，是它前两个数之和。
    //求第n个位置上的数的值。
    function fibo(n) {
        if (n === 1 || n === 2)
            return 1;
        return fibo (n - 1) + fibo (n - 2);
    }
// overflow
    for (let i = 1; i < 10; i++) {
        document.write (fibo (i) + ",");
    }
</script>