Es6

let

块级作用域 在{ }里定义,只能在{ }里使用;
let在循环里可以解决下标问题

const常量

如果是值类型,不能被修改 + 具备Let的块级作用域
如果是引用类型, 值可以被修改,类型不能修改
如果要修改 可以:Object.freeze()//冻结

eg:
//常量命名大写
//定义的对象的值不能被修改?
consrt COOLMAN={name:"周杰伦"}
Object.freeze(COOLMAN)
COOLMAN.name="蔡依林'
console.log(COOLMAN)//蔡依林

//定义的对象的值不能被修改?
const COOLMAN={ }
Object.defineProperty(COOLMAN,"name",{
value:"周杰伦",
configurable:true,//能被删除,fasle 不能被删除
enumerable:true,//能遍历,fasle 不能遍历
writable:true//可以修改,fasle不能修改
})

对字符串的增强

includes()//判断是否有
startsWith()//判断开始位置是否有
endsWith()//判断结束位置是否有

字符串模板

``
${ }

数组增强

Array.from() //把伪数组转换为真数组,可以有两个参数,第二个参数可以是一个回调函数
Array.of()//把伪数组转换为真数组
find 找到反回数组
findindex()找到反回下标

for of()

不太适合遍历对象,更适合遍历数组

var o={
name:"周杰伦",
age:20,
address:"中国"
}
for(var key of Object.key(o)){
console.log(key);
}
for(var v of Object.values(o)){
console.log(v);
}
for(var [k,v] of Object.entries(o)){
console.log(k,v);
}

for(var key in o){
console.log(key);
console.log(o[key])
}

默认参数

function aaa(str="你好"){
console.log(str)
}
aaa("大家好")

箭头函数

//箭头函数的this默认指向window,
上下文(环境的this是谁,就指向谁)
当参数只有一个的时候 只有一句话的时候,可以省略括号

var fn =(a,b)=>{return a*b}

展开运算符(扩展运算符)

var arr =[11,22,33,44,55,66]
//求最大数
console.log(Math.max(...arr))
//求最小数
console.log(Math.min(...arr))

求最大值和最小值

   var arr =[11,22,33,44,55,66];
      var max=arr[0];
      var min=arr[0];
      for(var i=1;i<arr.length;i++){
       if(max<arr[i]){
        max=arr[i]
       }
       if(min>arr[i]){
        min=arr[i]
       }
      }
      console.log(max,min);
//最小值
      arr.sort((a,b)=>a-b);
      console.log(arr[0]);

Object.is( , )

用来比较两个值是否严格相等。它与严格比较运算符（===）的行为基本一致， 不同之处只有两个：
一.是+0不等于-0，
二.是NaN等于自身

Object.assign() 方法 //枚举

• 1.可合并对象,
• 2 .Object.assign()拷贝(浅拷贝)
  用来将源对象（source）的所有可枚举属性，复制到目标对象（target）。它至少需要两个对象作为参数，第一个参数是目标对象，后面的参数都是源对象。只要有一个参数不是对象，就会抛出TypeError错误。

  var target = { a: 1 };
    var source1 = { b: 2 };
    var source2 = { c: 3 };
    Object.assign(target, source1, source2);
    console.log(target) // {a:1, b:2, c:3}

   var o1={name:'刘德华'}
        var o2={age:20}
        var o3={name:'蔡依林',sex:'女'}
     
        function myAssign(){
            var list=Array.from(arguments);
            for (let i = 0; i < list.length; i++) {
                for(var key in list[i]){
                    list[0][key]=list[i][key]
                }                
            }
            return list[0]
        }
        var obj=myAssign(o1,o2,o3);
        console.log(obj);

Set

数据结构Set类似于数组，但是成员的值都是唯一的，没有重复的值。
(只能用 for of 遍历)

     var set = new Set([1,2,3,4,5,5,5,5]);
     console.log(set.size); 

Set的属性和方法:
size : 数量
set.size()//等价与数组的length
add(value)：添加某个值，返回Set结构本身
delete(value)：删除某个值，返回一个布尔值，表示删除是否成功
has(value)：返回一个布尔值，表示该值是否为Set的成员
clear()：清除所有成员，没有返回值

WeakSet:

(WeakSet 没有size属性，没有办法遍历它的成员)
WeakSet和Set一样都不存储重复的元素, 用法基本类似，但有一些不同点, WeakSet的成员只能是对象，而不能是其他类型的值。

Map:

Map 是一个“超对象”，key和值可以是任意类型a

  let map = new Map([[1, 'one'],[2, 'two'],[3, 'three']]);

他的方法和 Set 差不多:
size：返回成员总数。
set(key, value)：设置一个键值对。
get(key)：读取一个键。
has(key)：返回一个布尔值，表示某个键是否在Map数据结构中。
delete(key)：删除某个键。
clear()：清除所有成员。
keys()：返回键名的遍历器。
values()：返回键值的遍历器。
entries()：返回所有成员的遍历器。

解构赋值

数组的扁平化

(把一维数组变成多维数组)

 //方式一
      var arr=[1,[2,[3,4],5],6];
      function fn(arr){
        return arr.toString().split(",").map(el=>Number(el))
      }
      console.log(fn(arr));
      //方拾二
     var arr=[1,[2,[3,4],5],6];
      var arr2=arr.flat(2);
      console.log(arr2);

内置对象

String,Array,Date,Function,Object,Map,Set

• 1.什么是类
  类是抽象的,是模板,把相同的属性和方法提取成为一个类;
  类是对象的模板;
  对象是类的实例
  类需要通过new运算符进行实例化

• 2.什么是继承
  子类继承父类的属性和方法

class Student{
  constructor(){
}
}

//人类
  class Person{
      constructor(name,age,sex){
        this.name=name;//属性
        this.age=age;
        this.sex=sex;
      }
      //行为
      eat(){
        console.log("人类的吃饭行为");
      }
    }
    //学生
    class Student extends Person{
      constructor(sno,name,age,sex){
        super(name,age,sex);
        this.sno=sno
      }
      daydayup(){
        console.log("爱写代码");
      }
    }
    var stu=new Student("1000","刘德华","20","男")
    stu.eat();
    stu.daydayup()

类.方法
不需要实例化,就是静态方法

Symbol()

表示独一无二(标识符)
它不能做运算,

Symbol.for()

symbol一些运用场景

var a=Symbol();
var b=Symbol();
console.log(a==b)//false
//
var a=Symbol.for("a")//如果没有a,就创建
var b=Symbol.for("a")//如果有a就获取
cosole.log(a==b)//true
//
var obj={
[a]:function(){
console.log("111")
}
name:"刘德华"
}
console.log(obj)
obj[a]()
for(var key in obj){
console.log(key)
}
//

函数生成器

   function* show(n){
        var res1=yield n+2;
        var res2=yield n+4
        return 100;
      }
    var f=show(10);
    console.log(f.next());
    console.log(f.next());
    console.log(f.next());