| function A() { | |
| } | |
| A.prototype.desc = function() { | |
| return "A"; | |
| } | |
| function B() { | |
| } | |
| B.prototype = Object.create(A.prototype); | |
| B.prototype.desc = function() { |
| // Roughly: a combination of Jeremy’s and Allen’s ideas, updated with the results of recent discussions | |
| // Guidelines: | |
| // - Don’t use the same syntax as for object literals, but stay close. | |
| // - Rationale: Some object literal features are forbidden in class declarations => don’t confuse people | |
| // - Rationale: Comma separation is a bit tricky. | |
| // - Keep new features at a minimum | |
| // - Don’t obscure the fact that private names are actually name objects. | |
| // => They can also be imported from somewhere else – a use case that needs to be supported. | |
| // - In order to minimize confusion, keep module syntax and class declaration syntax similar. |
| // Simulated static super references (as proposed by the current draft of the ECMAScript 6 specification) | |
| //------------------ Library | |
| function inherits(subC, superC) { | |
| var subProto = Object.create(superC.prototype); | |
| // At the very least, we keep the "constructor" property | |
| // At most, we preserve additions that have already been made | |
| copyOwnFrom(subProto, subC.prototype); | |
| setUpHomeObjects(subProto); |
Given that most things that matter at “class” level also matter at object level, I still feel that using object initializer notation for class declarations is the simplest solution. The following is a synthesis of some of the proposals out there.
Introduce Allen’s class operator as a declarative statement and an expression (similar to Jeremy’s and David’s proposals). IMHO, that’s best when it comes to ease of use for newbies.
class C { ... }
class C extends B { ... }
let C = class { ... };
| // No imports, those are more work, especially for plain browser. | |
| // However, as soon as you have imports, you should switch to AMD on browsers. | |
| // Related: http://www.2ality.com/2011/11/module-gap.html | |
| ({ define: | |
| typeof define === "function" ? | |
| define | |
| : typeof module !== "undefined" ? | |
| function(F) { module.exports = F() } | |
| : function(F) { this.defClass = F() }.bind(this) |
| //----- Example code: | |
| // Class declarations: | |
| // - No data properties allowed | |
| // - Future: support mixins | |
| // - Optional: call the initialization method `new` instead of `constructor` | |
| // Superclass | |
| class Person { | |
| constructor(name) { |
| #!/usr/bin/env node | |
| process.stdin.resume(); | |
| process.stdin.setEncoding('utf8'); | |
| var str = ""; | |
| process.stdin.on('data', function (chunk) { | |
| str += chunk; | |
| }); |
| <!DOCTYPE html> | |
| <html> | |
| <head> | |
| <meta charset="UTF-8"> | |
| <title>instanceof test</title> | |
| <script> | |
| // test() is called from the iframe | |
| function test(arr) { | |
| var iframeWin = frames[0]; | |
| console.log(arr instanceof Array); // false |
| // Based on: http://wiki.ecmascript.org/doku.php?id=strawman:syntactic_support_for_private_names | |
| //// The at (@) operator | |
| // Intuitively: | |
| // - obj.@foo is syntactic sugar for obj[foo] | |
| // - @foo is syntactic sugar for [foo] (for method definitions, property definitions, etc.) | |
| // Usage: Let propName be a normal variable holding either a symbol or a string. |
| // Related: UMD, a project cataloging UMD patterns https://github.com/umdjs/umd | |
| // Universal module definition: requires either an AMD loader or Node.js | |
| ({ define: typeof define === 'function' | |
| ? define | |
| : function (names, body) { | |
| module.exports = body.apply(null, names.map(require)); | |
| } | |
| }). | |
| define(["foo", "bar"], function (foo, bar) { |