Getting started with nodejs tutorial_node.js

Foreword

If we don’t learn nodeJs, we will be old... When the HTML5 wave hit, many ancestors started the journey of NodeJs, and at that time I was still doing server-side programs
Later, I switched to front-end, and the distance between me and the echelon is already very big. Because I know server-side languages ​​and have been working for a long time, I have only started to learn NodeJs and move towards a complete front-end
The plan to learn NodeJs this time is:
① 1-2 weeks to learn basic knowledge
② Develop a simple project in about 1 week
③ Use NodeJs to develop a set of tools for mobile terminal debugging
④ Packaging related (this may be a bit far away)

NodeJs Features

① Asynchronous
From file reading to network requests, NodeJs is completed asynchronously, and callback functions play an important role. Node is leading in terms of programming model

② Event callback
Event callbacks make programs lightweight, but the details are still up to the programmer. However, the callback function is actually quite difficult to read

③ Single thread
Node is single-threaded. If it were multi-threaded, the language would be too deep. It would be annoying to ask about in-process communication, but there are no deadlocks or other problems with threads
But there is a problem related to performance, because multi-core cannot be used;

Module mechanism/CommonJs

We used to do server-side development. If the code is not well organized, later maintenance will be very difficult, so there is MVC and three-tier architecture
Now the business logic of the front-end is gradually moving closer to the back-end. As far as single-page applications are concerned, it has surpassed the program logic of the back-end
The continuous increase in page views will bring about a surge in the amount of js code. How to manage our front-end code well has become a problem, so requireJs appeared...
PS: This paragraph has nothing to do with nodeJs...
JavaScript does not have a modular system, so CommonJs was proposed to give js the basis for developing large-scale applications

Module reference

If we want to reference a module, such as mathematical calculations:

var math = require('math');

Module definition

If we want to define our own module, we can do this

Copy code The code is as follows:

exports.add = function () {
Return sum;
}

If this function is defined in math, it can be used

math.add();

Module ID

The module identifier is the parameter passed to require. It needs to be named in camel case and points to a file path. This is very similar to requireJS

Module implementation

Module implementation in Node is divided into two categories, one is the system-level core module, and the other is the file module written by the user
The core modules are translated into binary files during the compilation process. After the Node process is started, some core modules will be loaded directly into the memory (file location, compilation and execution)
The file module needs to be loaded dynamically, which is relatively slow
But once loaded, those files will be cached, and the cached files (compiled files) will be read when they are introduced again
Let’s go a bit further here. When we use underscore, we will compile Html to form a template function (it is really just a function). In fact, this can be used for caching
Save the compiled function before deploying the project and remove the html template file (the optimization effect is unknown)

In node, each module is an object:

Copy code The code is as follows:

function Module(id, parent) {
this.id = id;
this.exports = {};
//parent is a keyword and should not be used indiscriminately
This.parent = parent;
if (parent && parent.children) {
parent.children.push(this);
}
this.filename = null;
this.loaded = false;
this.children = [];
}

The last stage of introducing file modules during compilation and execution. After locating the specific file, node will create a new module object, then load and compile according to the path
Each successfully compiled module will cache its file path as an index on Module._cache

Each module file has three variables: require, exports, and module, but they are not defined in the file (the same is true for the __filename__ and __dirname__ variables)
In fact, during the compilation process, Node wraps the contents of the javascript file head and tail (equivalent to passing the custom function into the window)

Copy code The code is as follows:

(function (exports, require, module, __filename__, __dirname__) {
var math = require('math');
exports.area = function (radius) {
Return '';
};
});

In this way, the modules are isolated and will not affect each other. This is somewhat similar to the compilation of underscore...

Packages and NPM

Node organizes its own core modules, so third-party file modules can be written and used in an orderly manner, but in third-party modules, modules are still hashed in various places
They cannot directly reference each other. Module outsourcing and NPM are a mechanism to establish connections
PS: Many modules will form a package. The concept of this package is similar to the concept of java package, so the concept of #assembly should be similar

After decompressing a package structure, several files will be formed:
① package.json description file
② bin executable binary directory
③ lib javascript code directory
④ doc document (nearly none)
⑤ test demo

The above are some of the specifications of the CommonJS package, but we can understand it a little bit (for beginners). NPM needs to be mastered. With the help of NPM, we can skillfully install the management package

Install dependency packages

Installing dependency packages is a common method:

npm install express
After execution, the node_modules directory will be created in the current directory, and then the express directory will be created under it...
PS: express is a popular web development framework on NodeJs, which helps us quickly develop a web application
It can be called after the installation is completed:

Copy code The code is as follows:

var express = require('express');

Conclusion

This section ends briefly, and our actual project process will gradually deepen later