函数部分补充（15）

 函数中的返回值

 

function fn(n, m) {//=>形参:入口
    //=>函数体
    var total = 0;
    total = n + m;
    console.log(total);
}

fn(10, 20);//=>实参:给形参传递的具体值
/*
var a = 12;
fn(a, 1 === 1 ? 10 : 0);//=>实参一定是值,即使我们写的是变量或者表达式,也是把变量或者表达式计算的结果作为值传递给形参变量
*/

function fn(n, m) {
    var total = 0;//=>total:私有变量
    total = n + m;
}
fn(10, 20);
console.log(total);//=>Uncaught ReferenceError: total is not defined TOTAL是私有变量,我们无法在函数的外面直接获取这个值(闭包)

/*
 * 函数的入口：形参
 * 函数的出口：返回值  return
 *    把函数运行的结果(或者函数体中的部分信息)拿到函数外面去使用
 */
function fn(n, m) {
    var total = 0;
    total = n + m;
    return total;//=>并不是把TOTAL变量返回,返回的是变量存储的值,RETURN返回的永远是一个值
}
// fn =>代表的是函数本身
// fn(10, 20) =>代表的是函数执行(不仅如此,它代表的是函数执行后,返回的结果 [RETURN返回的值] )
// console.log(fn(1, 2));//=>3
var result = fn(1, 2);
console.log(result);//=>3

function fn(n, m) {
    var total = 0;
    total = n + m;
    return;
}

var res = fn(100, 200);//=>如果当前函数没有RETURN结果出来（或者RETURN; 啥也没返回），函数执行在外面拿到的结果都是 UNDEFINED
console.log(res);

function fn(n, m) {
//=>如果n/m有一个没有传递值，我们返回零
if (n === undefined || m === undefined) {
    return 0;//=>RETURN还有一个作用：类似于循环中的BREAK，能够强制结束函数体中代码的执行(RETURN后面的代码不在执行)
}

var total = 0;
total = n + m;
return total;
}

console.log(fn(10));//=>n=10 m=undefined

// n === undefined 经常这样判断n的值是否为undefined，这种方式可以
// n==undefined 这种模式不好,因为null==undefined也是相等的(===比较才不相等)
// typeof n=='undefined' 真实项目中开发者更喜欢这种判断模式

// total=0; 0是有值的,值是0,从内存方面来说，会在栈内存中占一个位置
// total=null;  开发者更喜欢用null来作为初始值,null是空对象指针，是不占内存位置的

arguments

/*
 * 任意数求和：不管函数执行的时候，传递多少实参值进来，我们都可以求和
 *
 * 形参有局限性：我们需要具体的知道用户执行的时候传递实参数量、顺序等，才可以使用形参变量定义对应的入口
 *
 * arguments：函数内置的实参集合（内置：函数天生就存在的机制，不管你是否设置了形参，也不管你是否传递了实参，ARGUMENTS都有，始终存在）
 */

/*
function sum(n, m) {
    console.log(arguments);
    /!*
     * ARG它是一个类数组(不是数组,不能直接使用数组中的方法)
     *
     * 即使设置形参变量,形参该是什么值还是什么值,但是ARG使用存储的是“所有”传递进来的实参，所以它被称为“实参集合”
     *
     * {
     *   0:10,
     *   1:20,
     *   length:2,
     *   callee:存储的是当前函数本身  arguments.callee===sum:true
     * }
     *!/
}
sum(10, 20);
*/

/*
 * 把ARG中存储的实参值依次遍历,每遍历一个都累加起来,最后实现任意数求和
 */


//=>基础版
function sum() {
    var total = null;
    for (var i = 0; i < arguments.length; i++) {
        var item = arguments[i];//=>每一次遍历出来的实参值
        total += item;
    }
    return total;//=>把计算的结果返回
}
console.log(sum(10));


//=>升级版：在累加的时候，把字符串转换为数字，对于一些非有效数字，不在相加
function sum() {
    var total = null;
    for (var i = 0; i < arguments.length; i++) {
        var item = arguments[i];//=>10 '20' 'AA'
        //1.不管ITEM获取的是传递的啥,都先转换为数字类型
        item = Number(item);
        //2.如果当前的值是有效数字我们才累加,非有效数字直接跳过即可
        isNaN(item) ? null : total += item;
    }
    return total;
}

console.log(sum(10, '20', 'AA'));//=>30

//扩展
let sum = (...arg) => eval(arg.filter(item => !isNaN(item)).join('+'));
console.log(sum(10, '20', 'AA', 50));

匿名函数和实名函数

/*
 * 实名函数：有函数名的
 * 匿名函数：没有函数名的
 *   - 函数表达式：把函数当做值赋值给变量或者元素的事件
 *   - 自执行函数：创建和执行一起完成的
 *   - ...
 */
/*function fn() {

}*/

//=>函数表达式
/*var fn = function () {

};
oBox.onclick = function () {

};*/

//=>自执行函数
(function (i) {

})(10);
~function () {

}();
+function () {

}();
!function () {

}();