NodeJS

• Node.js is a JavaScript runtime environment for the basic Chrome V8 engine
• Node.js uses an event-driven, non-blocking I/ O model, making it lightweight and efficient
• Node.js package manager NPM (Node Package Mange) is the largest open source library ecosystem in the world

• Command Line
• Html+css
• javascript
• Mongo DB (this is a non-relational database, we nodeJS choose to connect to it, because the query speed of a non-relational database is very fast, because there is no association between the table, unlike our myqSQL or Oracle relational database, Nodejs is a high concurrency language, so the speed of data operation is very high. Mongo DB is selected here.

• Webstorm (download and use webStorm directly, here does not write the download and installation process)
• Vscode (personally recommended to use this, this is a relatively lightweight editor, the important thing is that you can customize your own plug-in)
• Sublime (This is the best to use I think, but getting started is a bit more difficult)

For example

/ * * *@author clearlove
 * @aim Test a nodeJS global variable *@param Time The timing variable *@param Timer Clears a timer * setTimeout Indicates a delay * setInterval Indicates a timer cycle */
setTimeout(function () {
    console.info("Three seconds have passed and I'm done executing.")},3000)

var time = 0

let timer = setInterval(function () {
    time++
    console.info(time)
    if (time > 10) {
        clearInterval(timer)
        console.info("It's over.")}},2000)
Copy the code

• The results
  
  

There’s another thing we see a lot

console.info(__dirname)   //w file path name does not contain the file name. This is also a global variable in bNode
console.info(__filename)  // The full path name of the file
Copy the code

• First of all, let’s talk about why we need this engine and what it does. As we all know, our computer does not know what javascript we write, and the backend languages that the computer can recognize, such as C and C++, can recognize, but it does not know our JS. Node is written in C++. V8 engine is the core of nodejs. V8 engine is actually written in C++. The process is to write good JS code through v8 engine running in the Node environment, so as to achieve a computer to understand our JS language effect, a simple draw a foot of the flow chart, MD document drawing flow chart is relatively simple (CAodan).

• Here is my understanding, there may be some deviation, if there is any problem, inform me in time, I will update the content in time.

• When we write code, the general rule of development is the development of one function and one module, which is not only easy to develop, but also more convenient in order to avoid scolding you when others receive your code in future maintenance. So it’s the same in Node, every JS is a module. Then write a total js unified call. Let’s write a simple example:
• – We create a new tool class js, this purpose is for the user to input a data type, we output his data type

/ * * *@auhor clearlove
 * @aim Determine the data type entered by the user *@param {*} Params parameters * /
var counter = function(params) {
    return typeof params
}

// Export the current utility function to a place where it can be used directly
module.exports = counter
Copy the code

We introduce it in node_demo.js

/ * * *@author clearlove
 * @aim Receive module code *@parms Counter assigns the incoming js to counter */
let counter = require("./stuff")
console.info(counter(false))
Copy the code

Operation effect:

Module. Exports: require

• Module. exports aims to export current utility functions to a place where they can be imported, so they can be imported elsewhere
• Require directly imports the JS we need, why do we need a variable to receive it? Because if we don’t accept it we still can’t find a way to quote it

So, at this point, people are asking, what if we have one method and we have more than one? See the examples:

• stuff.js

/ * * *@auhor clearlove
 * @aim Determine the data type entered by the user *@param {*} Params parameters * /
var counter = function(params) {
    return typeof params
}
/ * * * *@param {*} a 
 * @param {*} b 
 */
var add = function(a, b) {
    return 'The result of the calculation is:${a+b}`
}
/ * * *@param PI PI */
var pi = 3.141592653589793238462643383279
    // Export the current utility function to a place where it can be used directly
module.exports.counter = counter
module.exports.add = add
module.exports.pi = pi
Copy the code

• node_demo.js

/ * * *@author clearlove
 * @aim Receive module code *@parms Counter assigns the incoming js to counter */
let stuff = require("./stuff") // Stuff is an object
console.info(stuff.counter(false))
console.info(stuff.add(584.654))
console.info(stuff.pi)
Copy the code

• The results
  
  

If you want to copy a hundred methods a hundred times, you can export an object directly and look at the code:

    /** * export each method name to */
module.exports = {
    counter: counter,
    add: add,
    pi: pi
}
Copy the code

• I’m not going to show the results here, but it’s the same as above. There is also the value of the object above you write your method is also ok, look at the code:

        / * * *@param PI PI */
    var pi = 3.141592653589793238462643383279
        /** * export each method name to */
    module.exports = {
        counter: function(params) {
            return typeof params
        },
        add: function(a, b) {
            return 'What you calculate is:${a + b}`
        },
        pi: pi
    }
Copy the code

${a+b} ${a+b} ${a+b} ${a+b} ${a+b} ${a+b} ${a+b}

• Events we often encounter in JS, such as mouse click, keyboard events, etc., events are to solve interaction problems, so node also has Event module, he is the three points we need to pay attention to the Event here: The Nodejs core API uses the traditional asynchronous EventEmitter architecture (FS/HTTP). All EventEmitter objects are instances of the EventEmitter class. The sequence of events is as follows: Import modules -> Create EventEmitter objects -> register events -> trigger events
• See the example

/ * * *@author clearlove
 * @aim Demonstrates the basic event usage process *@param MyEmitter creates the EventEmitter object */
Import event from 'events' import event from 'events' is written in the same way as below, except that it is written in ES6
var event = require('events');
// Create the EventEmitter object
var myEmitter = new event.EventEmitter();
Function ('click',function (params) {}) {// Register an event ('click',function (params) {}))
myEmitter.on('anyevent'.function(param){
    console.info(typeof param)
    //return typeof param
})
You can call the event directly or pass arguments
//myEmitter. Emit ('anyevent',false) //myEmitter. Emit ('anyevent',false
myEmitter.emit('anyevent'.false)
Copy the code

Running results:

• To handle asynchronous execution:

/ * * *@author clearlove
 * @aim Demonstrate asynchronous use *@param MyEmitter creates the EventEmitter object */
var event = require('events');
var myEmitter = new event.EventEmitter();
myEmitter.on('anyevent'.function(param){
    console.info(param)
})
myEmitter.emit('anyevent'.'I'm myEmitter event.')
console.info('I'm being executed after the myEmitter event.')
Copy the code

Running results:

We can see that our code is executed sequentially, that is, the following events are executed after the execution of the above declared events, so what if I want to reverse the execution order? Node’s official solution looks like this:

/ * * *@author clearlove
 * @aim Demonstrate asynchronous use *@param MyEmitter creates the EventEmitter object */
var event = require('events');
var myEmitter = new event.EventEmitter();
myEmitter.on('anyevent'.function(param){
    EventEmitter calls all listeners synchronously in the order in which they were registered. You must ensure that events are ordered correctly and race conditions are avoided. SetImmediate () or process.nexttick () can be used to switch to asynchronous mode
    setImmediate(() = >{
        console.info(param)
    })
})
myEmitter.emit('anyevent'.'I'm myEmitter event.')
console.info('I'm being executed before the myEmitter event.')
Copy the code

Running results:

I don’t need to write down any of the following methods: once, error, or whatever. Multiple parameter case handling, look at the code:

/ * * *@author clearlove
 * @aim Demonstrate multiple arguments *@param MyEmitter creates the EventEmitter object */
var event = require('events');
var myEmitter = new event.EventEmitter();
myEmitter.on('event'.(a, b) = > {
    console.log(a + b,this);
  });
  myEmitter.emit('event'.1.2);
Copy the code

Running results:

When a listener is called, this points to the EventEmitter object