[JavaScript] - sintaxis básica de clase

En el lenguaje JavaScript, el método tradicional para generar objetos de instancia es a través del constructor. La aparición de la clase es6 puede básicamente reemplazar al constructor y prototipo es5, haciendo que la estructura del código sea más concisa.
1. La forma en que se escribe el constructor es muy diferente de los lenguajes tradicionales orientados a objetos (como C ++ y Java), lo que puede confundir fácilmente a los programadores que son nuevos en js.
2. ES6 proporciona una forma de escritura más cercana a los lenguajes tradicionales, e introduce el concepto de Class (clase) como plantilla para los objetos. Con la palabra clave class, se pueden definir clases.
3. El nuevo método de escritura de clases simplemente hace que el método de escritura del prototipo de objeto sea más claro y más parecido a la sintaxis de la programación orientada a objetos.

ES5 crear objeto

function Person(name, age) {
  this.name = name;
  this.age = age;
}

Person.prototype.sayHi = function () {
  console.log("hello, 我是" + this.name);
};

var p = new Person("lw", 36);
p.sayHi();

ES6 crear objeto

class Person {
  constructor(name, age) {
    this.name = name;		// 属性
  	this.age = age;
  }

  sayHi() {		// 方法
 	console.log("hello, 我是" + this.name);	// sayHi是原型对象的属性
  };
}

var p = new Person("lw", 36);
p.sayHi();

método constructor 

constructor()El método es el método predeterminado de la clase, newque se llama automáticamente cuando el comando genera la instancia del objeto. Una clase debe tener constructor()métodos, si no se definen explícitamente, constructor()se agregará un método vacío de forma predeterminada. (una clase es un constructor)

class Point {
}
​
// 等同于
class Point {
  constructor() {}
}

En el código anterior, se define un punto de clase vacío y el motor de JavaScript le agregará automáticamente un método constructor() vacío. El método constructor() devuelve el objeto de instancia (es decir, this) de forma predeterminada, y puede especificar que devuelva otro objeto.

class Foo {
  constructor() {
    return Object.create(null);
  }
}
​
new Foo() instanceof Foo
// false

En el código anterior, la constructor()función devuelve un objeto completamente nuevo, lo que hace que el objeto de instancia no sea Foouna instancia de la clase.

La clase debe usar la newllamada, de lo contrario se informará un error. Esta es una gran diferencia con los constructores normales, que newtambién se pueden ejecutar sin ellos.

class Foo {
  constructor() {
    return Object.create(null);
  }
}
​
Foo()
// TypeError: Class constructor Foo cannot be invoked without 'new'

 class Person {
      constructor(name, age, gender) {
        this.name = name
        this.age = age
        this.gender = gender
      }
      say() {
        console.log(this.name);
      }
    }

    class Student extends Person {
      constructor(name, age, gender, ss) {
        // super 一定要写在构造函数constructor里面，否则会语法错误
        super(name, age, gender)        // 就如Person.call(this,name,age,gender)
      }
      get m() {            // get是取值函数
        super.say()
      }
    }
    let per = new Person('rose')
    let stu = new Student('jack', 20, '男')
    console.log(stu);    // Student {name: 'jack', age: 20, gender: '男'}

    per.say()    // rose
    stu.m        // jack