Kata kunci kelas es6 digunakan untuk mentakrifkan "kelas" dengan cepat; intipati kelas ialah fungsi, yang boleh dianggap sebagai gula sintaksis, menjadikan penulisan prototaip objek lebih jelas dan lebih seperti sintaks bagi pengaturcaraan berorientasikan objek. Tiada promosi boleh ubah semasa mempromosikan kelas Semua kaedah kelas ditakrifkan pada atribut prototaip kelas Memanggil kaedah pada contoh kelas sebenarnya memanggil kaedah pada prototaip.
Persekitaran pengendalian tutorial ini: sistem Windows 7, ECMAScript versi 6, komputer Dell G3.
es6 memperkenalkan konsep Kelas dan kata kunci kelas digunakan untuk mentakrifkan "kelas" dengan cepat. Kaedah penulisan kelas baharu menjadikan penulisan prototaip objek lebih jelas, lebih seperti sintaks pengaturcaraan berorientasikan objek, dan lebih mudah difahami.
Malah, konsep prototaip dan pembina masih digunakan di belakangnya.
Mod ketat Tidak perlu menggunakan penggunaan ketat kerana selagi kod ditulis dalam kelas dan modul, mod ketat hanya boleh digunakan.
Tiada promosi berubah-ubah semasa menambah baik kelas (disebabkan warisan, anda mesti memastikan subkelas ditakrifkan selepas kelas induk).
Semua kaedah kelas ditakrifkan pada atribut prototaip kelas memanggil kaedah pada contoh kelas sebenarnya memanggil kaedah pada prototaip boleh dipanggil melalui objek contoh, tetapi tidak Apabila memanggil melalui nama kelas, ralat akan dilaporkan
Malah, kelas hanyalah Sintaks gula ialah satu lagi cara menulis pembina
(Syntax sugar ialah penyelesaian yang elegan pada peringkat sintaks untuk mengelakkan ralat pengekodan dan meningkatkan kecekapan pengekodan. Ringkasnya, ia adalah mudah alih kaedah penulisan)
Lihat kod
class Person{ } console.log(typeof Person) //funciton console.log(Person.prototype.constructor === Person) //true
Gunakan dan lihat kod
penggunaan adalah sama seperti menggunakan pembina Gunakan baharu untuk menjana contoh objek
class person2 { } let json = new person2;
Sifat dan kaedah yang ditakrifkan dalam pembina ialah sifat contoh. dan kaedah yang dipanggil untuk ini, jika tidak, ia adalah sifat dan kaedah prototaip
class Person { constructor (name) { this.name = name //constructor内定义的方法和属性是实例对象自己的, } say () { //而constructor外定义的方法和属性则是所有实例对象可以共享的 注意! console.log('hello') } } let jon = new Person() jon.hasOwnPrototype('name') //true jon.hasOwnPrototype('say') //false
Kaedah yang boleh dipanggil terus melalui kelas tanpa melepasi objek instance, di mana ini menunjuk kepada kelas itu sendiri
class Person { static doSay () { this.say() } static say () { console.log('hello') } } Person.doSay() //hello *********************************************************************************************** //静态方法可以被子类继承 class Sub extends Person { } Sub.doSay() // hello //静态方法可以通过类名调用,不能通过实例对象调用,否则会报错 class Person { static sum(a, b) { console.log(a + b) } } var p = new Person() Person.sum(1, 2) // 3 p.sum(1,2) // TypeError p.sum is not a function
nama mengembalikan nama kelas, iaitu nama serta-merta mengikuti kelas.
class Person { } Person.name // Person
Jika terdapat ini di dalam kaedah kelas, ralat mungkin akan dilaporkan jika kaedah ini digunakan secara bersendirian
Jika ini menunjuk ke arah yang salah 1. Gunakan fungsi anak panah 2. Ikat dalam pembina ini
class Person { get name () { return 'getter' } set name(val) { console.log('setter' + val) } } let jon = new Person() jon.name = 'jon' // setter jon jon.name // getter
Orang kelas {}
Orang kelas {}
// Pengecam TypeError 'Orang' telah pun diisytiharkan
class Person { constructor(x, y) { this.x = x //默认返回实例对象 this this.y = y } toString() { console.log(this.x + ', ' + this.y) } }
Setiap kelas mesti mempunyai pembina Jika tiada pengisytiharan eksplisit, enjin js akan menambah kosong secara automatik pembina
class person3 { } //等于 class person3 { constructor(){} }
Perhatian Apabila mengisytiharkan kaedah dalam kelas, jangan tambah kata kunci fungsi sebelum kaedah Jangan pisahkan kaedah dengan koma, jika tidak ralat akan dilaporkan Semua kaedah yang ditakrifkan di dalam kelas tidak boleh dikira
Ambil perhatian bahawa atribut kejadian adalah sama dengan es5 melainkan ia ditakrifkan secara eksplisit pada dirinya sendiri (iaitu objek ini Ditakrifkan pada prototaip <🎜). >
class Point { constructor(x,y){ this.x = x; this.y = y; } toString(){ return `this.x + this.y`; } } var point = new Point(); point.toString() //(2,3) point.hasOwnProperty("x") //true point.hasOwnProperty("y") //true 在这x&&y都是实例对象point自身的属性(因为定义在this变量上) // 所以返回true point.hasOwnProperty("toString") //false toString是原型对象的属性 (因为定义在Point类上) //所以返回false point._proto_.hasOwnProperty("toString") //true //加两个实例 var p1 = new Point(); var p2 = new Point(); p1._proto_ === p2._proto_ //true 这个不建议使用 //上面代码中 p1和p2 都是point的实例 他们的原型都是Point.prototype 所以 _proto_属性是相等的 //即是说 可以通过实例的_proto_ 属性为 "类" 添加方法
class Father { constructor (surname){ this.surname = surname } say(){ console.log("你的名字" + this.surname) //你的名字锤子 } } //在这里 子继承父类 class Son extends Father { constructor(surname,name){ super(surname) this.name = name } say(){ super.say() console.log('调用普通' + this.name) //调用普通铁的 } } var son = new Son('锤子',"铁的") son.say() console.log(son) //打印 {surname: "锤子", name: "铁的" //在子类的构造函数如果使用 super 调用父类的构造函数 必须写在 this之前 //还可以 调用父类的普通方法 //在es6中 类没变量提升 必须先定义 才能通过实例化对象类里面的 共有属性 和方法 通过this 调用 //类 里面的this 代表什么 //constructor 里面this指向实例对象 // 方法里面this 代表 方法的 调用者
warisan ialah ciri berorientasikan objek utama yang boleh mengurangkan penulisan kod dan memudahkan pengekstrakan kata kunci kandungan awam meluas
class Father { constructor (surname){ this.surname = surname } say(){ //父级Father里面有一个方法 say() console.log("你的名字" + this.surname) } } class Son extends Father { //在这里Son 继承了 Father父级里面的方法 关键字extends } var son = new Son('锤子') //new 出来实例 son.say() //打印 你的名字锤子
class Person { constructor(name, age) { // 构造函数,接收一个name和age this.name = name this.age = age } say(){ // 一个方法 //注意类里面的方法不加function关键字 方法与方法之间不用,号隔开 console.log("你好",this.name) } // ....sayWhat(){} saySome(){} } var person = new Person('老王',44) //调用方法 person.say() //老王 //在类的实例上调用方法 其实就是调用 原型上的方法
与函数一样 calss 也可以使用表达式的形式定义 采用class表达式 可以写出立即执行的Class!!
注意与函数表达式类似 类表达式在他们被求值前也不能使用(即赋值变量 之前调用) 但 与函数定义不同 虽然函数声明可以提升 但类不能
类表达式(类定义)
类表达式可以是被命名的或匿名的
let Person = class { constructor(x, y) { this.x = x this.y = y } }
let Person = class Person { constructor(x, y) { this.x = x this.y = y } } const Mycalss = class Me { getClassName(){ return Me.name; } }; //这里用 表达式(即赋值变量一个) //注意! 这个类的名字是Mycalss而不是 Me Me只在Class的内部代码可用 指代当前类 let inst = new Mycalss(); inst.getClassName() //Me Me.name //报错 Me只在Class内部有定义
let person = new class { constructor(name) { this.name = this.name; } sayname(){ console.log(this.name); } }("常东东") //这段代码中class是立即执行的实例
class Animal { //class定义了一个“类” constructor(){ this.type = 'animal' //有一个constructor方法,这就是构造方法 //this关键字则代表实例对象 } //constructor内定义的方法和属性是实例对象自己的,而constructor外定义的方法和属性则是所有实例对象可以共享的 注意! says(say){ console.log(this.type + ' says ' + say) } } let animal = new Animal() animal.says('hello') //animal says hello class Cat extends Animal { //通过extends关键字实现继承 //定义了一个Cat类,该类通过extends关键字,继承了Animal类的所有属性和方法。 constructor(){ super() //super关键字 它指代父类的实例(即父类的this对象)子类必须在constructor方法中调用super方法,否则新建实例时会报错。 this.type = 'cat' //这是因为子类没有自己的this对象,而是继承父类的this对象,然后对其进行加工。如果不调用super方法,子类就得不到this对象。 } } let cat = new Cat() cat.says('hello') //cat says hello
【相关推荐:javascript视频教程、编程视频】
Atas ialah kandungan terperinci Apakah yang dilakukan oleh kelas es6?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!