title: 函数的扩展
date: 2018.9.6
tags:
2018.9.6 星期四 14:15
1. 函数参数的默认值
2. rest 参数
3. 严格模式
4. name 属性
5. 箭头函数
6. 双冒号运算符
7. 尾调用优化
8. 函数参数的尾逗号
function log(x, y = 'World') {
console.log(x, y);
}
log('Hello') // Hello World
log('Hello', 'China') // Hello China
log('Hello', '') // Hello
// ES6 之前
function log(x, y) {
y = y || 'World';
console.log(x, y);
}
log('Hello', '') // Hello World
参数变量是默认声明的，所以不能用let或const再次声明。
使用参数默认值时，函数不能有同名参数。
参数默认值不是传值的，而是每次都重新计算默认值表达式的值。也就是说，参数默认值是惰性求值的。
let x = 99;
function foo(p = x + 1) {
console.log(p);
}
foo() // 100
x = 100;
foo() // 101
x =200;
foo() // 201
function foo({x, y = 5}) {
console.log(x, y);
}
foo({}) // undefined 5
foo({x: 1}) // 1 5
foo({x: 1, y: 2}) // 1 2
foo() // TypeError: Cannot read property 'x' of undefined
// 改进
function foo({x, y = 5} = {}) {
console.log(x, y);
}
foo() // undefined 5
function fetch(url, { body = '', method = 'GET', headers = {} }) {
console.log(method);
}
fetch('http://example.com') // 报错
function fetch(url, { body = '', method = 'GET', headers = {} } = {}) {
console.log(method);
}
fetch('http://example.com') // "GET"
// 作为练习，请问下面两种写法有什么差别？
function m1({x = 0, y = 0} = {}) {
return [x, y];
}
function m2({x, y} = { x: 0, y: 0 }) {
return [x, y];
}
上面两种写法都对函数的参数设定了默认值，区别是写法一函数参数的默认值是空对象，但是设置了对象解构赋值的默认值；写法二函数参数的默认值是一个有具体属性的对象，但是没有设置对象解构赋值的默认值。
通常情况下，定义了默认值的参数，应该是函数的尾参数。因为这样比较容易看出来，到底省略了哪些参数。如果非尾部的参数设置默认值，实际上这个参数是没法省略的。
指定了默认值以后，函数的length属性，将返回没有指定默认值的参数个数。也就是说，指定了默认值后，length属性将失真。
如果设置了默认值的参数不是尾参数，那么length属性也不再计入后面的参数了。
(function (a) {}).length // 1
(function (a = 5) {}).length // 0
(function (a, b, c = 5) {}).length // 2
(function(...args) {}).length // 0
(function (a = 0, b, c) {}).length // 0
(function (a, b = 1, c) {}).length // 1
一旦设置了参数的默认值，函数进行声明初始化时，参数会形成一个单独的作用域（context）。
等到初始化结束，这个作用域就会消失。这种语法行为，在不设置参数默认值时，是不会出现的。
如果参数的默认值是一个函数，该函数的作用域也遵守这个规则。请看下面的例子。
let foo = 'outer';
function bar(func = () => foo) {
let foo = 'inner';
console.log(func());
}
bar(); // outer
上面代码中，函数bar的参数func的默认值是一个匿名函数，返回值为变量foo。函数参数形成的单独作用域里面，并没有定义变量foo，所以foo指向外层的全局变量foo，因此输出outer。
var x = 1;
function foo(x, y = function() { x = 2; }) {
var x = 3;
y();
console.log(x);
}
foo() // 3
x // 1
/*
函数foo的参数形成一个单独作用域。这个作用域里面，首先声明了变量x，然后声明了变量y，y的默认值是一个匿名函数。
这个匿名函数内部的变量x，指向同一个作用域的第一个参数x。
函数foo内部又声明了一个内部变量x，该变量与第一个参数x由于不是同一个作用域，所以不是同一个变量，因此执行y后，内部变量x和外部全局变量x的值都没变。
*/
// 改进:如果将var x = 3的var去除
/*
函数foo的内部变量x就指向第一个参数x，与匿名函数内部的x是一致的，所以最后输出的就是2，而外层的全局变量x依然不受影响。
*/
var x = 1;
function foo(x, y = function() { x = 2; }) {
x = 3;
y();
console.log(x);
}
foo() // 2
x // 1
利用参数默认值，可以指定某一个参数不得省略，如果省略就抛出一个错误。
另外，可以将参数默认值设为undefined，表明这个参数是可以省略的。
function throwIfMissing() {
throw new Error('Missing parameter');
}
function foo(mustBeProvided = throwIfMissing()) {
return mustBeProvided;
}
foo()// Error: Missing parameter
function foo(optional = undefined) { ··· }
ES6 引入 rest 参数（形式为…变量名），用于获取函数的多余参数，这样就不需要使用arguments对象了。
rest 参数搭配的变量是一个数组，该变量将多余的参数放入数组中。
注意，rest 参数之后不能再有其他参数（即只能是最后一个参数），否则会报错。
函数的length属性，不包括 rest 参数。
function add(...values) {
let sum = 0;
for (var val of values) {
sum += val;
}
return sum;
}
add(2, 5, 3) // 10
function sortNumbers() {
return Array.prototype.slice.call(arguments).sort();
}
// rest参数的写法
const sortNumbers = (...numbers) => numbers.sort();
从 ES5 开始，函数内部可以设定为严格模式。
ES2016 做了一点修改，规定只要函数参数使用了默认值、解构赋值、或者扩展运算符，那么函数内部就不能显式设定为严格模式，否则会报错。
两种方法可以规避这种限制。第一种是设定全局性的严格模式，这是合法的。
第二种是把函数包在一个无参数的立即执行函数里面。
这个属性早就被浏览器广泛支持，但是直到 ES6，才将其写入了标准。
需要注意的是，ES6 对这个属性的行为做出了一些修改。
#### 1 如果将一个匿名函数赋值给一个变量，ES5 的name属性，会返回空字符串，而 ES6 的name属性会返回实际的函数名。
#### 2 如果将一个具名函数赋值给一个变量，则 ES5 和 ES6 的name属性都返回这个具名函数原本的名字。
#### 3 Function构造函数返回的函数实例，name属性的值为anonymous。
#### 4 bind返回的函数，name属性值会加上bound前缀。
// #### 1
var f = function () {};
f.name // "" // ES5
f.name // "f" // ES6
// #### 2
const bar = function baz() {};
bar.name // "baz" // ES5
bar.name // "baz" // ES6
// #### 3
(new Function).name // "anonymous"
// #### 4
function foo() {};
foo.bind({}).name // "bound foo"
(function(){}).bind({}).name // "bound "
ES6 允许使用“箭头”（=>）定义函数。
1) 如果箭头函数不需要参数或需要多个参数，就使用一个圆括号代表参数部分。
2) 如果箭头函数的代码块部分多于一条语句，就要使用大括号将它们括起来，并且使用return语句返回。
3) 由于大括号被解释为代码块，所以如果箭头函数直接返回一个对象，必须在对象外面加上括号，否则会报错。
$PS: 如果只有一条语句,没有大括号,默认是返回该语句 的值,比如上面返回一个对象
4) 如果箭头函数只有一行语句，且不需要返回值，可以采用下面的写法，就不用写大括号了。
5) 箭头函数可以与变量解构结合使用。
var f = v => v;
// ## 1
var f = () => 5;
var sum = (num1, num2) => num1 + num2;
// ## 2
var sum = (num1, num2) => { return num1 + num2; }
// ## 3
let getTempItem = id => ({ id: id, name: "Temp" });
// 下面是一种特殊情况，虽然可以运行，但会得到错误的结果。
let foo = () => { a: 1 };
foo() // undefined
// 执行了一行语句a: 1。这时，a可以被解释为语句的标签，因此实际执行的语句是1;，然后函数就结束了，没有返回值。
// ## 4
let fn = () => void doesNotReturn();
// ## 5
const full = ({ first, last }) => first + ' ' + last;
// 等同于
function full(person) {
return person.first + ' ' + person.last;
}
箭头函数使得表达更加简洁。
箭头函数的一个用处是简化回调函数。
下面是 rest 参数与箭头函数结合的例子。
const square = n => n * n;
const square = n => n * n;
const numbers = (...nums) => nums;
numbers(1, 2, 3, 4, 5)
箭头函数有几个使用注意点。
（1）函数体内的this对象，就是定义时所在的对象，而不是使用时所在的对象。
（2）不可以当作构造函数，也就是说，不可以使用new命令，否则会抛出一个错误。
（3）不可以使用arguments对象，该对象在函数体内不存在。如果要用，可以用 rest 参数代替。
（4）不可以使用yield命令，因此箭头函数不能用作 Generator 函数。
上面四点中，第一点尤其值得注意。this对象的指向是可变的，但是在箭头函数中，它是固定的。
1) 箭头函数可以让this指向固定化，这种特性很有利于封装回调函数。
this指向的固定化，并不是因为箭头函数内部有绑定this的机制，实际原因是箭头函数根本没有自己的this，导致内部的this就是外层代码块的this。
2) 正是因为它没有this，所以也就不能用作构造函数。
3) 另外，由于箭头函数没有自己的this，所以当然也就不能用call()、apply()、bind()这些方法去改变this的指向。(bind方法无效，内部的this指向外部的this。)
// ## $PS1
function foo(){
function bar(){console.log(this)} // window
const goo=()=>console.log(this) // window
bar(); // 非箭头函数,调用对象window.foo(), 指向window
goo() // 箭头函数 定义时所在的对象: window
}
foo();
// ## $PS2
function Timer() {
this.s = 0;
setTimeout(() => console.log(this), 1000);
// setTimeout(function () {console.log(this)}, 1000); // 始终是window
}
Timer(); // window,window // 箭头函数 定义时所在的对象: window
var timer = new Timer(); // Timer, window // 箭头函数 就是定义时所在的对象: new 操作符,this指当前对象
// ## 4 请问下面的代码之中有几个this？: 只有一个this
function foo() {
return () => {
return () => {
return () => {
console.log('id:', this.id);
};
};
};
}
var f = foo.call({id: 1});
// $PS: f()()() // id: 1 // 需要 三次 调用,即() ,才可以执行到最内层的函数. foo执行了一次
var t1 = f.call({id: 2})()(); // id: 1
var t2 = f().call({id: 3})(); // id: 1
var t3 = f()().call({id: 4}); // id: 1
$PS: 箭头函数没有this,但是指向固定:就是定义时所在的对象，而不是使用时所在的对象。结合下面
由于箭头函数使得this从“动态”变成“静态”，下面两个场合不应该使用箭头函数。
第一个场合是定义函数的方法，且该方法内部包括this。
第二个场合是需要动态this的时候，也不应使用箭头函数。
const cat = {
lives: 9,
jumps: () => {console.log(this)}, // window : 箭头函数指向固定:就是定义时所在的对象:定义cat时的对象window
jumps:function(){console.log(this)} // cat 使用时所在的对象cat
}
cat.jumps(); //
// ## 2
var button = document.getElementById('press');
button.addEventListener('click', () => {
this.classList.toggle('on');
});
// 上面代码运行时，点击按钮会报错，因为button的监听函数是一个箭头函数，导致里面的this就是全局对象。如果改成普通函数，this就会动态指向被点击的按钮对象。
// $PS: react的事件处理, 用箭头函数绑定 this:始终指向定义时的对象
// ### 1 这里使用箭头绑定方法. 警告：这个语法是实验性的！
handleClick = () => {
alert(this.state.message);
}
render(){
return (
<input
// ### 2
onChange={(e)=>{this.handleChange(e)}}
// ### 3
onChange={function(){this.changTextValue() }.bind(this)}
/>
}
下面是一个部署管道机制（pipeline）的例子，即前一个函数的输出是后一个函数的输入。
箭头函数还有一个功能，就是可以很方便地改写 λ 演算。
函数绑定运算符是并排的两个冒号（::），双冒号左边是一个对象，右边是一个函数。
如果双冒号左边为空，右边是一个对象的方法，则等于将该方法绑定在该对象上面。
如果双冒号运算符的运算结果，还是一个对象，就可以采用链式写法。
ES2017 允许函数的最后一个参数有尾逗号（trailing comma）。
此前，函数定义和调用时，都不允许最后一个参数后面出现逗号。
这样的规定也使得，函数参数与数组和对象的尾逗号规则，保持一致了。
15:05