function log(x,y){
	y = y|| 'World';
	console.log(x,y);
}
log('Hello'); //Hello World
log('Hello','China') //Hello China
log('Helllo','') //Hello World 上面代码检查函数log的参数有没有赋值，如果没有，则指定默认值World，这种写法的缺点在于，如果没有参数y赋值了，但是对应的布尔值为false，则赋值不起作用，就像上面的代码最后一行，参数y等于空字符，结构被改为默认值。

if(typeof y === 'undefined'){
	y = 'World';
}

function log(x,y = 'World'){
	console.log(x,y);
}
log('Hello');
log('Hello','China') //Hello China
log('Hello','') //Hello

function foo(x = 5){
	let x =1;//error
	const x =2;//error
}

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 fetch(url,{body = '',method = 'GET',headers ={} }){
	console.log(method);
}

fetch('http://example.com',{})
//"GET"

fetch('http://example.com')
//报错

//写法一
function m1({x = 0,y = 0} = {}){
	return [x,y];
}

//写法二
function me({x,y} = {x:0,y:0}){
	return [x,y];
} 写法一函数参数的默认值是空对象，但是设置了对象解构赋值的默认值

//函数没有参数的情况
m1()			//[0,0]
m2()			//[0,0]

//x和y都有值的情况
m1({x:3,y:8}) 		//[3,8]
m2({x:3,y:8})		//[3,8]

//x有值，y无值的情况
m1({x:3}) 			//[3,0]
m2({x:3}) 			//[3,undefined]

//x和y都无值的情况
m1({})			//[0,0]
me({})			//[undefined,undefined]

m1({z:3})		//[0,0]
me({z:3})		//[undefined,undefined]

//例一
function f(x = 1,y){
	return [x,y];
}

f() 	//[1,undefined]
f(2)	//[2,undefined]
f(,1)	//报错
f(undefined,1) 	//[1,1]

//例二
function f(x,y = 5,z){
	return [x,y,z];
} 
f() 	//[undefined,5,undefined]
f(1) 	//[1,5,undefined]
f(1,2) 	//报错
f(1,undefined,2)  //[1,5,2] 这里有默认值的参数不是尾参数，这时，无法只省略该参数，而不是省略它后面的参数，除非显式输入undefined。

function foo(x=5,y=6){
	console.log(x,y);
}

foo(undefined,null)
//5 null

(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

var x = 1;
function f(x,y = x){
	console.log(y);
}
f(2)  //2 上面代码中，参数y的默认值等于x。调用时，由于函数作用域内部的变量x已经生成，所以y等于参数x，而不是全局变量x。如果调用时，函数作用域内部的变量x没有生成，结果就会不一样。

let x  = 1;

function f(y = x){
	let x =2;
	console.log(y)
}
f() //1 函数调用时，y的默认值变量x尚未在函数内部生成，所以x指向全局变量

function f(y = x){
	let x =2;
	console.log(y);
}
f() //ReferenceError : x is not defined

let foo = 'outer';
function bar(func = x => foo){
	ley foo =  "inner";
	console.log(func()); //outer
}
bar(); 函数bar的参数func的默认值是一个匿名函数，返回值为变量foo。这个匿名函数声明时，bar函数的作用域还没有形成，所以匿名函数里面的foo指向外层作用域的foo，输出outer。

function bar(func =() => foo){
	let foo = 'inner';
	console.log(func());
}

bar() //ReferenceError: foo is not defined 匿名函数里面的foo指向函数外层，但是函数外层并没有声明foo，所以就报错了。

var x = 1;
function foo (x,y = function(){ x = 2;}){
	var x = 3;
	y();
	console.log(x);
}
foo() //3 函数foo的参数y的默认值是一个匿名函数，函数foo调用时，它的参数x的值为undefined，所以y函数内部一开始是undefined，后来被重新赋值为2.但是，函数foo内部重新声明了一个x，值为3，这两个x是不一样的，互相不产生影响，因此最后输出3。

var x =1 ;
function foo(x,y = function(){x =2;}){
	x = 3;
	y();
	console.log(x);
} 
foo() //2

function throwIfMissing(){
	throw new Error('Missing parameter');
}
function foo(mustBeProvided = throwIfMissing()){
	return mustBeProvided;
}
foo();
//Error: Missing parameter

function add(...values){
	let sum = 0;
	
	for(var val of values){
		sum += val;
	}
	
	return sum;
}
add(2,5,3) //10 上面代码的add函数是一个求和函数，利用rest参数，可以向该函数传入任意数目的参数

//arguments变量的写法
function sortNumbers(){
	return Array.prototype.slice.call(arguments).sort();
}

//rest参数的写法
const sortNumbers = {...numbers} => numbers.sort(); 可以发现rest参数的写法更加自然也更加简洁

function push(array, ...items){
	items.forEach(function(item){
		array.push(item);
		console.log(item);
	});
}

var a = [];
push(a,1,2,3); 注意，rest参数之后不能再有其他参数(即只能是最后一个参数)，否则会报错。

//报错
function f(a, ...b,c){
	//...
} 函数的length属性，不包含rest参数

(function(a){}).length //1
(function(...a){}).length //0
(function(a, ...b){}).length //1

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

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

[...document.querySelectorAll('div')]
//[<div>,<div>,<div>]

function push(array,...items){
	array.push(...items);
}

function add(x,y){
	return x+y;
}

var numbers = [4,38];
add(...numbers) //42 array.push(...items)和add(...numbers)都是函数的调用，都使用了扩展运算符将一个数组变为参数序列

//ES5的写法
function f(x,y,z){
	//...
}
var args = [0,1,2];
f.apply(null,args);

//ES6的写法
function f(x,y,z){
	// ...
}

var args = [0,1,2];
f(...args);

//ES6的写法
Math.max(...[14,3,77])

//等同于	
Math.max(14,3,77) JavaScript不提供求数组最大元素的函数，所以只能套用Math.max函数，将数组转为一个参数序列，然后求最大值，有了扩展运算符以后，就可以只直接使用Math.max了。

var arr1 = [0,1,2];
var arr2 = [3,4,5];
Array.prototype.push.apply(arr1,arr2);

//ES6的写法
var arr1 = [0,1,2];
var arr2 = [3,4,5];
arr1.push(...arr2); push方法的参数不能是数组，所以只好通过applay方法变通使用push。有了扩展运算符，就可以直接将数组传入push方法。

function foo(){}
fo.name //"foo" 这个属性早就被浏览器广泛支持，但是直到es6，才将其写入标准。

var func1 = function (){}

//ES5
func1.name //""

//ES6	
func1.name //"func1" func1等于一个匿名函数，ES5和ES6的name属性返回值不一样。 如果将一个具名函数赋值给一个变量，则ES5和ES6的name属性都返回这个具名函数原本的名字。

const bar = function baz(){}

//ES5
bar.name //"baz"

//ES6
bar.name //"baz" Function构造函数返回的函数实例，name属性值为"anonymous"。

(new Function).name //"anonymous" binde返回的函数，name属性值会加上"bound"前缀。

function foo(){}
foo.bind({}).name //"bound foo"

(function(){}).bind({}).name  //"bound"

var f = v => v; 上面的箭头函数等同于；

var f = function (v){
	return v;
}

var f = () => 5;
//等同于
var f = function () {return 5};

var sum = (num1,num2) => num1 + num2;
//等同于
var sum = function(num1,num2){
	return num1 + num2;
} 如果箭头函数的代码块部分多于一条语句，就要使用大括号将它们括起来，并且使用return语句返回

var sum = (num1,num2) => {return num1 + num2;} 由于大括号被解释为代码块，所以如果箭头函数直接返回一个对象，必须在对象外面加上括号。

var getTempItem = id => ({id:id,name:"Temp"}); 箭头函数可以与变量解构结合使用。

const full = ({first,last}) => first + ' ' +last;

//等同于
function full(person){
	return person.first + '' +person.last;
} 箭头函数使得表达更加简洁

const isEven = n => n%2 == 0;
const square = n => n*n; 上面代码只用了两行，就定义了两个简单的工具函数。如果不用箭头函数，可能就要占用多行，而且还不如现在这样写醒目。

//正常函数写法
[1,2,3].map(function (x){
	return x * x;	
});
//箭头函数写法
[1,2,3].map(x => x*x);

//正常函数写法
var result = values.sort(function (a,b){
	return a - b;
});
//箭头函数写法
var result = values.sort((a,b) => a-b); 同样，rest参数与箭头函数也可以混合使用

const numbers = (...nums) => nums;

numbers(1,2,3,4,5)
//[1,2,3,4,5]

const headAndTail = (head, ...tail) => [head,taill];

headAndTail(1,2,3,4,5)
//[1,[2,3,4,5]]

function foo(){
	setTimeout(() => {
		console.log('id',this.id);
	},100);
}
var id = 21;

foo.call({id:42});
//id:42 setTimeout的参数是一个箭头函数，这个箭头函数的定义生效在foo函数生成时，而它的真正执行要等到100毫秒后。如果是普通函数，执行时this应该指向全局对象window，这是应该输出21.但是，箭头导致this总是指向函数定义生效时所在的对象，所以输出的是42。

function Timer(){
	this.s1 =0;
	this.s2 =0;
	//箭头函数
	setInterval(() => this.s1++,1000);
	
	//普通函数
	setInterval(function(){
		this.s2++;
	},1000);
}

var timer new Timer();

setTimeout(() => console.log('s1:',timer.s1),3100);
setTimeout(() => console.log('s2:',timer.s2),3100);
//s1:3
//s2:0 Timer函数内部设置了两个定时器，分别使用了箭头函数和普通函数。前者的this绑定定义时所在的作用域(即Timer函数)，后者的this指向运行时所在的作用域(全局对象)。所以，3100毫秒之后，timer.s1被更新了三次，而timer.s2一次都没有更新。

var handler = {
	id:'123456',

	init:function(){
		document.addEventListener('click',
		event => this.doSomething(event.type),false);
	},

	doSomething: function(type){
		console.log('Handling' + type + 'for' + this.id);
	}
}; init方法中使用了箭头函数，这导致这个箭头函数里面的this，总是指向handler对象。否则，回调函数运行时，this.doSomething这一行会报错，因为此时this指向document对象。

//ES6
function foo(){
	setTimeout(() => {
		console.log('id:',this.id);
	},100);
};

//ES5
function foo(){
	var _this = this;

	setTimeout(function (){
		console.log("id:",_this.id);
	},100);
}; 请问下面的代码之中有几个this?

function foo(){
	return () =>{
		return () => {
			return () =>{
				console.log('id:',this.id);
			};
		};
	};
}
var f = foo.call({id:1});

var t1 = f.call({id:2})()();  //id:1
var t2 = f().call({id:3})();	//id:1
var t3 = f()().call({id:4});	//id: 1 上面代码，只有一个this，就是函数foo的this，所以t1、t2、t3都输出同样的结果，因为所有内层函数都是箭头函数，都没有自己的this，它们的this都是最外层foo函数的this。

function foo(){
	setTimeout(() =>{
		console.log('args:',arguments);
	},100);
}

foo(2,4,6,8)
//args:[2,4,6,8] 上面代码中，箭头函数内部的变量arguments，其实是函数foo的arguments变量。

(function(){
	return[
		(() => this.x).bind({x:'inner'})()
	];
}).call({x:'outer'});
//['outer'] 上面代码中，箭头函数没有自己的this，所以bind方法无效，内部的this指向外部的this。 长期以来，JavaScript语言的this对象一直是一个令人头痛的问题，在对象方法中使用this，必须非常小心。箭头函数"绑定"this,很大程度上解决了这个困扰。

function ionsert(value){
	return {into:function (array){
		return {after: function (afterValue){
			array.splice(array.indexOf(afterValue) + 1,0,value);
			return array;
		}};
	}};
}
insert(2).into([1,3]).after.(1);//[1,2,3] 上面这个函数，可以使用箭头函数改写。

let insert = (value) => ({into:(array) => ({after:(afterValue) =>{
		array.splice(array.indexOf(afterValue) + 1, 0,value);
		return array;
	}})
});
insert(2).into([1,3]).after(1);//[1,2,3];

const pipeline =(...funcs) =>
	varl => funcs.reduce((a,b) => b(a),val);
const plus1 = a => a + 1;
const mult2 = a => a * 2;
const addThenMult = pipeline(plus1,mult2);

addThenMult(5);
//12 如果觉得上面的写法可读性比较差，也可以采用下面的写法。

const plus1 = a => a +1;
const mult2 = a => a *2;

mult2(plus1(5))
//12

foo::bar;
//等同于
bar.bind(foo);

foo::bar(...arguments);
//等同于
bar.apply(foo,arguments);

const hasOwnProperty = Object.prototype.hasOwnProperty;
function hasOwn(obj,key){
	return obj::hasOwnProperty(key);
} 如果双冒号左边为空，右边是一个对象方法，则等于将该对象绑定在该对象上面。

var method = obj :: obj.foo;
//等同于

var method = ::obj.foo;

let log = :: console.log;
//等同于
var log = console.log.bind(console); 由于双冒号运算符返回的还是原对象，因此，可以采用链式写法。

//例一
import {map,takeWhile,forEach } form "iterlib";

getPlayers()

::map(x => x.character())
::takeWhile(x => x.strength >100)
::forEach(x => console.log(x));

//例二
let {find,html} = jake;

document.querySelectorAll("div.myClass");
::find("p")
::html("hahaha");

function f(x){
	return g(x);
} 函数f的最后一步是调用函数g，这就叫尾调用。

//情况一
function f(x){
	let y = g(x);
	return y;
}
//情况二
function f(x){
	return g(x) +1;
}
//情况三
function f(x){
	g(x);
} 上面这三种情况都不是尾调用，情况一是电泳函数g之后，还有赋值操作，所以不属于尾调用。情况二属于调用后还有操作。 情况三同	
	
function f(x){
	g(x);
	return undefined;
} 所以也不是尾调用。

function f(x){
	if (x > 0){
		return m(x)
	}
	return n(x);
} 函数m和n都属于尾调用，因为它们都是函数f的最后一步操作

function f(){
	let m =1;
	let n =2;
	return g(m + n);
}
f();

//等同于
function f(){
	return g(3);
}
f();

//等同于
g(3); 上面代码中，如果函数g不是尾调用，函数f就需要保存内部变量m和n的值、g的调用位置等信息。但由于调用g之后，函数f就结束了，所以执行到最后一步，完全可以删除f(x)的调用帧。只保留g(3)的调用帧。

function addOne(a){
	var one =1;
	function inner(b){
		return b + one;
	}
	return inner(a);
} 上面的函数不会进行尾调用优化，因为内层函数(inner)用到了外层addOne的内部变量one。

functioon factorial(n){
	if(n ===1) return 1;
	return n * factorial(n - 1);
}
factorial(5) //120 上面代码是一个阶乘函数，计算n的阶乘，最多需要保存n个调用记录，复杂度O(n)。

function factorial(n,total){
	if (n === 1) return total;
	return factorial(n -1 ,n * tatal);
}
factorial(5,1) //120

function Fibonacci (n){
	if (n <= 1){
		return 1;
	}
	return Fibonacci(n -1) +Fibonacci(n -2);
}
Fibonacci(10);//  89
//Fibonacci(100)
//Finbonacc(500)
//堆栈溢出了 如果我们使用尾递归优化过的fibonacci递归算法

function Finbonacci2(n ,ac1 =1,ac2 = 1){
	if(n <= 1){ return ac2};

	return Fibonacci2(n-1,ac2,ac1 + ac2);
}
Fibonacci2(100) //573147844013817200000
Fibonacci2(1000) //7.0330367711422765e+208
Fibonacci2(10000) //Infinity 由此可见，"尾调用优化"对递归操作意义重大，所以一些函数式编程与雅安将其写入语言规格。ES6也是如此，所有ECMAScript的实现，都必须部署"尾调用优化"。这就是说，ES6中，只要使用尾递归，就不会发生栈溢出，相对节省内存。

function tailFactorial(n,total){
	if (n === 1)
		return total;
	return tailFactorial(n-1,n *total);
}

	return tailFactorial(n,1);
}
factorial(5); //120 上面代码通过一个正常形式的阶乘函数factorial,调用尾递归函数tailFactorial，看起来就正常多了。

function currying(fn,n){
	return function (m){
		return fn.call(this,m,n);
	}
}

function tailFactorial(n,total){
	if (n === 1) return total;
	return tailFactorial(n-1,n*total);
}

const factorial = currying(tailFactor,1);

factorial(5) //120 上面代码通过柯里化，将尾递归函数tailFactorial变为只接受1个参数的factorial。

function factorial(n,total = 1){
	if (n === 1)
		return total;
	return factorial(n-1,n * total);
}
factorial(5) //120 上面代码中，参数total有默认值1，所以调用时不用提供这个值。

function restricted(){
	"use strict";
	restructed.caller;//报错
	restricted.arguments;//报错
}
restricted();

function clownsEverywhere(param1,param2){
	//...
}
clownsEverywhere('foo','bar'); 如果以后要遭函数的定义之中添加参数，就势必还要添加一个逗号，这对版本管理系统来说，就会显示，添加逗号的哪一行也发生了变动。这看上去有点冗余，因此，新提案允许定义和调用时，尾部直接有一个逗号。

function clownsEverywhere(param1,param2,){}

clownsEverywhere('foo','bar',);