ES6属性

Es6

变量声明

let：

• 存在块级作用域

• 在同一作用域内不允许重复声明变量

• 存在暂时性死区，只有等到声明变量代码出现，才可以获取和使用变量

• 可以修改变量

相比 var 优点

 for (var index = 0; index < array.length; index++) {  
        }
        console.log(index)
        //var 输出    index=5
        //let     报错

const：

• 存在块级作用域

• 在同一作用域内不允许重复声明变量

• 存在暂时性死区，只有等到声明变量代码出现，才可以获取和使用变量

• 不可以修改变量

优先级：const ------> let --------> var

扩展运算符

合并数组

let arr1=['zhiv','JavaScript',1,2,3]
        let arr2=['year',2024]
        let arr=[...arr1,...arr2]
        console.log(arr)

合并对象：只在第一层进行深拷贝

let obj1={
            name:"lili",
            age:20
        }
        let obj2={
            phone:{
               lihua：123546
                }，
            sex:"女"
        }
        let obj={...obj1,...obj2}
        console.log(obj)

1维数组：深拷贝

2维数组：仅实现第一层深拷贝

数组的结构赋值

 var list=[1,2,3,4,5,6,7,8,9]
            var [a,b,c,...d]=list
            console.log(d)//输出4，5,6,7,8,9

构造函数：Person

• 用 new关键字调用的，首字母大写

• 没有 return 返回值，默认返回this

function Person1 (name) {
        this.name = name
        return 'zhangsan'//最终还是会返回this
        }
        var p1 = new Person1('Tom')
        console.log(p1)

• return复杂数据类型（对象），返回that对象，this对象丢失

  function Person(){
                  this.name=name
                  var that=[1,2,3,4]
                  return that
              }
              var Person=new Person("jack")
              console.log(Person);
              //輸出：1,2,3,4Array.from()

实例成员：实例对象进行访问

function Person(name) {
                this.name=name//实例成员
            }
            console.log(Person.name)//实例对象进行访问

静态成员：构造函数进行访问

Person.height='166'//静态成员
var p1=new Person("tom")//访问时：undefined
console.log(Person.height)//构造函数进行访问

实例化对象

var p1=new Person("tom")

map函数

• 键可以是任意值，包括函数、对象或任意基本类型

• 在频繁增删键值对的场景下表现更好

• 默认情况下不包含任何键，只含显式插入键

• 键是有序的，返回按顺序返回

  简单使用

  var map=new Map()
              //设值
              map.set('a',1)
              map.set('v',4)
              //取值
              console.log(map.get('a'))//1
              //覆盖
              map.set('a',3)
              console.log(map.get('a'))//3
              //检查类似数组的length
              console.log(map.size)//2
              //删除
              map.delete('a')
              console.log(map.size)//1

            var list=["dkj",12,45]
            newList=list.map(function (n) {
                console.log(n)
                //输出 dkj 12 45
                return n*2
            })
            console.log(newList)
            //输出[NaN, 24, 90]

map.size：键值对的数量

map.clear：移除所有键值对

map.selete：删除指定键值对

箭头函数

var f=x=>({name:1})

键名，属性名相同时可以进行简写

var bo={foo:foo}
var bo={foo}

var o={
                method(){
                    return "Hello"
                }
            }
            //等同于
 var o={
                method:function(){
                    return "Hello"
                }
            }

注：简写对象方法时不能用作构造函数

对象的结构赋值

 var obj={
                c:{
                    aa:1,
                    bb:22,
                    cc:{
                        aaaa:1111111
                    }
                }
            }
            var msg=obj.c.aa
            console.log(msg)//输出1
            var msg1=obj.c.bb
            console.log(msg1)//输出22
            var {aa,bb,cc}=obj.c
            console.log(aa)//输出1
            console.log(bb)//输出2

super关键字

• 指向当前对象的原型对象

• Object.setPrototypeOf（）：设置一个对象的原型对象

• Object.getPrototypeOf（）：读取一个对象的原型对象

  var proto={ foo:'hello'}      
  var obj={foo:'world',   
           find(){return super.foo } }  
  //为obj设置原型对象            
  Object.setPrototypeOf(obj,proto)   
  obj.find()             
  console.log( obj.find())//输出hell

属性遍历

对象新增方法

Object.is

• 判断两个值是否相等，与===行为一致

• 不同：+0不等于-0，NaN等于自身

  +0===-0   
  NaN===NaN         
  Object.is(+0,-0)    
  console.log(Object.is(+0,-0));//fslse  
  Object.is(NaN,NaN)         
  console.log(Object.is(NaN,NaN));//true

Object.assign（）

• 用于对象合并，将源对象source可枚举的属性，复制到目标对象target

• Object.assign（）方法第一个参数是目标对象，后面对象是源对象

• Object.assign（）方法是浅复制，遇相同会覆盖

              var target={a:1,b:2}
              var source={b:3,c:5}
              var source1={c:7}
              Object.assign(target,source,source1)
              console.log(target)//输出a:1,b:3,c:7

Object.keys()

• 返回自身的（不含继承）所有可遍历，属性的键名的数组

  var obj={name:"lili",age:23}
  Object.keys(obj)
  console.log(Object.keys(obj))
  //输出 name，age

Object.values（）

• 返回自身的（不含继承）所有可遍历，属性对应值的数组

  var obj={name:"lili",age:23}
  Object.values(obj)
  console.log(Object.values(obj))
  //输出lili，23

Object.entries()

• 返回自身的（不含继承）所有可遍历，属性键值对的数组

var obj={name:"lili",age:23}
Object.entries(obj)
console.log(Object.entries(obj))

Object.formEntries（）

• 将键值对数组转化为对象

   var obj=Object.fromEntries([
                  ["lili","boy"],
                  ["bu",42]
  
              ])
              console.log(obj)
              //输出{lili: 'boy', bu: 42}

filter函数

• 不会对空数组进行检测

• 不会改变原始数组

              var list=["dkj",12,45]
              list.filter(function (n) {
                  console.log(n)
                  return n>3
              })