超级的

超级的([论据]) //调用父构造函数。
超级的.父级上的属性超级的[表达]

班 矩形 {
  建造师(高度,宽度) {
    这.名称= “矩形”;
    这.高度=高度;
    这.宽度=宽度;
  }
  说出姓名() {慰问.日志(`嗨，我是${这.名称}.`);
  }
  得到 地区() {
    返回 这.高度* 这.宽度;
  }
  设置 地区(价值) {
    这._面积=价值;
  }
}

班 方形 延伸 矩形 {
  建造师(长度) {
    //在这里，它使用长度调用父类的构造函数
    //为矩形的宽度和高度提供
    超级的(长度,长度);

    //注意：在派生类中，必须先调用super（）
    //可以使用“this”。将其移到顶部会导致ReferenceError。
    这.名称= “方形”;
  }
}

班 矩形 {
  静止的 logNb边() {
    返回 “我有四个方面”;
  }
}

班 方形 延伸 矩形 {
  静止的 日志描述() {
    返回 `${超级的.logNb边()}都是平等的`;
  }
}方形.日志描述(); //“我有四个相等的边”

班 底座 {
  静止的基本静态字段= 90;
  基本方法() {
    返回 10;
  }
}

班 扩展 延伸 底座 {扩展字段= 超级的.基本方法(); // 10
  静止的扩展静态字段= 超级的.基本静态字段; // 90
}

班 底座 {基本字段= 10;
}

班 扩展 延伸 底座 {扩展字段= 超级的.基本字段; //未定义
}

班 底座 {
  foo公司() {}
}
班 派生 延伸 底座 {
  删除() {
    删除 超级的.foo公司; //这太糟糕了
  }
}

新的 派生().删除(); //ReferenceError:涉及“super”的删除无效。

常数对象1= {
  方法1() {慰问.日志(“方法1”);
  },
};

常数对象2= {
  方法2() {
    超级的.方法1();
  },
};对象.设置原型Of(对象2,对象1);对象2.方法2(); //记录“方法1”

班 底座 {
  基本获取X() {
    返回 1;
  }
}
班 扩展 延伸 底座 {
  获取X() {
    返回 超级的.基本获取X();
  }
}

常数e（电子）= 新的 扩展();慰问.日志(e（电子）.获取X()); // 1
常数 {获取X} =e（电子）;慰问.日志(获取X()); // 1

常数家长1= { 支柱: 1 };
常数父母2= { 支柱: 2 };

常数小孩= {
  我的父母() {慰问.日志(超级的.支柱);
  },
};对象.设置原型(小孩,家长1);小孩.我的父母(); //日志“1”

常数我的父母=小孩.我的父母;
我的父母(); //仍记录“1”

常数另一个孩子= { __原型__:父母2,我的父母};另一个孩子.我的父母(); //仍记录“1”

班 底座 {
  基本获取X() {
    返回 1;
  }
  静止的 静态BaseGetX() {
    返回 三;
  }
}
班 AnotherBase公司 {
  基本获取X() {
    返回 2;
  }
  静止的 静态BaseGetX() {
    返回 4;
  }
}
班 扩展 延伸 底座 {
  获取X() {
    返回 超级的.基本获取X();
  }
  静止的 静态GetX() {
    返回 超级的.静态BaseGetX();
  }
}

常数e（电子）= 新的 扩展();
//重置实例继承对象.设置原型Of(扩展.原型, 另一个底座.原型);慰问.日志(e（电子）.获取X()); //记录“2”而不是“1”，因为原型链已更改慰问.日志(扩展.静态GetX()); //仍然记录“3”，因为我们还没有修改静态部分
//重置静态继承对象.设置原型(扩展,另一个底座);慰问.日志(扩展.静态GetX()); //现在记录“4”

班 底座 {
  静止的 获取名称() {慰问.日志(这.名称);
  }
}

班 扩展 延伸 底座 {
  静止的 获取名称() {
    超级的.获取名称();
  }
}扩展.获取名称(); //日志“扩展”

班 A类 {}
班 B类 延伸 A类 {
  集合X() {
    超级的.x个= 1;
  }
}

常数b条= 新的 B类();b条.集合X();慰问.日志(b条); //B{x:1}慰问.日志(对象.hasOwn（拥有）(b条, “x”)); //真的

/*重复使用与上面相同的声明*/

常数b2型= 新的 B类();b2型.集合X.呼叫(无效的); //TypeError:无法分配给对象“null”的只读属性“x”

班 X（X） {
  建造师() {
    //创建不可写属性对象.定义属性(这, “道具”, {
      可配置的: 真的,
      可写的: 假,
      价值: 1,
    });
  }
}

班 Y（Y） 延伸 X（X） {
  建造师() {
    超级的();
  }
  foo公司() {
    超级的.支柱= 2; //无法覆盖该值。
  }
}

常数年= 新的 Y（Y）();年.foo公司(); //TypeError:“prop”是只读的慰问.日志(年.支柱); // 1