面向对象

  • Object对象常用方法
  • 原型和原型链
  • es6构造函数
  • es6静态属性和方法


Object对象常用方法

Object.assign()             1个值拷贝，两个值改变第一项合并，三个值以上改变第一项合并，可以用空对象代替第一项

Object.defineProperty()     设置对象属性。值1为对象名，值2为对象属性，值3为设置属性
		configurable:false 不能删除属性 ，true可以删除属性(默认false)
		enumerable:false 为不能枚举，true为可枚举(默认false，为false则不能遍历)
		value 改变属性值
		writable:false 不能改变属性值，true可以改变属性值(默认false)

		get() 获取该属性时，会调用get方法
		set() 设置该属性时，会调用set方法

Object.entries()           将对象转为二维数组（仅限可枚举属性）

Object.keys()              获取对象所有键（仅限可枚举属性）

Object.values()            获取对象所有值（仅限可枚举属性）

Object.getOwnPropertyNames(obj)    获取对象所有键（包括不可枚举属性）

Object.freeze()            对象冻结，即对象不能被改变了

Object.is()                判断两个值是否相等,类似于===（特例两个NaN用is比较是相等的，正负零用is比较是不相等的）

Object.getPrototypeOf()    获取对象原型

Object.setPrototypeOf()    设置对象原型

对象名.hasOwnProperty(属性) 判断对象是否包含某个属性
let obj = {a: 1,b: 2}
        Object.defineProperty(obj, "a", {
            configurable: false,
            enumerable: false,
            value: 5,
            writable: false
        })
        for (var k in obj) {
            console.log(k)  //b 因为obj的a的enumerable为false，所以不能遍历a
        }
        console.log(obj);  //{b:2;a:5} 设置a的值为5了
        Object.defineProperty(obj, "c", {
            // enumerable: true,
            value: 4
        })
        console.log(obj);   //{b: 2, a: 5, c: 4}

        let objarr = Object.entries(obj);
        console.log(objarr)

        let objallkey = Object.keys(obj);
        console.log(objallkey) //["b"] 因为a和c都不是可枚举属性。b是原生的，所以可枚举

        let objallval = Object.values(obj);
        console.log(objallval)  //[2]

        let allkeys = Object.getOwnPropertyNames(obj);
        console.log(allkeys); //["a","b","c"] 获取对象所有键，包括不可枚举的

        Object.freeze(obj)

        // Object.getPrototypeOf()
        // Object.setPrototypeOf()
        function Person(name) {
            this.name = name;
        }
        Person.prototype.syaName = function () {
            console.log(this.name)
        }
        function banban(name, age) {
            Person.call(this, name);   //call ,修改this指向为name
            this.age = age;
        }
        //将banban的原型设置为Person的原型
        Object.setPrototypeOf(banban.prototype, Person.prototype) 

        let yanyan = new banban("kuku", 18);
        console.log(yanyan)//banban{name:"kuku",age:18}原型中有Person，Person的原型中有sasName


        let obj2 = {
            a: 4,
            b: 5,
            c: 6
        }
        console.log(obj2.hasOwnProperty("c")); //true 对象包含c这个属性

原型和原型链

  1. 原型：（自己写都是prototype，打印台都是_proto）
    所有function函数共用的属性 prototype
    所有对象共用的属性 _ proto _
  2. 原型链：对象通过prototype找到共有的属性
    let A = function(){}
    let a = new A();
    对象a的属性中没有的，则找A.ptototype中共有的，没有则再找Object.prototype中共有的，再没有就确实没有了为null

es6构造函数

  • 继承要改写父类构造方法，需要加上super(父类构造函数参数)
  • 继承要重写父类方法，直接改就行
class Person {
            //有参构造
            constructor(name, age) {
                this.name = name;
                this.age = age;
            }
            //直接写在类中的方法都会加载到原型中（原型：prototype/ _proto_）
            chat(content) {
                console.log(this.name + "说了" + content);
            }
        }
        
        //继承
        //在子类中不写 constructor 会直接继承父类的 constructor
        class Girl extends Person {
            //子类要重新定义构造函数时，需要加super()
            //并且super()中要加上，父类构造函数的形参
            //子类新增形参：同样需要this处理
            constructor(name, age, job) {       
                super(name, age);
                this.job = job;
            }

            //改写方法，直接改！
            chat() {
                console.log(this.name + "说了");
            }
        }
        let p = new Person("小三", 18);
        console.log(p);
        let g = new Girl("傻女子", 3, "代购");
        console.log(g);

es6静态属性和方法

  • 静态属性和方法前面加上static
  • 静态只能通过类名调用
  • 静态不能被继承
class Person {
            //有参构造
            constructor(name, age) {
                this.name = name;
                this.age = age;
            }
            //直接写在类中的方法都会加载到原型中（原型：prototype/ _proto_）
            chat(content) {
                console.log(this.name + "说了" + content);
            }

            //静态方法需要在方法前加 static 并且调用时用类名调用
            static like() {
                console.log(this.name);
            }
        }

        let p = new Person("kk", 18);
        console.log(p.chat);
        console.log(Person.like);