es6-函数的扩展

函数的扩展

1.函数的默认值

//参数变量默认声明，不能再次使用let和const声明
function login(name,isLogin=false){
	console.log(name,isLogin);
}
login("admin");        //"admin" false
//与解构赋值结合
function login({name,isLogin=false}){
	console.log(name,isLogin);
}
//1.参数默认值为空对象，设置了解构赋值的值
function login({name="admin",isLogin=false}={}){
	console.log(name,isLogin);
}
//2.参数默认值为具体属性，解构赋值的值为空
function login({name,isLogin}={name="admin",isLogin=false}){
	console.log(name,isLogin);
}
//参数默认值位置
//1.一般设置默认值的参数需作为尾参数，若不是则不能省略，
//	除非赋undefined,默认值才会生效
function login(isLogin=false,name){
	console.log(name,isLogin);
}
login(undefined,"admin"); // false "admin"

1.函数的length属性将返回没有指定默认值的参数个数。
2.rest参数也不会计入length属性。

//参数默认值是变量,作用域先查找当前函数，在查全局
var bool= false;
function login(name,isLogin=bool){
	console.log(name,isLogin);
}
//参数默认是另一个函数，其作用域是全局作用域
var bool= false;
function login(name,func=x=>bool){
	let bool = true;
	console.log(name,func());
}
login("admin");            //"admin" false
//依托函数默认值，指定某一个参数不可省略，若省略则抛出错误(默认值为一个错误信息)。

---

rest参数，获取函数多余的参数，类型为数组；就不需要使用arguments对象了。
res参数之后不能有其他参数，函数的length属性不包括rest参数。
扩展运算符…
可以将数组转为用逗号分割的参数序列。
1.展开数组

	console.log(...[1,2,3]);    //1 2 3

2.合并数组

	console.log(...[1,2],...[3,4]);  //1 2 3 4

3.与解构赋值结合

	const [p,...arr] = [2,1,3,4];
	p    //2
	arr   //[1,3,4]

4.函数返回值。
5.字符串可转为真正的数组。
6.可以将类似数组的对象转为真正的数组。
7.Map/Set/Generator函数，扩展运算符内部调用Iterator接口。

name属性返回该函数的函数名。
Function构造函数返回的函数实例，name属性返回“anonymous”，
bind返回的函数，name属性值会加上“bound”前缀。

箭头函数
嵌套函数可以使用箭头函数很好的改写。

//1.一个参数
var func = key=>key;     func(1);      //1
//2.没有或多个参数
var func=()=>"hello";   func();         //"hello"
var func=(a,b)=>a+b;     func("1",2);        //"12"
//3.参数可使用解构赋值
var func=({a,b})=>a+b;  func({a:"1",b:2});
//4.rest参数
var func=(...item)=>item;   func(1,"2",["hello","world"]);     //[1,"2",["hello","world"]]

1.this 为定义时的对象，不能使用call()/apply()/bind()改变this的指向。
2.不可以当做构造函数
3.不可使用arguments对象、super、new.target
4.不可以使用yield命令。

函数绑定（es7）-“::”
左边是个对象，右边是一个函数。该运算符会将左边的对象作为上下文环境绑定到右边的环境。
1.如果左边为空，右边是一个对象的方法，则将该方法绑定到该对象上（晕）
2.该运算符返回的还是原对象，因此可以采用链式写法。
尾调用
函数的最后一步调用另一个函数，即return (function)。

//1.
function func(){
	var f=()=>"hello";
	return f();
}
//2.尾递归
function factorial(n){
	if(n === 1) return 1;
	return n*factorial(n-1);
}
factorial(5);    // 嵌套 (5*(4*(3*(2*1))));
//尾调用优化
function factorial(n,total){
	if(n===1) return total;
	return factorial(n-1,n*total);
} 
factorial(5,1); //total = 1; n =5
factorial(4,5); //total =5; n=4
factorial(3,20); //total =20; n =3
factorial(2,60); //total = 60;n =2
factorial(1,120); //total = 120,n =1
				 //return total=120;

只有开启严格模式“use strict"，尾调用优化才会生效。
把所有递归函数用到的内部变量全部改写成函数的参数。

//1.
function factor(n){
	factorial(n,1);
}
factor(5);
//函数柯里化，将函数多参数的转换为单参数的形式。
function currying(fn,n){
	return function(m){
		fn.call(this,m,n);
	}
}
var func = currying(factorial,1);
func(5);     //有种函数嵌套的感觉