JavaScript——函数

堆内存 栈内存问题

栈内存 是用来存储 基本数据类型(提供代码运行环境) 内存小 速度快
堆内存 是用来存储 引用数据类型 内存大 速度慢

  var a = 12;
    var obj = {q:1,w:2};
    var obj2 = obj;//(xxxfff000)

    //先去开辟一个堆内存，把属性名和属性值一对一对存储到堆内存中；
    // 把这个堆内存的地址(xxxfff000) 赋给 obj(xxxfff000);

JavaScript 函数

函数是由事件驱动的或者当它被调用时执行的可重复使用的代码块。

我们要用函数的原因

1、 节省代码
2、 高内聚（把东西缩到一块，这一块就是为了实现某个功能，跟其他代码没有任何联系） 低耦合（跟其他代码没关联）

function 函数名(){
函数体
}

var 函数名 = function 函数名-可写可不写(){
函数体
}

  * 第一种声明方式， 我们在声明的代码的之前调用这个函数
    * 第二种声明方式，  我们只能在声明的代码之后调用
    *
    * 函数声明之后 可以无限次调用
    *
    * return //返回的意思
    *
    * */
    clearRoom();//函数的调用  -->  函数名()

    function clearRoom() {
        console.log('收拾桌子');
        console.log('收拾卧室');
        console.log('出门');
    }

    // clearRoom();

    // clearPer();

    var clearPer  = function (){
        console.log('洗脸');
        console.log('刷牙');
        console.log('穿鞋');
        return '出门';// return 什么 那函数执行完 返给外界的就是啥
    };
    var a = clearPer();//把函数执行的结果赋值给 a
    console.log(a);
    // clearPer();


    function sum() {
        var a = 10;
        var b = 20;
        var total = a + b;
        return total;
    }
    total
    var t = sum();
    console.log(t);

函数的传参

函数的传参 （就是一个接收的的过程）
function sum(a,b){
//a和b 叫形参（形式上的参数）
}

  function sum(a,b) {
        console.log(a,b);
        var total = a + b;
        return total;
    }

    sum(1,2); // 1,2  是实参 （实际的参数）
    sum(3,4); //

截至目前
函数的声明 （2种）
函数的执行 （函数名()）
函数的返回值 (return) return 后边的代码不再执行 跟 for中的 break和continue 类似
函数的形参 (听指令的功能 || 管道入口)
函数的实参 (说指令 || 填入洗衣液和水)
arguments // 实参集合
this // 函数的执行主体 （谁调用的这个函数）

function sum2() {
        console.log(arguments);//为了让大家看arguments 是什么
        var total = 0;
        for(var i = 0; i < arguments.length;i++){
            // var total = arguments[i] + arguments[i+1]
            total += arguments[i];
        }
        console.log(this);
        return total;
        total = 400;
        return total;
    }

    console.log(sum2(1, 2, 3, 4));

1、当实参个数大于形参个数时，他们是按照先后顺序一一对应的
2、当实参个数小于形参个数时，没有对应上的形参会有一个（undefined）默认值

//两个数的求和
    function sum(a,b) {
        console.log(a,b);
        var total = 0;
        total = a + b;
        return total;
    }
   // sum(1,2);//3
    // console.log(sum(1, 2, 3, 4));// 3

函数中的this 指向问题：函数执行 看点前边是谁 函数中的this就是谁

    var obj = {
        fn: sum,
        w:12
    };
    sum();
    obj.fn();

    var oDiv = document.getElementById('div1');
    oDiv.onclick = function () {
        console.log(this);
    };

    //自己就能执行
    (function () {
        console.log(22)
    })()

函数的声明存储

    //对象的存储过程
    var obj = {
        w:1,
        e:2
    };
    obj = {q:1};
    //1、新开辟一个堆内存
    //2、把属性名和属性值，一对一对的存到堆内存中
    //3、把这个对内存的地址（xxxfff000） 赋给 obj这个变量


    //函数的存储过程
    function sum(a,b) {
        return a + b;
    }

    //1、新开辟一个堆内存
    //2、把函数体当作字符串存到这个堆内存中
    //3、把这个对内存的地址赋给 函数名 sum

    sum();

    var n = parseFloat('width:100px');
    if(n > 100){
        console.log(200)
    }else if(n == 100){
        console.log(100)
    }else if(n == NaN){
        console.log('NaN')
    }else {
        console.log('good')
    }

匿名函数

就是没有名字，没有命名的函数

第一种匿名函数

 //第一种匿名函数
    var sum2 = function (a,b,c) {
        console.log('var')
    }
    sum2();

第二种匿名函数

  (function () {
        console.log('这是一个自执行函数1')
    })();

    !function () {
        console.log('这是一个自执行函数2')
    }();

    ~function () {
        console.log('这是一个自执行函数3')
    }();

函数总结

 //1、 函数的定义 （2种）
    // function 函数名(){函数体}
    // var fn = function(){}

    //2、return 可有可无 ；
    // 跳出函数体
    // 确定返回值
    // 当不写return时，函数执行返回的  *结果*  是undefined
    // 当写了 return  但是后边没有任何内容；这时的 执行返回的结果 undefined
    // return a+b; 它是把表达式运行的结果返回出去
    // return 的位置 不固定， 根据业务需求来确定 return的位置；

    //3、形参 和 实参
    // function sum(a,b,c){} // a b c  在函数定义阶段确定的参数是 形参
    // sum(1,2,3) // 在函数调用的阶段，传进去的参数叫做实参
    // sum(1) // b c 多余的形参给的默认值是 undefined
    // sum(1,2,3,4) // 多余的实参 没有对应的实参接收，形参是按照先后顺序来接受实参的

    //4、arguments (实参集合)
    //它是一个函数内部的属性，跟咱们设不设置形参 和 传不传 实参 是没有关系的；他一直都存在
    function sum() {
        console.log(arguments)
    }
    sum(1,2,3)

    //5、this :函数的执行主体 ； 谁调用的函数；简单规律就是看点 点前边是谁  函数中的this 就是谁