commonjs

modular system: Defines the encapsulated module. Define the dependencies of the new module on other modules. The introduction of other modules can be supported. Thought has, there is always a little something to build a modular system of norms, otherwise all kinds of module loading mode will only make the bureau more chaotic. There are some specifications of non-traditional module development methods in Avascript COMMONJS module speci

The AMD specification originates from the TRANSPORT/C specification in Commonjs, in the following format:Define (ID?, dependencies, Factory);Module Name specification:1. Module name consists of: multiple string name or '/';2. String name follows the hump rule, or: '. ', '. ' ；3. Module name is forbidden with extension, such as: '. js ';4. Top-level Path module name starts with the root space, relative path module name: With '. ', '. ' StartDependency

This article describes how to use Promise in Node. js to encapsulate asynchronous functions and use unified chained APIs to get rid of the nightmare of multiple callbacks. it is a very practical little skill, I hope my friends will like writing Node. during the js process, continuous IO operations may lead to "pyramid nightmare". the multiple nesting of callback functions makes it difficult to maintain the code. the Promise of CommonJs is used to enca

When it comes to components, JavaScript does not have this feature. Many functions of Javascript in the past were implemented by different vendors. Components have the following features: . JavaScript does not have a module system. There is no native support for confined scope or dependency management. . JavaScript does not have a standard library. There are no file system APIs in the core library, but these will be available after html5 :). . JavaScript does not have a standard API. . JavaScrip

Surpassing yesterday's series (3) In fact, learning is always passive. One day, when we understand that we need to study hard, we will find that the world of knowledge is so mighty that we cannot see the bank, we can't even see the sunrise, so it's difficult to get confused.Therefore, progress is never easy. ------------------------------------------ Node. js contacts and learns new things. It is always good for you in the future. Start from here: http://www.nodejs.org/ 1, Require

Use Promise in NodeJS to encapsulate asynchronous Functions This article mainly introduces the use of Promise in node. js to encapsulate asynchronous functions, and the use of unified chained APIs to get rid of the nightmare of multiple callbacks. It is a very practical little skill and I hope my friends will like it. Write Node. during the js process, continuous IO operations may lead to "Pyramid nightmare". The multiple nesting of callback functions makes it difficult to maintain the code. The

COMMONJS specificationShortly after the birth of Netscape, JavaScript has been exploring the path of local programming, and Rhino is the product of its representation. Helpless at that time, the service-side JavaScript path is to refer to a number of server-side language to achieve, in such a background, no features, two no practical value. But as JavaScript is used more and more in the front-end, and as the server-side JavaScript pushes, JavaScript's

This period of time, learn a little about es6 new norms of knowledge, and then whim, want to try to write with ES6 code in the browser run. Say dry, first said my implementation steps (did not expect to have a pit!) ） Translating ES6 code into ES5; The HTML file introduces the translated ES5; Then run in the browser environment; Run in the node environment; Then here are some of my directory structures, roughly previewed. SRC,ES6 Development Directory DIST,ES5 Production Catalo

does not need to immediately develop a dependent module, when the need for require on it, more convenient, and AMD on the contrary, the definition of modules need to develop a dependent module, and in the form of parameters to introduce factory AMD Mode definition Module define ([' Dep1 ', ' Dep2 '],function (DEP1,DEP2) { //internal only use the established module return function () {}; }); Cmd Define (function (require,exports,module) { //here if you need a XX mo

Inheritance:varModule_two = (function(old) {varmy ={}, key; for(KeyinchOld ) { if(Old.hasownproperty (key)) {My[key]=Old[key]; } } varSuper_modulemethod =Old.modulemethod; My.modulemethod=function () { //override method on the clone, access to super through Super_modulemethod }; returnmy;} (MODULE));The above code is streamlined: you can use Object.create ()var Module_two = (function (old) { var my = object.create (old); var super_modulemethod = old.modulemethod;

support However, there are two popular JavaScript modularization systems in the world: CommonJS implemented by Node and AMD. Many class libraries support both AMD and CommonJS, but do not support CMD. There may be many CMD modules in China, but they are not popular in the world. Currently, the popular React and peripheral class libraries are directly using the CommonJS