ECMAScript6学习笔记

ECMAScript6学习

5/26/2017 4:10:34 PM

块的作用域

使用let关键字绑定变量的作用域范围，被let修饰的关键字是不能在外部被引用的。

块作用域使用{}来标识

{
let name = 'zs';
}
console.log(name);

const恒量

被const修饰的变量不能修改它的引用

const fruit = 'apple';
fruit = 'pear'; //不能修改fruit引用值

但是可以改变变量所引用值的内容，如下：

const fruit = [];
fruit.push('apple');
fruit.push('orange');
console.log(fruit);

结构数组

//解构对象
function tool() {
return {knif: 'knif1', hork: 'hork1'};
}

let {knif: k, hork: h} =tool();
console.log(k, h);

模板字符串

将会把变量替换成相应的字符串

var dessert = '甜点';
var breakfast = `今天的早餐是${dessert}`;
console.log(breakfast);
//输出的是：今天的早餐是甜点

带标签的模板字符串

var dessert = '甜点';
var drink = '豆奶';
var breakfast = kitchen`今天的早餐是${dessert}和${drink}!`;

function kitchen(stirngs, ...values) {
console.log(stirngs);   //strings是["今天的早餐是", "和", "!"]
console.log(values);    //values就是字符串中的变量
}

判断字符串里是否包含其他字符串

判断字符串是否以某个字符串开头：

startsWith(pattern);

判断字符串是否以某个字符串结尾：

endsWith(pattern);

判断字符串是否包含某个字符串

includes(pattern);

默认参数

function breakfast (dessert = '默认') {
//函数体
}

展开操作符

会将数组拆分成单个元素输出,Spread

var fruit = ['apple', 'orange'];
console.log(...fruit);

将一个数组的元素放到另一个数组中

var fruit = ['apple', 'orange'];
var breakfast = ['rice', ...fruit];

剩余操作符Rest

用途：放在方法形参列表的最后，传入多于的实参都将放到最后的那个数组中

//剩余操作符
function reset(apple, orange, ...breakfast) {
console.log(breakfast);
}
reset('apple', 'orange', 'knif', 'chopsticks');

结果为：[“knif”, “chopsticks”]

解构参数

function breakfast (dessert, drink, {location, restaurant} = {}) {
console.log(dessert, drink, location, restaurant);
}

breakfast('cake', 'juice', {location:'福建', restaurant:'白天鹅'});

函数的名字

console.log(breakfast.name);

箭头函数

let breakfast = (dissert,drink) => {
return dissert + drink;
};
console.log('cake', 'juice');

对象表达式

let breakfast = {
dissert: 1,
drink: 1
}

如果breakfast的dissert属性的值为dissert，则可省略冒号和后面的变量名

let breakfast = {
dissert,
drink
}

在对象里面声明方法，只需在属性名后面加上“(){}”

let breakfast = {
dissert,
drink,
fun(){
return 'hello world';
}
}

对象的属性

对象属性的访问方法有两种，一种是以点的形式，另一种是以中括号的形式。

但是如果属性名中包含有空格，则应该使用中括号的形式

Object.is(value1, value2)判断两个值是否相等

console.log(Object.is(-0, +0)); //false

Object.assign()将对象的值复制到另一个对象里

let breakfast = {};
Object.assign(
breakfast,
{
name: 'zcw',
age: 21
}
);
console.log(breakfast);

输出：Object {name: “zcw”, age: 21}

设置对象的prototype

let breakfast = {
drink(){
return 'apple';
}
}

let dinner = {
drink() {
return 'orange';
}
}

let sunday = Object.create(breakfast);  //根据breakfast创建对象
console.log(sunday.drink());
console.log(Object.getPrototypeOf(sunday) === breakfast);   //true;

Object.setPrototypeOf(sunday, dinner);
console.log(sunday.drink());
console.log(Object.getPrototypeOf(sunday) === dinner);  //true

使用proto属性设置对象的prototype

let breakfast = {
drink(){
return 'apple';
}
}

let dinner = {
drink() {
return 'orange';
}
}

let sunday = {
__proto__: breakfast
}
console.log(sunday.drink());    //apple
console.log(Object.getPrototypeOf(sunday) === breakfast);   //true

sunday.__proto__=dinner;
console.log(sunday.drink());    //orange
console.log(Object.getPrototypeOf(sunday) === dinner);  //true

super

let breakfast = {
drink(){
return 'apple';
}
}

let sunday = {
__proto__: breakfast,
drink(){        //覆盖父类的drink方法，super.drink()调用父类的drink方法
return super.drink() + "haha";
}
}

generators生成器

function* chef(foods) {
for (var i = 0; i < foods.length; i++) {
yield foods[i];
}
}

let zs = chef(['egg', 'water']);
console.log(zs.next());
console.log(zs.next());
console.log(zs.next());

class的使用

class chef {
constructor(food) {
this.food = food;
}

cook(){
console.log(this.food);
}
}

let zs = new chef('egg');
zs.cook();

set、get方法

class chef {
constructor(food) {
this.food = food;
this.dish = [];
}

set menu(data){
this.dish.push(data);
}

get menu() {
return this.dish;
}

cook(){
console.log(this.food);
}
}

let zs = new chef('egg');
zs.menu = "炒鱼";
zs.menu = "冰鸡";
console.log(zs.menu);

静态方法

不用实例化类便使用该类的方法

class chef {

static cook(food){
console.log(food);
}
}

chef.cook("口水鸡");

extends 继承

class Person {
constructor(name, age) {
this.name = name;
this.age =age;
}

intro() {
console.log(`${this.name},${this.age}`);
}
}

class Chef extends Person {
constructor(name, age) {
super(name, age);
}
}

let zs = new Chef('张三', 22);
zs.intro();

Set

它里面不能有重复的元素

let s = new Set('abc');
console.log(s);

添加

s.add('d');

查看是否包含

s.has('a');

删除

s.delete('a');

遍历

s.forEach(ele => {
console.log(ele);
})

清空

s.clear();

大小

s.size

map

定义

let food = new Map();

添加元素（对象，方法，字符串）

food.set(fruit, 'apple');
food.set(cook, 'hot');
food.set(dessert, 'cookie');

获取元素

console.log(food.get(cook));

大小

console.log(food.size);

删除指定元素

food.delete(fruit);

检查是否存在

console.log(food.has(cook));

遍历map

food.forEach((value, key) => {
con
4000
sole.log(`${key}:${value}`)
})

清空

food.clear();

module

暂时空

5/27/2017 8:28:00 AM