函数参数的默认值

函数参数的默认值写法

如果调用函数时传入了对应的参数，就用传递的参数，如果没有传，就用默认值

在 ES6 之间前，不能直接为函数参数指定默认值，我们通常采用以下变通方法

function sum(a, b) {
  if (a === undefined) a = 0;
  if (b === undefined) b = 0;
  console.log(`${a}+${b}=${a + b}`);
}
sum(); // 0+0=0
sum(1, 3); // 1+3=4
sum("A", "B"); // A+0=A0

ES6 中，函数指定默认值，非常简单，直接在形参后面赋值

function sum(a = 0, b = 0) {
  console.log(`${a}+${b}=${a + b}`);
}
sum(); // 0+0=0
sum(1, 3); // 1+3=4
sum("A", "B"); // A+0=A0

默认值生效的条件：参数没有赋值，或赋值为 undefined

function sum(a = 0, b = 0) {
  console.log(`${a}+${b}=${a + b}`);
}
sum(); // 0+0=0
sum(undefined, "B"); //0+B=0B

函数参数默认值是惰性求值的

如果默认值是表达式，默认值表达式是惰性求值的

let x = 1;
function fn(a = x++) {
  console.log(x);
}
fn(2); // 1   x++不会执行
fn(); // 2   x++被执行
fn(undefined); // 3   x++被执行

参数默认值的位置

通常情况下，定义了默认值的参数应该是函数的尾参数。因为这样容易看出，那些参数是可以省略不传值的。

如果非尾部的参数设置了默认值，实际上我们是无法跳过此参数，设置其后参数的值的。除非显示传入 undefined 值

function fn(a = 1, b, c) {
  console.log(a, b, c);
}
fn(); // 1 undefined undefined
fn(2); // 2 undefined undefined
fn(undefined, 4, 5); // 1 4 5
// fn(,3,3); // 报错

函数的 length 属性

函数的 lenght 属性用来返回没有指定默认值的参数个数。

function sum(a,b,c=1){}

console.log(sum.length); // 2

函数参数的默认值与解构赋值结合使用

指定参数的默认值，就避免了在函数体内部再去判断传入的参数是否有值了。

function foo({ a = 1, b = 3 }) {
  console.log(a, b);
}

// 相当于  let {a = 1, b = 3}=undefined
// foo(); // 报错
// 相当于 let {a = 1, b = 3}={} 没有对应值，则用默认值
foo({}); // 1 3
// 相当于 let {a = 1, b = 3}={ a: "A" } a有值，用传的值，b无值，用默认值
foo({ a: "A" }); // A 3
// 相当于 let {a = 1, b = 3}={ a: "A", b: "B" } a与b都有值，用传的值
foo({ a: "A", b: "B" }); // A B

function foo({ a = 1, b = 3 } = {}) {
  console.log(a, b);
}
// 相当于 let { a = 1, b = 3 } = {}
foo(); // 1 3
// 相当于 let { a = 1, b = 3 }={}
foo({}); // 1 3
// 相当于 let { a = 1, b = 3 }={ a: "A" }
foo({ a: "A" }); // A 3
// 相当于 let { a = 1, b = 3 }={ a: "A", b: "B" }
foo({ a: "A", b: "B" }); // A B

function foo({ a, b } = { a: 1, b: 3 }) {
  console.log(a, b);
}

// 相当于 let { a, b } = { a: 1, b: 3 }
foo(); // 1 3
// 相当于 let { a, b } = {}
foo({}); // undefined undefined
// 相当于 let { a, b } ={ a: "A" }
foo({ a: "A" }); // A  undefined
// 相当于 let { a, b }={ a: "A", b: "B" }
foo({ a: "A", b: "B" }); // A B