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();

 

你可能感兴趣的:(javaScript)