15-JavaScript类和对象

• 从ES6开始系统提供了一个名称叫做class的关键字, 这个关键字就是专门用于定义类的
• 通过class定义类, 那么不能自定义这个类的原型对象
• 如果想将属性和方法保存到原型中, 只能动态给原型对象添加属性和方法

ES6运用类创建构造函数

class Person{
    constructor(myName, myAge){         // 当前对象
        this.name = myName;
        this.age = myAge;
        this.hi = function () {
            console.log("hi");
        }
    }
    run(){                              // 保存到原型对象中
        console.log("run");
    }
}

let obj = {
    constructor: Person,
    type: "人",
    say: function () {
        console.log(this.name, this.age);
    }
};
Person.prototype = obj;
let p = new Person("lnj", 34);
console.log(p);

ES6继承性

1. 在子类后面添加extends并指定父类的名称
2. 在子类的constructor构造函数中通过super方法借助父类的构造函数

            ES6(旧) ↓                                                ES6 ↓

function Person(myName, myAge) {               // class Person{
    this.name = myName;                        //     constructor(myName, myAge){
    this.age = myAge;                          //     this.name = myName;
}                                              //     this.age = myAge;
Person.prototype.say =  function () {          // }
    console.log(this.name, this.age);          // say(){
}                                              //     console.log(this.name, this.age);
function Student(myName, myAge, myScore) {     //      }
    // 在子类中通过call或apply方法借助父类的构造函数 //
    Person.call(this, myName, myAge);          // class Student extends Person{
    this.score = myScore;                      //     constructor(myName, myAge, myScore){
    this.study = function () {                 //         super(myName, myAge);
        console.log("day day up");             //         this.score = myScore;
    }                                          //     }
}                                              //     study(){
// 将子类的原型对象设置为父类的实例对象              //        console.log("day day up");
Student.prototype = new Person();              //     }
Student.prototype.constructor = //Student;     //  }
let stu = new Student("zs", 18, 99);           // let stu = new Student("zs", 18, 98);
stu.say();                                     // stu.say();

获取对象类型

• 创建构造函数后，通过console.log(typeof obj);只能获取到数据类型obj无法返回函数名称
• 运用console.log(p.constructor.name);指向原型对象去找到函数名称

let obj = new Object();
console.log(typeof obj); // object

let arr = new Array();
console.log(typeof arr); // object
console.log(arr.constructor.name); // Array

function Person() {
    this.name = "lnj";
    this.age = 34;
    this.say = function () {
        console.log(this.name, this.age);
    }
}
let p = new Person();
console.log(p.constructor.name); // Person

JavaScript-对象关键字

instanceof

instanceof用于判断对象是否是指定构造函数的实例

注意：只要构造函数的原型对象出现在实例对象的原型链（针对继承性）中也会返回true

class Person{ name = "lnj";}
let p = new Person();
console.log(p instanceof Person); // true

class Cat{ name = "mm";}
let c = new Cat();
console.log(c instanceof Person); // false

isPrototypeOf

isPrototypeOf用于判断一个对象是否同时是另一个对象的原型

function Person(myName) {
    this.name = myName;
}
function Student(myName, myScore) {
    Person.call(this, myName);
    this.score = myScore;
}
Student.prototype = new Person();
Student.prototype.constructor = Student;

let stu = new Student();
console.log(Person.prototype.isPrototypeOf(stu)); // true

判断对象属性

1. in的特点: 只要类中或者原型对象中有, 就会返回true

class Person{
    name = null;
    age = 0;
}
Person.prototype.height = 0;

let p = new Person();

console.log("name" in p); // true
console.log("width" in p); // false
console.log("height" in p); // true

2. .hasOwnProperty的特点：只会去类中查找有没有, 不会去原型对象中查找

console.log(p.hasOwnProperty("name")); // true
console.log(p.hasOwnProperty("height")); // false