无类继承.key

无类继承 JavaScript 面向对象的根基 周爱 民 / aimingoo aiming@gmail.com https://aimingoo.github.io https://github.com/aimingoo

rand = new Person("Rand McKinnon",... https://docs.oracle.com/cd/e19957-01/816-6408-10/object.htm#1193255 https://www.fi.muni.cz/~xdohnal/manuals/jscript/toc.html

function car(make, model, year) { this.make = make; this.model = model;... https://docs.oracle.com/cd/e19957-01/816-6408-10/object.htm#1193255 https://www.fi.muni.cz/~xdohnal/manuals/jscript/toc.html

JavaScript 1.1 prototype based

function MyObject() { this.xxx =...... } MyObject.prototype = new Object(); MyObject.prototype.constructor = MyObject;... obj = new MyObject(); obj.x = 100;

Object() prototype.tostring().xxx proto MyObject() prototype.constructor proto obj x: 100 console.log(obj.x); console.log(obj.xxx); console.log(obj.tostring());

原型继承 类抄写 声明 : 类 / 原型 / 对象... 类继承 js1.1 ~ 1.x js2 ECMAScript edition 1~4

ECMAScript Ed5 Non-classes based

Object.hasOwnProperty(obj,...) Object.defineProperty(obj,...) Object.freeze() Object.XXXX()...

obj = Object.create(X, {... })

Object.setPrototypeOf(obj, X)

X.isPrototypeOf(obj)

X.isPrototypeOf(obj) vs. obj instanceof Object

1. 对象就是属性包 1 2 所以原型继承就是属性包的链式访问 所以可以没有类继承 ( 例例如构造器器和 new) an object is a collection of properties

JavaScript 2015 ECMAScript Ed 6 / ES6 该来的总会来的 崔椭圆 @2020

let obj = { name: 'obj', foo() {... } }

homeobj = Method[[HomeObject]]; super = Object.getPrototypeOf(homeObj)

let obj = { foo() { // 所以这 是静态声明 初始器赋值 console.log(super.name, this.name); } } Object.setPrototypeOf(obj, {name: 'Super'}); obj.name = 'obj'; obj.foo(); // Super, obj let obj2 = Object.create(obj, {name: 'I am obj2'}); obj2.foo(); // Super, I am obj2

let foo = obj.foo; foo(); //???,???

Class is appearances

class MyClass extends X { constructor() {.. } static foo() {.. } more() {...

class MyClass extends X { constructor() { super();.. } static foo() {.. } more() {..... // bind classname and set prototypes MyClass = asclassconstructor(constructor); Object.setPrototypeOf(MyClass, X); Object.setPrototypeOf(MyClass.prototype, X.prototype); = // for static methods sethomeobject(foo, MyClass); // for constructor and instance methods sethomeobject(constructor, MyClass.prototype); sethomeobject(more, MyClass.prototype);

class MyClass {} class MyClass extends X {}

class MyClass { constructor() { } } // no "super()" class MyClass extends X { constructor(...args) { // default super(...args); } }

> class MyClass extends null {} > obj = new MyClass; TypeError: Super constructor null of > Object.setPrototypeOf(MyClass, Object) > typeof(obj = new MyClass) 'object'

new X New or create

Base() prototype.tostring().xxx function MyObject() {} MyObject.prototype = new Base(); MyObject.prototype.foo =... proto MyObject() prototype.constructor proto obj = new MyObject; obj foo:...

function MyObject() {} MyObject.prototype = new Base(); MyObject.prototype.foo =... obj = new MyObject; class MyClass extends Base { constructor() {... foo() {...... obj2 = new MyClass; Base() constructor { _this = new_instance() setprototypeof(_this, new.target.prototype); // binding <this> or return... } MyClass() constructor { super(); // with new.target...... obj2 is <_this> obj2 obj2 = new MyClass; obj2.foo();

// success class MyDate extends Date {... // fail MyFunction.prototype = Function; } MyDate.prototype = new Date();... // success class MyFunction extends Function {... }

class MyClass extends X; 1 2 父类 X 是可以通过写类的原型来重置的 super 总是通过计算指向 X, 并受上述重置影响 obj = new MyClass; 1 obj 总是由祖先类 (Base) 创建的实例例

Atom Meta based

X = Object.create(null); Object.setPrototypeOf(X null);

function isatom(obj) { let types = {object: true, function: true}; if (types[typeof obj]) { return!(obj instanceof Object); } return false; }

arguments namespace // for arguments args = Function('return arguments')(); isatom(args); // true // for namespace import * as namespace from "./exports.mjs"; isatom(namespace); // true

atom 原 子 meta 元 能产 生原 子的 一个过程 Meta - 能产 生meta的 一个过程 称为元类型 MetaClass - 如果所产 生的meta是 一个类 则这个Meta称为元类类型 // 如下代码意味着Atom()是元函数或元构造器器 atom = new Atom();

// a meta/atom-constructor, derived from null, it s meta style class meta extends null {...

// Atom() for meta system class Atom extends null { constructor() { return Object.create(new.target.prototype); } }

// Atom() for meta system class Atom... // Meta class Meta extends null { constructor() { return Object.setPrototypeOf( class extends new.target{}, Atom); } }

// Atom() for meta system class Atom... // Meta class Meta... // to atom style void Object.setPrototypeOf(Atom, null); void Object.setPrototypeOf(Meta, null);

// Atom() for meta system class Atom... // Meta class Meta... // to atom style... // Meta Classes class MetaClass extends Meta { static isclassof(x) { return x instanceof this x.prototype instanceof this; } }

// Atom() for meta system class Atom... // Meta class Meta... // to atom style... // Meta Classes class MetaClass extends Meta {... class MetaObject extends new MetaClass {} x = new MetaObject;

> [MetaObject, MetaClass, Meta, Atom, x].foreach(x=>console.log(isatom(x))); true true true true true > typeof x 'object'

class Meta class MetaClass class MetaObject extends new MetaClass {} class MetaX extends MetaClass {} Meta (元类型) extends extends class MetaObjectEx extends MetaObject {} obj = new MetaObject; obj2 = new MetaObjectEx; MetaClass (元类) MetaX (派 生类) Meta-class instantiation Meta based ECMAScript based MetaObject (实例例类) instanceof is 'true' extends MetaObjectEx obj instanceof is 'true' obj2

> Meta.isAtom(null); true > Meta.isAtom(Object.prototype); true

> Objext = Meta.from(Object);

atom Object.prototype > Objext = Meta.from(Object); > Objext.keys(new Objext); [] Atom Meta MetaClass MetaObject Objext = Object

Ox bje t github.com/aimingoo/metameta