ES6对象

小技巧

1. 属性简写:属性名和属性值相同，只写属性值即可

2. 方法简写：方法名和方法相同，只写方法即可

  function createUser(loginId,loginPwd,nickName){
            const say = function(){
                console.log(loginId,nickName)
            }
            return {
               loginId,//1.属性简写
               loginPwd,
               nickName,
               say,//2.方法简写
               fun(){//方法速写，不是箭头函数
                   console.log(this.loginId)
               },
            //    "fun" : function(){
                   
            //    }
            }
        }
        const user = createUser("01","123456","abc")
        console.log(user)

1. 计算属性名：对象的属性名可以引用变量值 [变量名]

const prop1 = "name";
const prop2 = "age";
const prop3 = "say";
const user = {
     [prop1] : "老师",
     [prop2] : 30,
     [prop3](){
         console.log(this[prop1],this[prop2])
   } 
}
console.log(user)

 新增API

is() 判断两个值是否相等，类似于===，除NaN和0

        is()
        console.log(NaN === NaN)//false
        console.log(+0 === -0)//true

        console.log(Object.is(NaN,NaN))//true
        console.log(Object.is(+0,-0))//false
        console.log(Object.is({},{}))//false
        console.log(Object.is(1,2))//false

assign() 用于混合对象，带浅克隆

 assign()  ES7
        const obj1 = {
            a : 123,
            b : 456,
            c :789
        }
        const obj2 = {
            a : 789,
            d : "abc"
        }
        // 参数个数不定
        const obj = Object.assign({},obj1,obj2)
        console.log(obj)

getOwnPropertyNames() 获取对象的属性名，返回为一个数组，数组中的数据会枚举出来对象的属性

        const obj = {
            e : 1,
            a : 2,
            c : 3,
            b : 4,
            0 : 5,
            3 : 6,
            1 : 7
        }//对象的属性渲染顺序会按照浏览器厂商规定
        const arr = Object.getOwnPropertyNames(obj)
        console.log(arr)

setPropertypeOf() 设置兑现改的隐式原型 __proto__

   
        const obj1 = {
            a : 1
        }
        const obj2 = {
            b : 2
        }
        // obj1.__proto__ = obj2 // 必须通过构造函数来完成
        Object.setPrototypeOf(obj1,obj2)
        console.log(obj1)

面向对象：class类

 面向对象和面向过程的思想

   // 面向过程 ： 只注重过程（几步），功能较小
        // 1.打开冰箱门
        function openFrige(){}
        // 2.把大象放进去
        function elephantIn(){}
        // 3.关上冰箱
        function closeFrige(){}

        // 面向对象  ： 主要考虑对象个数，对象的参数和方法，针对大型项目和大型模块
        function Elephant(){
            this.tiji = tiji;
        }
        function Frige(){
            this.width = width;
        }
        Frige.prototype.openDoor = function(){}
        Frige.prototype.closeDoor = function(){}
        Frige.prototype.join = function(){}
        let frige = new Frige()
        let ele = new Elephant()


        frige.openDoor()
        frige.join(ele)
        frige.closeDoor()

class类的创建

  // ES6
        class Person{
            constructor(job,name,age,sex){
                this.job = job;
                this.name = name;
                this.age = age;
                this.sex = sex;
                // this.print = function(){
                //     console.log("实例方法")
                //     console.log(`姓名：${this.name},工作：${this.job},年龄：${this.age},性别：${this.sex}`)
                // } 
            }
            print(){
                console.log("原型方法")
                console.log(`姓名：${this.name},工作：${this.job},年龄：${this.age},性别：${this.sex}`)
            }
        }
        const p1 = new Person("程序猿","jack","25","男")
        p1.print()

使用的注意点

 1.类的声明不会被提升，和let const一样，有暂时性死区

 2.类的所有代码全部都是在严格模式下执行

 3.类的所有方法不可被枚举

 4.类的所有方法无法当成构造函数使用

 5.类的构造器必须使用new来调用