super关键字

指向定义时所在对象的原型对象 :::info 只能用在对象的方法简写中或者 class中，用在其它地方会报错：Uncaught SyntaxError: 'super' keyword unexpected here :::

  1. let obj = {
  2.   a: 'hello',
  3.     foo(){
  4.       return super.a
  5.   }
  6. }
  7. Object.setPrototypeOf(obj, {a: 'dva'}) // 将{a: 'dva'}设置为obj的原型对象
  8. obj.foo() // dva
  9. obj.foo.call({a:'123'})

super和this关键字没有关系

  1. let obj2 = {}
  2. Object.setPrototypeOf(obj2, {a: '12'})
  3. obj.foo.call(obj2) // "dva"

有空研究下babel中如何实现的super关键字

  1. let obj = {
  2.     foo: '23',
  3.    a() {
  4.         return super.foo   
  5.    }    
  6. }
  7. // babel 转义后
  8. "use strict";
  10. var _obj;
  12. function _get(target, property, receiver) {
  13.     if (typeof Reflect !== "undefined" && Reflect.get) {
  14.         _get = Reflect.get;
  15.     } else {
  16.         _get = function _get(target, property, receiver) {
  17.             var base = _superPropBase(target, property);
  18.             if (!base) return;
  19.             var desc = Object.getOwnPropertyDescriptor(base, property);
  20.             if (desc.get) {
  21.                 return desc.get.call(receiver);
  22.             }
  23.             return desc.value;
  24.         };
  25.     }
  26.     return _get(target, property, receiver || target);
  27. }
  29. function _superPropBase(object, property) {
  30.     while (!Object.prototype.hasOwnProperty.call(object, property)) {
  31.         object = _getPrototypeOf(object);
  32.         if (object === null) break;
  33.     }
  34.     return object;
  35. }
  37. function _getPrototypeOf(o) {
  38.     _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf: function _getPrototypeOf(o) {
  39.         return o.__proto__ || Object.getPrototypeOf(o);
  40.     };
  41.     return _getPrototypeOf(o);
  42. }
  44. var obj = _obj = {
  45.     foo: '23',
  46.     a: function a() {
  47.         return _get(_getPrototypeOf(_obj), "foo", this);
  48.     }
  49. };

class中的super

  • 用作函数，指向父类的构造函数。ES6 规定使用extend关键字继承时，必须调用一次super。
  • 用作对象
    • 类的普通方法中，指向父类的原型对象
    • 类的静态方法中，指向父类