ES6

1、变量申明方式

变量申明关键字：let和const，抛弃var

let与const都是只在声明所在的块级作用域内有效。

let声明的变量可以改变，值和类型都可以改变，没有限制。

const声明的变量不得改变值，这意味着，const一旦声明变量，就必须立即初始化，不能留到以后赋值,但可以改变其属性。

理解：let地址可变，const申明的变量指针所指的地址是不能改变的

const a={
    a:1,
    b:"dddd"
};

a.a=5;
a.c=10;
console.log(a.a);
console.log("c",a.c);
delete a.a;
console.log(a);

//运行结果
5
c 10
{ b: 'dddd', c: 10 }

2、三点式运算符

展开运算符（...)

数组展开：

const arr1 = [1, 2, 3];
const arr2 = [...arr1, 10, 20, 30];
// 这样，arr2 就变成了[1, 2, 3, 10, 20, 30];

对象的展开：

// 这种方式在react中十分常用
const props = {
  size: 1,
  src: 'xxxx',
  mode: 'si'
}


const { size, ...others } = props;

console.log(others)

const obj1 = {
  a: 1,
  b: 2, 
  c: 3
}

const obj2 = {
  ...obj1,
  d: 4,
  e: 5,
  f: 6
}

// 结果类似于 const obj2 = Object.assign({}, obj1, {d: 4})

3、类对象Class

class Point {
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }

  toString() {
    return '(' + this.x + ', ' + this.y + ')';
  }
}
Point === Point.prototype.constructor // true

getter

get prop() {
    return 'getter';
}

setter

set prop(value) {
    console.log('setter: '+value);
}

 extends

继承

 

class NewObj extends Object{
  constructor(){
    super(...arguments);
  }
}
var o = new NewObj({attr: true});
o.attr === true  // false

 4、数组

arr.push() 从后面添加元素，返回值为添加完后的数组的长度

let arr = [1,2,3,4,5]
console.log(arr.push(5))   // 6
console.log(arr) // [1,2,3,4,5,5]

arr.pop() 从后面删除元素，只能是一个，返回值是删除的元素

let arr = [1,2,3,4,5]
console.log(arr.pop())     // 5
console.log(arr)  //[1,2,3,4]

 arr.concat() 连接两个数组 返回值为连接后的新数组

let arr = [1,2,3,4,5]
console.log(arr.concat([1,2]))  // [1,2,3,4,5,1,2]
console.log(arr)   // [1,2,3,4,5]

 arr.forEach(value,index,array) 遍历数组,无return

let array = [1,2,3,4];
array.forEach((item, index, array) => {
　　console.log(item);
});

 arr.map(value,index,array) 映射数组(遍历数组),有return 返回一个新数组

let array = [1, 2, 3, 4];
let temp = array.map((item, index, array) => {
　　return item * 10;
});
console.log(temp);　　//  [10, 20, 30, 40];
console.log(array);　　// [1, 2, 3, 4]
// map 遍历数组, 会返回一个新数组, 不会改变原来数组里的内容
let temp2 = array.map(String);　　// 把数组里的元素都转成字符串

arr.filter(value,index,array)过滤数组，返回一个满足要求的数组

let array = [1, 2, 3, 4];
let temp = array.filter((item, index, array) => {
　　return item >  3;
});
console.log(temp);　　// [4]
console.log(array);　　// [1, 2, 3, 4]

arr.every(value,index,array) 依据判断条件，数组的元素是否全满足，若满足则返回ture

let array = [1, 2, 3, 4];
let bo = array.every((item, index, array) => {
　　return item > 2;
});

 arr.some() 依据判断条件，数组的元素是否有一个满足，若有一个满足则返回ture

let array = [1, 2, 3, 4];
let tmep = array.some((item, index, array) => {
　　return item > 1;
});