ES6中常用的10个新特性

1.不一样的变量声明：const和let

    let和var的区别：let是块级作用域，即局部变量；var是全局作用域
    
	let和const的区别：let和const都是块级作用域,let是变量；const是常量,一旦声明，值不能在改变

		var x = '全局变量';
		{
		  let x = '局部变量';
		  console.log(x); // 局部变量
		}
		console.log(x); // 全局变量

		const a = 1
		a = 0 //报错

tip:
	如果const的是一个对象，则对象所包含的值是可以被修改的（const的是地址，不是值）

		const student = { name: 'cc' }

		student.name = 'yy';// 不报错
		student  = { name: 'yy' };// 报错

		let 关键词声明的变量不具备变量提升（hoisting）特性
		let 和 const 声明只在最靠近的一个块中（花括号内）有效
		当使用常量 const 声明时，请使用大写变量，如：CAPITAL_CASING
		const 在声明时必须被赋值

2.模版字符串

在es6中，用${}和反引号来代替“+”

		es5:
		$('.app').html('hello world'+a)
		
		es6:
		$('.app').html(`hello world,${a}`)

3.箭头函数（Arrow Functions）

箭头函数的形式：()=>

不需要 function 关键字来创建函数
省略 return 关键字
继承当前上下文的 this 关键字

	es5:
	let fun=function (a,b){
	return a+b
}
	es6:
	let fun=(a,b)=>a+b

	// ES5
	[1,2,3].map((function(x){
	    return x + 1;
	}).bind(this));
	    
	// 使用箭头函数
	[1,2,3].map(x => x + 1);
		
tip:当且仅当有一个值的时候，是不需要括号的

4.函数的参数默认值

	// ES6之前，当未传入参数时，text = 'default'；
	function printText(test) {
	    test= test|| 'default';
	    console.log(test);
	}
	
	// ES6；
	function printText(test= 'default') {
	    console.log(test);
	}
	
	printText('hello'); // hello
	printText();// default

5.Spread / Rest 操作符

Spread / Rest 操作符指的是 ...，具体是 Spread 还是 Rest 需要看上下文语境。

当被用于迭代器中时，它是一个 Spread 操作符：

	 function foo(x,y,z) {
     console.log(x,y,z)
	 }
	 let arr=[7,8,9]
	 foo(...arr) //7,8,9
	  function f(...arr) {
	      console.log(arr)
	  }
	  f(1,2,3,4,5,5,5,5) //[1,2,3,4,5,5,5,5]	
</script>

6.二进制和八进制字面量

ES6 支持二进制和八进制的字面量，通过在数字前面添加 0o 或者0O 即可将其转换为八进制值：

	let oValue = 0o10;
	console.log(oValue); // 8
	 
	let bValue = 0b10; // 二进制使用 `0b` 或者 `0B`
	console.log(bValue); // 2

7.对象和数组解构

	    // 对象
    const student = {
        name: 'john',
        age: 22,
        sex: '女'
    }
    // ES5；
    const name = student.name;
    const age = student.age;
    const sex = student.sex;
    console.log(name + ' --- ' + age + ' --- ' + sex);

    // ES6
    const { name, age, sex } = student;
    console.log(name + ' --- ' + age + ' --- ' + sex);

8.对象超类

ES6 允许在对象中使用 super 方法：

		let parent = {
        foo() {
            console.log("Parent");
        }
	    }
	
	    let child = {
	        foo() {
	            super.foo();
	            console.log("Child");
		        }
		    }
	
	    Object.setPrototypeOf(child, parent);
	    child.foo(); // Parent
	                 // Child

9.for…of 和 for…in

for...of 用于遍历一个迭代器，如数组：

		let letters = ['a', 'b', 'c'];
		letters.size = 3;
		for (let letter of letters) {
		  console.log(letter);
		}
		// 结果: a, b, c

for...in 用来遍历对象中的属性：

	 let stus = ["john", "22", "女"];
	 for (let stu in stus) {
	   console.log(stus[stu]);
	  }
	// 结果: john, 22, 女

10.ES6中的类

ES6 中支持 class 语法，不过，ES6的class不是新的对象继承模型，它只是原型链的语法糖表现形式。

函数中使用 static 关键词定义构造函数的的方法和属性：

	class Student {
	  constructor() {
	    console.log("I'm a student.");
	  }
	 
	  study() {
	    console.log('study!');
	  }
	 
	  static read() {
	    console.log("Reading Now.");
	  }
	}
	 
	console.log(typeof Student); // function
	let stu = new Student(); // "I'm a student."
	stu.study(); // "study!"
	stu.read(); // "Reading Now."

类中的继承和超集：

	  class Phone {
        constructor() {
            console.log("I'm a phone.");
        	}
	    }
	
	    class MI extends Phone {
	        constructor() {
	            super();
	            console.log("I'm a phone designed by xiaomi");
	        }
	    }
	
	    let mi8 = new MI();//I'm a phone.
		                   // I'm a phone designed by xiaomi

tip:
extends 允许一个子类继承父类，需要注意的是，子类的constructor 函数中需要执行 super() 函数。
当然，你也可以在子类方法中调用父类的方法，如super.parentMethodName()。
有几点值得注意的是：

类的声明不会提升（hoisting)，如果你要使用某个 Class，那你必须在使用之前定义它，
否则会抛出一个 ReferenceError 的错误
在类中定义函数不需要使用 function 关键词