JavaScript-函数形参与实参

函数 

1. JavaScript 使用关键字 function 定义函数。
2. 函数可以通过声明定义，也可以是一个表达式。
3. 函数声明后不会立即执行，会在我们需要的时候调用到。
4. 分号是用来分隔可执行JavaScript语句。 由于函数声明不是一个可执行语句，所以不以分号结束。
5. 避免使用new关键字

6. 提升（Hoisting）是 JavaScript 默认将当前作用域提升到前面去的的行为。提升（Hoisting）应用在变量的声明与函数的声明。因此，函数可以在声明之前调用。

7. 编程 注重 高内聚，低耦合，模块的单一责任制。JavaScript中 解耦合最好的方式就是函数。

function functionName(parameters) {
  执行的代码
}

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

        //函数声明
        function test(){
            var a = 1,
                b = 2;
                console.log(a,b);
        }
        // 表达式 字面量  test1作为函数名
        var test = function test1(){
            var a = 1,
                b = 2;
                console.log(a,b); 
        }
        test();//1 2
        console.log(test.name);//test1
        // test1()// test1 is not defined  解析：外部test1不可见

        //匿名函数表达式 
        var test = function(){
            var a = 1,
                b = 1;
                console.log(a,b);
        }
        test();

//匿名函数
var x = function (a, b) {return a * b};
var z = x(4, 3);

//另一种写法
var myFunction = function (a, b) {return a * b};
var x = myFunction(4, 3);

• 匿名自我调用的函数

(function () {
    var x = "Hello!!";      // 我将调用自己
})();

• 形参 实参  具有映射关系

1. 形参和实参数量可不等

        var aa = Number(window.prompt('a')) ;
        var bb = Number(window.prompt('b'));
        // a,b 形式上占位 形式参数 形参
        function test(a,b){
            console.log(a + b);
        }
        // aa bb 实际参数 实参 
        test(aa,bb);

        // 少传参数
        function test1(a,b,c){
            console.log(a,b,c);
        }
        test1(1,2)//1 2 undefined 解析：函数内相当于var a = 1,b = 2;未传c则c未定义

        //多传参数
        function test2(a,b){
            console.log(a,b);
        }
        test2(1,2,3)//1 2  

• 函数内部可打印实参

        function test(a,b){
            console.log(test.length);//形参长度 2
            console.log(arguments);//打印实参 [1,2,3]
        }
        test(1,2,3);

        //由此可解决 一个函数被调用时，累加他的实参值
        function sum(){
            var a = 0;
            for (let i = 0; i < arguments.length; i++) {
                a += arguments[i];
            }
            return a;
        }
        var res = sum(1,2,3,4,56);
        console.log(res);//66

• 可在函数内更改实参的值   注下例中 a 与arguments[0] 不是一个东西 详见栈内存与堆内存

        function test(a,b){
            a = 3;
            console.log(arguments[0]);
        }
        // a 与arguments[0] 不是一个东西 详见栈内存与堆内存
        test(1,2)// 3 解析：可在函数内更改实参的值

        //实参未传入，则未定义该变量
        function test1(a,b){
            b = 3;
            console.log(arguments[1]);
        }
        test1(1)// undefined 

• 参数的默认值：undefined

        // es6写法 a = 1,b = 2
        function test(a = 1, b = 2) {
            console.log(a, b);
        }
        test(undefined, 2) //1 2 解析：形参 与 arguments[] 对应 谁不是undefined取谁,都是undefined取undefined 
        test(null, 2) //null 2

        //兼容写法 - ||
        function test1(a, b) {
            var a = arguments[0] || 1;
            var b = arguments[1] || 2;
            console.log(a + b);
        }
        test1() //3

        // 兼容写法 - typeof
        function other(a, b) {
            // 注要声明变量a b 否则undefined + undefined   结果为NaN
            // 兼容写法 - 三元运算符
            // var a = typeof(arguments[0]) !=='undefined' ? arguments[0] : 1;
            var a, b;
            if (typeof (arguments[0]) !== 'undefined') {
                a = arguments[0];
            } else {
                a = 1;
            }
            if (typeof (arguments[1]) !== 'undefined') {
                b = arguments[1];
            } else {
                b = 2;
            }
            console.log(a + b); //3
        }
        other();