class类
ES6的class可以看作只是一个语法糖,新的class写法只是让对象原型的写法更加清晰、更像面向对象编程的语法
class 函数名{
constructor(){
// 构造器
}//必须要写,就算不写也会默认添加
}
class类的使用注意点
- 可以写成计算属性名
const person="text"
class Person{
[person+"1"](){
console.log("大哥大姐过年好")
}
}
const a=new Person();
console.log(a.text1())
- 可以使用getter和setter方法 取值必走get方法,赋值必走set方法
const printName = "print";
const test = "job";
class Person{
constructor(job,name,age,sex){
this[test] = job;
this.name = name;
this.age = age;
this.sex = sex;
}
[printName](){
console.log(`工作:${this.job}姓名:${this.name}年龄:${this.age}性别:${this.sex}`)
}
get age(){
console.log("取值的时候走进来")
return this._age;
}
set age(val){
// console.log(val)
// console.log("赋值的时候走进来")
if(typeof val !== "number"){
throw new TypeError("age nust a number")
}
if(val < 0 ){
val = 0
}else if(val > 200){
val = 200;
}
this._age = val;
}
}
const a = new Person("程序猿","张三",12,"男")
console.log(a)
a[printName]()
a.age = 1000;
- 静态成员:属于当前自己所有,不能够被实例出来与其他人共享
普通数据成员属于类的一个对象,只有对象被创建了,普通数据成员才会被分配内存而静态成员属于整个类,即使没有实例对象创建,类的静态数据也存在。
class Car{
constructor(name){
this.name=name;
}
static money=100000;
static width=1000;
}
const car=new Car("宝马");
console.log(car)
自身自带的价格属性和宽度属性
- 字段初始器(ES7):简写constructor
class Test{
字段初始器 :做构造器的初始化工作,如果没有使用static,就是实例成员
a = 1;
b = 2;
static c = 3;
// print(){
// // 原型
// console.log(this.a)
// }
print = ()=>{
// 实例
console.log(this.a)
}
}
const t = new Test()
console.log(t)
箭头函数在字段初始器的中this指向当前对象
对象的继承
extends 继承
super
1.当成函数用,表示父类的构造器
2.当成对象使用,表示父类的原型
class Amimal{
constructor(type,name,age,sex){
this.type = type;
this.name = name;
this.age = age;
this.sex = sex;
}
print(){
console.log(`种类:${this.type}`)
console.log(`名字:${this.name}`)
console.log(`性别:${this.sex}`)
console.log(`年龄:${this.age}`)
}
}
class Dog extends Amimal{
constructor(name,age,sex){
//当函数用的时候是父类的构造器 默认是犬类 传三个参数即可
super("犬类",name,age,sex)
}
print(){
console.log(`汪`)
//当对象用的时候,表示的是父亲的原型
super.print()
}
}
const d = new Dog("旺财",5,"公")
console.log(d)
d.print()
Symbol 符号
Symbol创建的原因是,希望有一种机制,保证每一个属性的名字都是独一无二的,防止属性名冲突
创建符号
可以接受一个字符串作为参数,表示对Symbol实例的描述,主要是为了在控制台现实或者转换为字符串时比较容易区分
const syb1 = Symbol(“符号描述”)
生成symbol是一个原始类型的值,不是对象,所以不需要new关键字调用,并且Symbol函数没有构造器
let syb1 = Symbol("abc")
let syb2 = Symbol("abc")
let syb3 = Symbol()
console.log(syb1,syb2,syb3)//Symbol(abc) Symbol(abc) Symbol()
console.log(syb1 == syb2)//false
console.log(typeof syb1)//symbol
由于以Symbol值作为对象的键名,不会被常规的方法所遍历。利用这个特性我们可以给对象定义一些非私有,但是只在内部使用的方法,通过设计来增加只能在内部访问的方法(for…in遍历、Object.keys()、Object.getOwnPropertyNames()…)
共享符号
Symbol.for() 当符号描述相同,则可以得到同一个符号
const syb1 = Symbol.for("abc")
const syb2 = Symbol.for("abc")
console.log(syb1,syb2)//Symbol(abc) Symbol(abc)
console.log(syb1 === syb2)//true
知名符号
Symbol.hasInstance
对象的Symbol.hasInstance属性,指向一个内部方法。当其他对象使用instanceOf运算符时,判断是否为该对象的实例时,会调用这个方法。
function A(){}
const a=new A();
//defineProperty的作用就是直接在一个对象上定义一个新属性,或者修改一个已经存在的属性
Object.defineProperty(A,Symbol.hasInstance,{
value:function(obj){
console.log(obj)
return false
})
//false 不加这个为ture
Symbol.isConcatSpreadable决定是否展开数组
//Symbol.isConcatSpreadable true为展开 flase为不展开
let arr=[3]
let arr2=[1,2,3]
arr[Symbol.isConcatSpreadable]=false;
const result=arr.concat(arr2)
console.log(result)
Symbol.toPrimitive指向一个内部方法,该对象被转换成原始类型的值时,会调用该方法
//Symbol.toPrimitive
const obj={name:1,age:2}
obj[Symbol.toPrimitive]=function(){
return 100
}
console.log(obj+111)//2111
Symbol.toStringTag指向一个内部方法。在该对象上调用Object.prototype,toString方法时,如果这个属性存在,它的返回值会出现在toString的返回值中,表示对象的类型
class Person{
[Symbol.toStringTag] = "qwe"
}
const p = new Person()
console.log(p)
const arr = [12,1,3]
console.log(Object.prototype.toString.call(p))//[object Object] [object qwe]