Class:向传统类模式转变的构造函数使用帮助_class新手入门

前言JS基于原型的‘类’,一直被转行前端的码僚们大呼惊奇,但接近传统模式使用class关键字定义的出现,却使得一些前端同行深感遗憾而纷纷留言:“还我独特的JS”、“净搞些没实质的东西”、“自己没有类还非要往别家的类上靠”,甚至是“已转行”等等。有情绪很正常,毕竟新知识意味着更多时间与精力的开销,又不是简单的闭眼享受。然而历史的轴印前行依旧,对于class可以

Class:向传统类模式转变的构造函数使用帮助

前言

JS基于原型的‘类’,一直被转行前端的码僚们大呼惊奇,但接近传统模式使用class关键字定义的出现,却使得一些前端同行深感遗憾而纷纷留言:“还我独特的JS”、“净搞些没实质的东西”、“自己没有类还非要往别家的类上靠”,甚至是“已转行”等等。有情绪很正常,毕竟新知识意味着更多时间与精力的开销,又不是简单的闭眼享受。

Class:向传统类模式转变的构造函数使用帮助_class新手入门

然而历史的轴印前行依旧,对于class可以肯定的一点是你不能对面试官说:“拜托,不是小弟不懂,仅仅是不愿意了解,您换个问题呗!”一方面虽然class只是个语法糖,但extends对继承的改进还是不错的。另一方面今后可能在‘类’上出现的新特性应该是由class而不是构造函数承载,谁也不确定它将来会出落得怎样标致。因此,来来来,慢慢的喝下这碗热气腾腾的红糖姜汤。

1 class

ECMAScript中没有类的概念,我们的实例是基于原型由构造函数生成具有动态属性和方法的对象。不过为了与国际接轨,描述的更为简便和高大上,依然会使用‘类’这一词。所以JS的类等同于构造函数。ES6的class只是个语法糖,其定义生成的对象依然构造函数。不过为了与构造函数模式区分开,我们称其为类模式。学习class需要有构造函数和原型对象的知识,具体可以自行百度。

// --- 使用构造函数
function C () {
  console.log('New someone.');
}

C.a = function () { return 'a'; }; // 静态方法

C.prototype.b = function () { return 'b'; }; // 原型方法


// --- 使用class
class C {
  static a() { return 'a'; } // 静态方法
  
  constructor() { console.log('New someone.'); } // 构造方法
  
  b() { return 'b'; } // 原型方法
};

1.1 与变量对比

关键字class类似定义函数的关键字function,其定义的方式有声明式和表达式(匿名式和命名式)两种。通过声明式定义的变量的性质与function不同,更为类似let和const,不会提前解析,不存在变量提升,不与全局作用域挂钩和拥有暂时性死区等。class定义生成的变量就是一个构造函数,也因此,类可以写成立即执行的模式。

// --- 声明式
class C {}
function F() {}

// --- 匿名表达式
let C = class {};
let F = function () {};

// --- 命名表达式
let C = class CC {};
let F = function FF() {};

// --- 本质是个函数
class C {}
console.log(typeof C); // 'function'
console.log(Object.prototype.toString.call(C)); // '[object Function]'
console.log(C.hasOwnProperty('prototype')); // true

// --- 不存在变量提升
C; // 报错,不存在C。
class C {}
// 存在提前解析和变量提升
F; // 不报错,F已被声明和赋值。
function F() {}

// --- 自执行模式
let c = new (class {
})();
let f = new (function () {
})();

1.2 与对象对比

类内容({}里面)的形式与对象字面量相似。不过类内容里面只能定义方法不能定义属性,方法的形式只能是函数简写式,方法间不用也不能用逗号分隔。方法名可以是带括号的表达式,也可以为Symbol值。方法分为三类,构造方法(constructor方法)、原型方法(存在于构造函数的prototype属性上)和静态方法(存在于构造函数本身上)

class C {
  // 原型方法a
  a() { console.log('a'); }
  // 构造方法,每次生成实例时都会被调用并返回新实例。
  constructor() {}
  // 静态方法b,带static关键字。
  static b() { console.log('b'); }
  // 原型方法,带括号的表达式
  ['a' + 'b']() { console.log('ab'); }
  // 原型方法,使用Symbol值
  [Symbol.for('s')]() { console.log('symbol s'); }
}

C.b(); // b

let c = new C();
c.a(); // a
c.ab(); // ab
c[Symbol.for('s')](); // symbol s

不能直接定义属性,并不表示类不能有原型或静态属性。解析class会形成一个构造函数,因此只需像为构造函数添加属性一样为类添加即可。更为直接也是推荐的是只使用getter函数定义只读属性。为什么不能直接设置属性?是技术不成熟?是官方希望传递某种思想?抑或仅仅是笔者随意抛出的一个问题?

// --- 直接在C类(构造函数)上修改
class C {}
C.a = 'a';
C.b = function () { return 'b'; };
C.prototype.c = 'c';
C.prototype.d = function () { return 'd'; };

let c = new C();
c.c; // c
c.d(); // d

// --- 使用setter和getter
// 定义只能获取不能修改的原型或静态属性
class C {
  get a() { return 'a'; }
  static get b() { return 'b'; }
}

let c = new C();
c.a; // a
c.a = '1'; // 赋值没用,只有get没有set无法修改。

1.3 与构造函数对比

下面是使用构造函数和类实现相同功能的代码。直观上,class简化了代码,使得内容更为聚合。constructor方法体等同构造函数的函数体,如果没有显式定义此方法,一个空的constructor方法会被默认添加用于返回新的实例。与ES5一样,也可以自定义返回另一个对象而不是新实例。

// --- 构造函数
function C(a) {
  this.a = a;
}

// 静态属性和方法
C.b = 'b';
C.c = function () { return 'c'; };

// 原型属性和方法
C.prototype.d = 'd';
C.prototype.e = function () { return 'e'; };
Object.defineProperty(C.prototype, 'f', { // 只读属性
  get() {
    return 'f';
  }
});

// --- 类
class C {
  static c() { return 'c'; }
  
  constructor(a) {
    this.a = a;
  }
  
  e() { return 'e'; }
  get f() { return 'f'; }
}

C.b = 'b';
C.prototype.d = 'd';

类虽然是个函数,但只能通过new生成实例而不能直接调用。类内部所定义的全部方法是不可枚举的,在构造函数本身和prototype上添加的属性和方法是可枚举的。类内部定义的方法默认是严格模式,无需显式声明。以上三点增加了类的严谨性,比较遗憾的是,依然还没有直接定义私有属性和方法的方式。

// --- 能否直接调用
class C {}
C(); // 报错

function C() {}
C(); // 可以


// --- 是否可枚举
class C {
  static a() {} // 不可枚举
  b() {} // 不可枚举
}

C.c = function () {}; // 可枚举
C.prototype.d = function () {}; // 可枚举

isEnumerable(C, ['a', 'c']); // a false, c true
isEnumerable(C.prototype, ['b', 'd']); // b false, d true

function isEnumerable(target, keys) {
  let obj = Object.getOwnPropertyDescriptors(target);
  keys.forEach(k => {
    console.log(k, obj[k].enumerable);
  });
}


// --- 是否为严格模式
class C {
  a() {
    let is = false;
    try {
      n = 1;
    } catch (e) {
      is = true;
    }
    console.log(is ? 'true' : 'false');
  }
}

C.prototype.b = function () {
  let is = false;
  try {
    n = 1;
  } catch (e) {
    is = true;
  }
  console.log(is ? 'true' : 'false');
};

let c = new C();
c.a(); // true,是严格模式。
c.b(); // false,不是严格模式。

在方法前加上static关键字表示此方法为静态方法,它存在于类本身,不能被实例直接访问。静态方法中的this指向类本身。因为处于不同对象上,静态方法和原型方法可以重名。ES6新增了一个命令new.target,指代new后面的构造函数或class,该命令的使用有某些限制,具体请看下面示例。

// --- static
class C {
  static a() { console.log(this === C); }
  a() { console.log(this instanceof C); }
}

let c = new C();
C.a(); // true
c.a(); // true


// --- new.target
// 构造函数
function C() {
  console.log(new.target);
}

C.prototype.a = function () { console.log(new.target); };

let c = new C(); // 打印出C
c.a(); // 在普通方法中为undefined。

// --- 类
class C {
  constructor() { console.log(new.target); }
  a() { console.log(new.target); }
}

let c = new C(); // 打印出C
c.a(); // 在普通方法中为undefined。

// --- 在函数外部使用会报错
new.target; // 报错

2 extends

ES5中的经典继承方法是寄生组合式继承,子类会分别继承父类实例和原型上的属性和方法。ES6中的继承本质也是如此,不过实现方式有所改变,具体如下面的代码。可以看到,原型上的继承是使用extends关键字这一更接近传统语言的形式,实例上的继承是通过调用super完成子类this塑造。表面上看,方式更为的统一和简洁。

class C1 {
  constructor(a) { this.a = a; }
  b() { console.log('b'); }
}

class C extends C1 { // 继承原型数据
  constructor() {
    super('a'); // 继承实例数据
  }
}

2.1 与构造函数对比

使用extends继承,不仅仅会将子类的prototype属性的原型对象(__proto__)设置为父类的prototype,还会将子类本身的原型对象(__proto__)设置为父类本身。这意味着子类不单单会继承父类的原型数据,也会继承父类本身拥有的静态属性和方法。而ES5的经典继承只会继承父类的原型数据。不单单是财富,连老爸的名气也要获得,不错不错。

class C1 {
  static get a() { console.log('a'); }
  static b() { console.log('b'); }
}

class C extends C1 {
}
// 等价,没有构造方法会默认添加。
class C extends C1 {
  constructor(...args) {
    super(...args);
  }
}

let c = new C();
C.a; // a,继承了父类的静态属性。
C.b(); // b,继承了父类的静态方法。
console.log(Object.getPrototypeOf(C) === C1); // true,C的原型对象为C1
console.log(Object.getPrototypeOf(C.prototype) === C1.prototype); // true,C的prototype属性的原型对象为C1的prototype

ES5中的实例继承,是先创造子类的实例对象this,再通过call或apply方法,在this上添加父类的实例属性和方法。当然也可以选择不继承父类的实例数据。而ES6不同,它的设计使得实例继承更为优秀和严谨。

在ES6的实例继承中,是先调用super方法创建父类的this(依旧指向子类)和添加父类的实例数据,再通过子类的构造函数修饰this,与ES5正好相反。ES6规定在子类的constructor方法里,在使用到this之前,必须先调用super方法得到子类的this。不调用super方法,意味着子类得不到this对象。

class C1 {
  constructor() {
    console.log('C1', this instanceof C);
  }
}

class C extends C1 {
  constructor() {
    super(); // 在super()之前不能使用this,否则报错。
    console.log('C');
  }
}

new C(); // 先打印出C1 true,再打印C。

2.2 super

关键字super比较奇葩,在不同的环境和使用方式下,它会指代不同的东西(总的说可以指代对象或方法两种)。而且在不显式的指明是作为对象或方法使用时,比如console.log(super),会直接报错。

作为函数时。super只能存在于子类的构造方法中,这时它指代父类构造函数。

作为对象时。super在静态方法中指代父类本身,在构造方法和原型方法中指代父类的prototype属性。不过通过super调用父类方法时,方法的this依旧指向子类。即是说,通过super调用父类的静态方法时,该方法的this指向子类本身;调用父类的原型方法时,该方法的this指向该(子类的)实例。而且通过super对某属性赋值时,在子类的原型方法里指代该实例,在子类的静态方法里指代子类本身,毕竟直接在子类中通过super修改父类是很危险的。

很迷糊对吧,疯疯癫癫的,还是结合着代码看吧!

class C1 {
  static a() {
    console.log(this === C);
  }
  b() {
    console.log(this instanceof C);
  }
}

class C extends C1 {
  static c() {
    console.log(super.a); // 此时super指向C1,打印出function a。
    
    this.x = 2; // this等于C。
    super.x = 3; // 此时super等于this,即C。
    console.log(super.x); // 此时super指向C1,打印出undefined。
    console.log(this.x); // 值已改为3。

    super.a(); // 打印出true,a方法的this指向C。
  }

  constructor() {
    super(); // 指代父类的构造函数
    
    console.log(super.c); // 此时super指向C1.prototype,打印出function c。

    this.x = 2; // this等于新实例。
    super.x = 3; // 此时super等于this,即实例本身。
    console.log(super.x); // 此时super指向C1.prototype,打印出undefined。
    console.log(this.x); // 值已改为3。

    super.b(); // 打印出true,b方法的this指向实例本身。
  }
}

2.3 继承原生构造函数

使用构造函数模式,构建继承了原生数据结构(比如Array)的子类,有许多缺陷的。一方面由上文可知,原始继承是先创建子类this,再通过父类构造函数进行修饰,因此无法获取到父类的内部属性(隐藏属性)。另一方面,原生构造函数会直接忽略call或apply方法传入的this,导致子类根本无法获取到父类的实例属性和方法。

function MyArray(...args) {
  Array.apply(this, args);
}

MyArray.prototype = Array.prototype;
// MyArray.prototype.constructor = MyArray;

let arr = new MyArray(1, 2, 3); // arr为对象,没有储存值。
arr.push(4, 5); // 在arr上新增了0,1和length属性。
arr.map(d => d); // 返回数组[4, 5]
arr.length = 1; // arr并没有更新,依旧有0,1属性,且arr[1]为5。

创建类的过程,是先构造一个属于父类却指向子类的this(绕口),再通过父类和子类的构造函数进行修饰。因此可以规避构造函数的问题,获取到父类的实例属性和方法,包括内部属性。进而真正的创建原生数据结构的子类,从而简单的扩展原生数据类型。另外还可以通过设置Symbol.species属性,使得衍生对象为原生类而不是自定义子类的实例。

class MyArray extends Array { // 实现是如此的简单
  static get [Symbol.species]() { return Array; }
}

let arr = new MyArray(1, 2, 3); // arr为数组,储存有1,2,3。
arr.map(d => d); // 返回数组[1, 2, 3]
arr.length = 1; // arr正常更新,已包含必要的内部属性。

需要注意的是继承Object的子类。ES6改变了Object构造函数的行为,一旦发现其不是通过new Object()这种形式调用的,构造函数会忽略传入的参数。由此导致Object子类无法正常初始化,但这不是个大问题。

class MyObject extends Object {
  static get [Symbol.species]() { return Object; }
}

let o = new MyObject({ id: 1 });
console.log(o.hasOwnPropoty('id')); // false,没有被正确初始化

来源:https://segmentfault.com/a/1190000016475608

海计划公众号
(0)
上一篇 2020/04/03 19:43
下一篇 2020/04/03 19:43

您可能感兴趣的内容

  • DPlayer简单用法基础教程_视频使用教程

    DPlayer 是一个支持弹幕的 HTML5 视频播放器。支持 Bilibili 视频和 danmaku,实时视频(HTTP Live Streaming,M3U8格式)以及 FLV 格式。 用法HTML


    <script src="dist/DPlaye

    2020/03/20
  • imgResize基础知识教程_移动端H5图片压缩

    imgResize基础知识教程 GitHub:https://github.com/CommanderXL/imgResize 简介描述:移动端H5图片压缩 大体的思路是,部分 A…

    2020/03/11
  • js声明函数入门基础知识_函数入门百科

    JS声明函数的三种方式:1.函数表达式: function操作符创建函数, 表达式可以存储在变量或者对象属性里. 往往被称为匿名函数, console.log(h.name); 可以看到打印为空 “”2.函数声明: 具名函数, 且函数能在其所在作用域的任意位置被调用, 其创建的函数为具名函数, 证明这一点你可以 console.log(h.name); 可以

    2020/03/26
  • Emmet菜鸟教程_一款编辑器插件,支持多种编辑器支持

    Emmet菜鸟教程 官方网址:https://emmet.io/ GitHub:https://github.com/emmetio 简介描述:一款编辑器插件,支持多种编辑器支持 …

    2020/03/12
  • 互房客助力 迁西·塞纳城邦D组团开盘劲销1.5亿菜鸟教程网_营销使用帮助

    开盘活动于2019年7月6号正式启动,活动当天得到迁西购买者的火爆参与,热闹非凡,销售额突破1.5亿,再一次名列当地第一,塞纳城邦销售团队再一次验证了“我们让销冠成为习惯”的自信口号!【互房客hufangke.com】自建最新最强大的网络营销平台,掌握最新最有效的千万用户需求,可针对项目提供及定制精准有效的营销推广渠道;相对而言,针对每个上线项目的选择

    2020/03/26
  • 向编程新手和初级开发人员分享我的三个技巧入门教程_编程基础知识入门

    向编程新手和初级开发人员分享我的三个技巧入门教程 在这篇文章中,我想向编程新手和初级开发人员分享我的三个技巧。虽然开发可能真的很难……但是有了这些技巧,将会助你更快成功! 一、不要…

    2020/03/20
  • vConsole菜鸟教程vue移动端调试_调试基础指南

    当我们在浏览器开发vue页面时,由于浏览器对于调试有天然的支持,我们开发起来很方便。但是现在已经进入了移动端时代,移动端页面的需求越来越大。在开发移动端页面的时候我们通常是在浏览器完成开发完成,之后才在手机端测试,如果测试出现问题还得重新回到浏览器上寻找错误。甚至还有嵌入在APP的页面,经过调试之后还要重新发包。当然还有更加奇怪的现象,由于手机浏览器和Web

    2020/03/26
  • Js中call/apply/bind方法函数的原生实现菜鸟教程_this菜鸟指南

    call/apply/bind方法简介在JavaScript中,函数中this的指向往往在调用时才可确定,而JavaScript提供了call/apply/bind方法让我们得以显示绑定函数的this指向。它们的第一个参数是一个对象,它们会把这个对象绑定到调用他们的函数内的this。因为你可以直接指定 this 的绑定对象,因此我们称之为显式绑定。//用例

    2020/03/29
  • Vue2Editor小白指南_基于 Quill 的 Vue.js 2.0 富文本编辑器组件

    Vue2Editor小白指南 官方网址:https://www.vue2editor.com/ GitHub:https://github.com/davidroyer/vue2-…

    2020/03/06
  • 微信小程序更新机制基础知识入门微信小程序的2种更新方式_小程序菜鸟知识

    1)小程序的启动方式: 冷启动—-小程序首次打开或销毁后再次被打开 热启动—-小程序打开后,在一段时间内(目前:5分钟)再次被打开,此时会将后台的小程序切换到前台。2)根据以上两种启动方式,相应的更新机制为: 小程序冷启动时,会检查小程序是否有最新版本。如果有则将异步下载最新版本,但是仍将运行当前版本等到下一次冷启动时再运行最新版本。如果你

    2020/04/05
  • 从JS继承实现一个VueJs的render函数基础知识_render菜鸟教程

    市面上的主流框架,相信作为一个前端搬砖人员,或多或少都会有所接触到。如ReactJs、VueJs、AngularJs。那么对于每个框架的使用来说其实是比较简单的,还记得上大学时候,老师曾经说过:”技术就是窗户纸,捅一捅就破了”,也就是说,任何一门技术,只要深入去研究,那么它也不再是很神秘的东西了。我个人在工作中用VueJs是比较多的,当然React也会,那今

    2020/03/24
  • 前端用v-html影响安全性使用指南_安全菜鸟教程

    原因:你的站点上动态渲染的任意 HTML 可能会非常危险,因为它很容易导致 XSS 攻击。请只对可信内容使用 HTML 插值,绝不要对用户提供的内容插值。解决办法:使用

     标签替换掉  标签。利用的就是

     标签的这个功能:被包围在

     元素中的文本通常会保留空格和换行符,并且文本也会呈现为等宽字体。注意:pre标签使用的

    2020/03/26
  • emojify.js菜鸟教程_快速将关键字转换成表情库图片

    emojify.js菜鸟教程 官方网址:http://hassankhan.github.io/emojify.js/ GitHub:https://github.com/joyp…

    2020/03/06
  • 实现一个简单的toast组件入门攻略_组件菜鸟攻略

    最近写了个简单的html+js的页面,里面需要一个提交表单的反馈动作,于是手撸了个简单的toast组件toast.js function showToast(msg, duration) {duration = isNaN(duration) ? 2000 : duration;var m = document.createElement(‘div’);m

    2020/03/29
  • PHP遍历二叉树菜鸟攻略_遍历菜鸟攻略

    遍历二叉树,这个相对比较复杂。二叉树的便利,主要有两种,一种是广度优先遍历,一种是深度优先遍历。什么是广度优先遍历?就是根节点进入,水平一行一行的便利。什么是深度优先遍历呢?就是根节点进入,然后按照一个固定的规律,一直向下走,一个方向的子树遍历之后再遍历另一个方向的子树。深度优先遍历,主要有三种顺序遍历:先序(先输出根节点),中序(第二个输出根节点),后序(

    2020/04/03
  • PathFinding.js入门百科_综合性的 JavaScript 路径查找库

    PathFinding.js入门百科 官方网址:https://github.com/qiao/PathFinding.js GitHub:http://qiao.github.i…

    2020/03/06