| if (typeof define !== 'function') { | |
| // Not AMD | |
| if (typeof require === 'function') { | |
| // Node.js | |
| var define = function (body) { | |
| module.exports = body(require); | |
| }; | |
| } else { | |
| // Vanilla browser | |
| var define = function (body) { |
| // Anti-pattern: creating a new promise instead of continuing an existing chain | |
| insert() { // method inside ES6 class | |
| return new Promise((resolve, reject) => { | |
| this.db.collection(this.collection).insert(this.fields) | |
| .then((modelDocument) => { | |
| this.fields = modelDocument; | |
| this.notifyObservers({event: "created", model: this}); | |
| resolve(modelDocument) | |
| }).catch((err) => { | |
| reject(err) |
| // The following code is valid ECMAScript 6, but doesn’t work in Firefox, yet | |
| function PreventUnknownGet() { | |
| } | |
| PreventUnknownGet.prototype = new Proxy(Object.prototype, { | |
| get(target, propertyKey, receiver) { | |
| if (!(propertyKey in target)) { | |
| throw new TypeError('Unknown property: '+propertyKey); | |
| } | |
| // Make sure we don’t block access to Object.prototype |
The term protocol is highly overloaded in computer science. One definition (related to the concept of “metaobject protocol”) is:
A prototcol is about achieving tasks via an object, it comprises a set of methods plus a set of rules for using them.
Note that this definition is different from viewing protocols as interfaces (as, for example, Objective C does), because it includes rules.
| //----- The ECMAScript 6 meta object protocol (MOP) implemented in ES5 | |
| // This is how getting a property is handled internally. | |
| // Double underscore (__) implies internal operation. | |
| Object.prototype.__Get__ = function (propKey, receiver) { | |
| receiver = receiver || this; | |
| var desc = this.__GetOwnProperty__(propKey); | |
| if (desc === undefined) { | |
| var parent = this.__GetPrototypeOf__(); | |
| if (parent === null) return undefined; |
This is a rough overview of the options for deploying ES6 to current JavaScript environments. Not everything can be combined with everything:
| // Simplified version of Sect. 9.2.3 | |
| // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-ecmascript-function-objects-construct-argumentslist-newtarget | |
| /** | |
| * All constructible functions have this own method, | |
| * it is called by the `new` operator | |
| */ | |
| AnyFunction.__Construct__ = function (args, newTarget) { | |
| let Constr = this; | |
| let kind = Constr.__ConstructorKind__; |
| function* zip(...iterables) { | |
| let iterators = iterables.map(i => i[Symbol.iterator]()); | |
| while (true) { | |
| let entries = iterators.map(i => i.next()); | |
| let done = entries.some(entry => entry.done); | |
| if (done) break; | |
| yield entries.map(e => e.value); | |
| } | |
| } |
jspm is a package manager for the SystemJS universal module loader, built on top of the dynamic ES6 module loader
Load any module format (ES6, AMD, CommonJS and globals) directly from any registry such as npm and GitHub with flat versioned dependency management. Any custom registry endpoints can be created through the Registry API.
For development, load modules as separate files with ES6 and plugins compiled in the browser.
Technologies that influenced ES6 features:
const: C++ (the latest C standard has borrowed it from C++)let: is old, became popular via BASIC.