函数-1

函数的定义
 // 1) 函数声明方式
    function sum(a, b) {
    console.log(1+3);
    }
    sum(10, 20);

    // 2) 函数表达式声明方式
    var add = function () {
    console.log(1+3);
    };
    add();

    // 3) 使用Function构造函数
    var add2 = new Function('console.log(1+3);');
    add2();

***函数的实参可以大于形参的个数，但是，实参比形参少，存在问题

 // 求出多个数的和
 function sum(numArr) {
    var value = 0;
    for(var i=0; i<numArr.length; i++){
        value += numArr[i];
        }
        console.log(value);
    }
    // var numArr = [10, 20, 30];
    sum([10, 20, 30, 90, 100]);


function sum(num1, num2) {
    // arguments对象，会把函数传入的值，放到arguments中，伪数组
    // console.log(arguments);
    var value = 0;
    for(var i=0; i<arguments.length; i++){
        value += arguments[i];
    }
    console.log(value);
    console.log(arguments.length);
    console.log(sum.length);  
    if(arguments.length === sum.length){
        //sum.length传入形参的个数，就是判断形参与实参的个数是否相等
    }
    }

    sum(10, 20, 30, 100, 200, 100, 20);

 // 1. 函数直接声明
    function sum(num1, num2) {
        return num1 + num2;
    }


    console.log(sum(10, 20));
    //会将当前的作用域的函数声明作用到整个作用域的最前面  console.log(sum(10, 20));放到函数前面也可以执行



    // 2. 函数表达式声明

    var add = function (num1, num2) {
        return num1 + num2;
    };
    console.log(add(20, 40));
    //输出调用函数只能在函数声明的下方调用

匿名函数
1、绑定事件
2、定时器
3、自调用函数
document.onclick = function () {
        alert("点我干嘛?");
    };

setInterval(function () {
        console.log(1111);
    }, 1000)

3、自调用函数--闭包
(function () {
        alert("真的会执行吗?");
   })();

回调函数：如果把函数的指针（地址）当作参数传递给另外一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数；
在一个函数中调用另外一个函数

function fn(num1, num2, func) {
        return func(num1, num2);
 }

//小案例
// 加减乘除函数
    function add(a, b) {
        return a + b;
    }

    function sub(a, b) {
        return a - b;
    }

    function mul(a, b) {
        return a * b;
    }

    function divide(a, b) {
        return a/b;
    }

    console.log(fn(10, 20, add));
    console.log(fn(10, 20, sub));
    console.log(fn(10, 20, mul));
    console.log(fn(10, 20, divide));

// 求Fibonacci的第n个数
    // 1 1 2 3 5 8 13 21...

    function f1(n) {
        if(n === 1 || n === 2) return 1;

        return f1(n-1) + f1(n-2);
    }

    console.log(f1(8));

var name = "张三";//全局
    {
        var age = 19000;
        console.log(name);//可以找到
    }
    console.log(age);//可以输出

    function test() {
        var sex = "男";//局部
        console.log(name);
    }

    test();

    console.log(sex);//找不到

函数内部可以找到函数外部的变量，只有在函数内部才是局部变量，如果变量用var声明的就是局部变量，没有用var 声明的就是全局变量

function test() {
        sex = "女";
        console.log(name + "局部打印");
    }
    test();

    console.log(sex);
//没有用var 声明的为全局变量
//这里的sex就是全局变量，但不推荐使用

var color = "yellow";
    function getColor() {
        var anotherColor = "red";

        function swapColor() {
            var tmpColor = color; // y
            color = anotherColor; // r
            anotherColor = tmpColor; // y
        }
        swapColor();
    }

    getColor();
    console.log(color); // red

 var num = 10;
        fun();
        function fun(){
            // 声明提前
             //var num;会把num=20分解，将var num;提前声明，赋值还在下方
            console.log(num);
            var num = 20;
        }

//Undefied

var a = b = c = 9;   a是局部的，b.c是全局的