NODE.JS– a software tool for executing js.
Nodejs = V8 + I/O + libraries
V8: fast, modern, economical
Advantages
- Javascript
- Common code on client and server
- Basic web tasks
- Many connections and tasks at the same time
- Easy to create a working prototype
- Convenient npm package manager
- Community
Installation
When installing, nodejs writes itself to the PATH variable (+ npm), [administration - environment variables]; can be checked on the command line:
set PATH
As a rule, files are launched under nodejs: let's write a simple script and run it via the command line:
The script will be executed and the result will be displayed on the command line.
Nodejs documentation
nodejs modules
To understand how the built-in nodejs modules work, you need to download the source code archive from the nodejs website (source code). And go to the lib directory. (dir command - get a list of files via the command line; If you need to list files in all subfolders, then instead of "dir" use "dir /s"). If you installed nodejs from a package, you will not find any files in the lib folder.
Nodejs has modules with varying degrees of stability. (for example, 0 – should not be used; 1, 2 – can be used but the module API may change).
The functions are growing (the project is developing) and over time we will need to move the USER constructor function into a separate file. This is where modules come into play.
Modules are a kind of way that nodejs offers to organize a project.
Projects tend to grow, which leads to the desire to split the project into several files - this is where modules come into play.
require
For HTML pages, script tags are used to include scripts. Nodejs has a special require command.
Var user = require("./user");
In our example, we access the file (user.js) in the same directory (the extension (.js) is optional).
//require("./user"); // .js is not necessary to specify // in this case the file will be executed, but there will be no USER variable // this is the main difference from script tags from nodejs // In node.js, the functions and variables of each module are global // for this file (the module itself) and they do not automatically // become available when connected (require("./user")) // But how to gain access? // Each module has a special variable exports - this is an object and what // I put there will return as a result require var user = require("./user.js"); // result: user = ( User: function )
The first difference between the nodejs modular system and browser scripts: if there are two script tags in the browser, then a function that is defined at the global level in one of them is available in the other, but not in nodejs. In nodejs, functions and variables are global for a given file (they are not available when required). Thus, nodejs allows you to write truly independent modules. But for the module to be available, it is used export system. Each module has a special exports variable.
Module-directory DIR/index
We connect the folder directly var user = require("./user"); , which contains the corresponding index.js .
For example
Function User(name)( this.name = name; ) User.prototype.hello = function(who)( console.log(phrases.Hello + ", " + who.name); ); exports.User = User;
We connect and use the User constructor in the file ./server.js
//server.js var user = require("./user"); var vasya = new user.User("Vasya");
"./" - relative to the current folder
exports is an object and what is put there will be returned as the result of require (exports.jpg). This way the module can declare its private variables/functions and export only what is needed.
For global variables, etc. there is a global object
Global.User = User;
Bottom line
- Connection require
- Variables: var (private for modules), exports, global (rarely used)
- Types of modules: js, node (with the .node extension), json (with the .json extension). Json modules are used when you need to store some simple information on a file.
- Module-directory DIR/index
module object
- module object
- Module-function module.exports = function
- Caching modules (the module is never read again)
- Module arrangement: search order
- Passing parameters: module-factory
The module object (the fundamental object for modules) is a variable that exists in each module (file, you can output console.log(module;);). . Contents: id property – usually the path to the file,
parent – link to the parent module (module.parent – link to the parent module that requires this),
children (module.children - those modules that are connected via require),
exports property and others.
Module or application? module.parent
The module can be launched directly, but if not, if the functionality is connected to another module, then let it export this functionality. These two cases can be separated by checking:
If(module.parent) ( exports.run = run; ) else ( run(); )
ps: as they say on stackoverflow.com The parent is the module that called the script for interpretation
// $ node foo.js console.log(module.parent); // null // require("./foo") console.log(module.parent); // ( ... )
Proper use of module.exports
In the context of a module:
module.exports = exports = this (these constructs are equivalent)
If you want to pass a function not in an object, but directly, then use the following syntax:
Module.exports = User;
Module caching
When Nodejs loads a module, it completely creates the corresponding module object (taking into account parent , exports and other similar properties) and remembers it in itself (module.id (the full path to the file) serves as an identifier for the internal cache) and the next time we re- we access (connect) to any module (file), nodejs takes the same object from the cache. That is, for example, it is enough to initialize a module once in a file; in the future you can simply use it.
In our case, for var db = require("../db");
and for var db = require("./db"); the same object is taken. Therefore, the principle is as follows: the first time a module is used, it is initialized and in the future we only connect it and use it (that is, in our case we do not need to use db.connect() twice, that is, in different files).
Module arrangement: the order in which modules are found in nodejs
How to make the db always connect without specifying a specific path:
Var db = require("../db"); //or var db = require("./db");
and like this:
Var db = require("db");
regardless of the file in which db is connected.
To do this, you need to understand the search order for modules in nodejs (what happens when require is called). There are many built-in modules in nodejs, for example require("fs"); , which will be connected without problems. If you specify a specific path in require, for example, require("../db"); , then the search will be based on the given path and the file will be found, or nodejs will try to get this file as a directory (and will look for index.js inside the category).
If you specify require("db"); and the module is not built-in, then the node_modules directory will be searched relative to the current position (if found, it will try to take the module from it). If the node_modules directory is missing, then the node_modules directory will be searched above, etc.
Besides specifying a specific path for a module, nodejs can search for modules like this:
Introduction to npm - the package manager for Node.JS
- create a package description file (package.json) that contains information about the module (name, version, etc.). Either manually or via command
npm init
(will ask for the necessary information) - To publish a module you need to:
- Add a user using the npm adduser command (you must enter Username and Password). Now all work with npm will be done on behalf of this user. The user can log in to https://www.npmjs.com/~name_user and monitor their modules.
- Publishing: npm publish
- Then someone can use your module added to the database, and the user himself can make changes.
- Get all npm commands using the npm help command
- Search for a module in the database: npm s keywords or npm search keywords (for example, npm s super module)
- Install the module: npm install name_module or npm i name_module
- When installing modules, nodejs first looks for the node_modules folder in the current directory (then higher and higher, etc.), or (if node_modules is missing) looks for package.json (also going up; package.json usually denotes the root of the project) and, accordingly, if it finds package.json, it creates a node_modules folder in the corresponding directory; if both options fail, then nodejs creates a node_modules folder in the current directory. If you want to place a module in a specific directory, then you need to create a node_modules folder in that directory.
- npm up update module (will check for update modules that are in the node_modules folder)
- npm remove modulename (remove module)
Output from npm:
npm init
nmp adduser
npm publish
npm search keywords
npm install module
npm update module
npm remove module
npm help command
NPM Package Structure
Installing the required version, for example: npm i [email protected]
The latest version of the module can be obtained if the module is developed using the git versioning system, for example, on github. It is enough to get Git Read-Only (url): https://github.com/strongloop/express.git and in the console:
npm i https://github.com/strongloop/express.git
dependencies in package.json
dependencies points to those modules on which this one depends.
devDependencies
Modules registered in devDependencies are not installed if the module is pulled as a dependency. They are installed only for development and can be installed if, for example, you go to the module in the node_modules folder and enter npm i (or by setting the npm config flag).
the main field specifies the entry point into the package
Global modules
Any module can be installed globally if you set the -g flag: npm -g module
Global means to the system directory.
Directory of global modules for windows:
C:\users\User_Name\AppData\Roaming\npm
Global modules are placed in the standard system directory. Those binaries that are in package.json will be installed on the system path (this is the main use of global modules), that is, in the future they can be called through the console.
Based on materials from I. Kantor's courses
Hey guys, in today's article I want to talk about global variables in Node. This article is aimed at developers who are at a beginner to intermediate skill level working with Node. If you have never heard of global variables or worked with them , no need to worry. This article will get you up and running in no time with everything you need to know about global variables.
What are Global Variables?
Global variables are very similar, if not identical, to regular variables. Global variables can be initialized with a value, that value can be changed, and they can even be cleared out like a regular variable. The difference between a regular variable and a global variable comes down to their scope. When you create a variable in a JavaScript file, that variables only exists in the scope that it was declared in. Now what do I mean by this? In the code below, you can see an example of two different variables with different scopes.
// Scope.js let fileScope = "Can be accessed anywhere in the file"; function doSomething() ( let localScope = "Can only be accessed inside this function"; fileScope = "Can be accessed in the function too!"; ) // This will result in an error because the variable does not exist // outside the function. localScope = "Try and change me here";
In the code snippet above, we can see that there are two variables, fileScope and localScope . The variable fileScope can be changed or called from anywhere within this file, whereas the localScope variable only exists inside the function doSomething() . I"m sure at this point you are wondering what this has to do with global variables. When we talk about global variables, they exist for all of the files in a program meaning they have global scope for the program.
The reason this is possible is because JavaScript programs share a global namespace between all of the files in the program. To put it another way, imagine that your program is a giant file or container that has "imported" all the other JavaScript files. You then declare a variable in this large container file, that variable now has scope throughout the whole program. If you are not sure what a namespace is or you want to find out more about them, check out this article to learn more.
How to Declare and Use a Global Variable
Now that we have a better understanding of what a global variable in Node is, let"s talk about how we actually set up and use a global variable. To set up a global variable, we need to create it on the global object. The global object is what gives us the scope of the entire project, rather than just the file (module) the variable was created in. In the code block below, we create a global variable called globalString and we give it a value. Next, we change the value of globalString , and then finally we set it to undefined.
// Global.js global.globalString = "This can be accessed anywhere!"; console.log(globalString); // Output: "This can be accessed anywhere!" globalString = "Check me out now"; console.log(globalString); // Output: "Check me out now" globalString = undefined; console.log(globalString); // Output: undefined // Example.js // We can use the global we created in Global.js in this file // as well. console.log(globalString); // Output: undefined globalString = “We can change it too!”; console.log(globalString); // Output: “We can change it too!”
What I have not talked about yet is another way that you can make a variable global. The reason I have excluded this is because it is not a proper way of setting up a variable. If you declare a variable in a file without using the keyword var and then assign a value to it, the global object will set a property for this variable. This process essentially turns it into a globally accessible variable. I strongly advise against using this method though as it is not the proper way to go about creating globals. It is also important to note that if you set the "use strict" directive, Node will disable implicit globals and you will likely end up with an error at runtime rather than a working script.
Practical Use Cases for Global Variables
Now, you might be thinking to yourself that you want to go off and create global variables now that you know more about them. I am going to strongly caution against creating global variables for a few very important reasons.
The first reason is that when you create a global variable, it exists throughout the lifetime of the application. When a variable persists through the lifetime of the app it means that it is there, in memory, occupying resources while the app is running.
Second, traditionally using global variables can cause concurrency issues. If multiple threads can access the same variable and there are no access modifiers or failsafes in place, it can lead to some serious issues of two threads attempting to access and use the same variable. However, while this is the case in other languages, it is not necessarily the case for Node.js as it is strictly a single-threaded environment. While it is possible to cluster Node processes, there is no native way to communicate between them.
The last reason I am going to talk about is that using globals can cause implicit coupling between files or variables. Coupling is not a good thing when it comes to writing great code. When writing code, we want to make sure that it is as modular and reusable as possible, while also making sure it is easy to use and understand. Coupling pieces of your code together can lead to some major headaches down the road when you are trying to debug why something isn't working.
If you want to know more about why globals are not recommended, you can check out this great article called Global Variables Are Bad.
If you feel confused as to the purpose of global variables, fear not. We are going to take a look at a few of the global variables that are built into Node and try to get a better understanding of why they are global and how they are used. In fact, you have probably used a few of them already without even realizing that they are global objects!
// Node Globals console.log("Hello World!"); process.env.PORT = 3000; setInterval(( console.log("2 seconds passed."); 2000);
If you take a look at the above code block you will probably see at least one instance you have used before, console.log() . According to the Node documentation, the console object is a global that has a few methods allowing developers to do things such as printing a log or an error. Digging deeper into the docs we can see that console is really a global instance that is configured to write to process.stdout and process.stderr .
This brings us to the next statement that you see in the code block above, the process object. If you have put up a production build of a Node application, then you have likely had to set the port for the environment variable. The environment variable env is a part of the process object which is another global. You can access variables on the process object in any file in your project because it is global. If this object was not global, the console object would not be accessible from any file either, remember it is really an object that refers back to the process object.
setInterval is another function that you may have seen before if you ever had reason to delay an operation before executing it. setTimeout and setImmediate are similar in nature to setInterval and are both global functions as well. These three functions are a part of the timer module which exposes a global API allowing you to call these functions without requiring timer in your files explicitly.
All of the above mentioned use cases are built in to Node and are global for a reason. The process object is global because it provides information about the current running Node process and therefore should be available from any file without having to require it. The same can be said of the timer module which contains a number of functions that are important and should be accessible anywhere without having to require it. If you would like to learn more about the existing global objects built into Node, I encourage you to visit the official documentation on Globals.
Learn More
Want to learn more about the fundamentals of Node.js? Personally, I"d recommend an online course, like Wes Bos" Learn Node.js since the videos are much easier to follow and you"ll actually get to build a real-world application.
Conclusion
I know that was quite a bit of information, so thank you for sticking it out. All of the above information was found in the documentation on Node's website. Please feel free to ask questions and give comments in the comment section below. Until next time guys!
JavaScript has a special object called a Global Object, it and all of its attributes can be accessed anywhere in the program, a global variable.
A JavaScript browser is usually a global window object, a Node.js global object is a global object, all global variables (except the global self) are owned by the global object.
In Node.js we have direct access to global properties, without having to include it in the application.
Global objects and global variables
The most fundamental global role is as a global host variable. By ECMAScript definition, the following conditions are global variables:
- The variable External is defined;
- Global object properties;
- The variable is implicitly defined (direct assignment to undefined variables).
When you define a global variable, the variable will also become the property of the global object, and vice versa. Note that, in Node.js, you cannot define variables in an external context, since all user code is part of the current module, and the module itself is not an external context.
Note: always use var to define variables in order to avoid introducing a global variable, as global variables will pollute the namespace, increasing the risk of communication code.
__filename
__filename specifies the file name of the script currently running. The absolute path to the location where the output file will be, but the command line option and specify the file name are not necessarily the same. If in a module, the returned value is the path to the module's file.
examples
// 输出全局变量 __filename 的值 console.log(__filename);$ node main.js /web/com/w3big/nodejs/main.js
__dirname
__dirname represents the script directory currently located.
examples
Create a main.js file, code like this:
// 输出全局变量 __dirname 的值 console.log(__dirname);The main.js executable file, the code looks like this:
$ node main.js /web/com/w3big/nodejs
setTimeout(CB, ms)
setTimeout(C - Bi, ms): The SetTimeout() function is specified only once.
It returns the value of the handle representing the timer.
examples
Create a main.js file, code like this:
Function printHello())( console.log("Hello, World!"); ) // setTimeout(printHello, 2000);
The main.js executable file, the code looks like this:
$ node main.js Hello, World!
clearTimeout(t)
clearTimeout(t) is used to stop the global function before passing setTimeout() to create the timer. Parameter T function setTimeout() to create a calculator.
examples
Create a main.js file, code like this:
Function printHello())( console.log("Hello, World!"); ) // var t = setTimeout(printHello, 2000); // 清除定时器 clearTimeout(t);
The main.js executable file, the code looks like this:
$nodemain.js
setInterval(CB, ms)
setInterval(C - Bi, ms) The global function executes the specified function after a specified number of milliseconds (ms) Number (CB).
It returns the value of the handle representing the timer. You can use the function clearInterval(T) to clear the timer.
The setInterval() method will continue to call the function until clearInterval() is called or the window is closed.
examples
Create a main.js file, code like this:
Function printHello())( console.log("Hello, World!"); ) // setInterval(printHello, 2000);
The main.js executable file, the code looks like this:
$ node main.js Hello, World! Hello, World! Hello, World! Hello, World! Hello, World! ......
The above program will output "Hello, World!" once every two seconds, and will continuously execute until the button is pressed CTRL + C.
console
Console The console for providing standard output, which is the debugging facility provided by the JScript engine in Internet Explorer, and later became the de facto browser standard.
Node.js follows this standard, ensuring consistent behavior and habits of the console object used in the standard output stream (STDOUT) or standard error stream (STDERR) output characters.
console method
Below is the console object:
| No. | Method and description |
|---|---|
| 1 | console.log([data] [, ... ]) For standard printable output stream characters and end with a newline character. This method accepts several parameters, if there is only one parameter, then the output is a string of this parameter. If there are multiple arguments, places such as the command output format in C E(). |
| 2 | console.info([data] [, ... ]) P role of the command returns an informational message, the console.log command does not make much difference, in addition to chrome, only text will be output, the rest will show a blue exclamation mark. |
| 3 | console.error([data] [, ... ]) Output error message. The console will display red when a fork error occurs. |
| 4 | console.warn([data] [, ... ]) A warning message is displayed. The console displays with a yellow exclamation mark. |
| 5 | console.dir(OBJ[, options]) Object used for inspection (inspection) and easy to read display and print formats. |
| 6 | console.time (shortcut) Time output, start time. |
| 7 | console.timeEnd(shortcut) End time, which indicates the end of time. |
| 8 | console.trace(message [, ...]) The code currently implements the call path on the stack, running this test function is useful, just want to test the function which is joined by console.trace on the line. |
| 9 | console.assert(value[, message][, ...]) To determine whether a variable or expression is true, two parameters were required, the first parameter is an expression and the second argument is a string. Only when the first argument is false, then the output will be the second argument; it will have no results. |
console.log accepts multiple parameters, if there is only one parameter, the output string of that parameter. If there are multiple arguments, places such as the command output format in C E().
The first parameter is a string, no parameters, just print a newline character.
Console.log("Hello world"); console.log("byvoid%diovyb"); console.log("byvoid%diovyb", 1991);
Hello world byvoid%diovyb byvoid1991iovyb
- console.error(): With console.log() it does the same thing, but outputs to standard error.
- console.trace(): Stream errors to standard output of the current call stack.
Operating results as follows:
Trace: at Object.
examples
Create a main.js file, code like this:
Console.info("程序开始执行："); var counter = 10; console.log("计数: %d", counter); console.time("获取数据"); // // 执行一些代码 // console.timeEnd("获取数据"); console.info("程序执行完毕。")
The main.js executable file, the code looks like this:
$ node main.js 程序开始执行： 计数: 10 获取数据: 0ms 程序执行完毕
process
A process is a global variable, an attribute is a global object.
It is used to describe the current process state of a Node.js object and provides a simple interface to the operating system. Usually you write your own command line programs and end up dealing with it. Below will introduce some of the most commonly used method of objecting process by members.
| No. | Events and description |
|---|---|
| 1 | exit Fires when the process is ready to quit. |
| 2 | beforeExit This event is fired when the node has an empty event loop, and no other action is taken. In general, there is no process to organize an exit node, but "beforeExit" listeners can be called asynchronously so that the node will continue. |
| 3 | uncaughtException When an exception is boiled back into the event loop, raise this event. If you add a monitor to an exception, the default action (stack printing and exit) will not occur. |
| 4 | The signal is triggered when event when the process receives a signal. Review the list of standard POSIX signal names such as SIGINT, SIGUSR1, and so on. |
examples
Create a main.js file, code like this:
Process.on("exit", function(code) ( // setTimeout(function() ( console.log("该代码不会执行"); 0); console.log(" 退出码为:", code); )); console.log("程序执行结束");
The main.js executable file, the code looks like this:
$ node main.js 程序执行结束退出码为: 0
Output Status Codes
| Status code | Title and description |
|---|---|
| 1 | Uncaught Fatal Exception There is an uncaught exception and it was not handled or the domain of the uncaughtException handler. |
| 2 | unused retention |
| 3 | JavaScript Internal Error Analyze The JavaScript error parsing source code is called when the Node process starts. Very rarely, only when Node. |
| 4 | Internal JavaScript fault Score The JavaScript process running the source node returns failure when evaluating the function. Very rarely, only when Node. |
| 5 | Fatal error V8 in an uncorrectable error with a fatal outcome. Usually print Stderr, content: fatal error |
| 6 | Non-Function Internal Exception Handler Uncaught exception, the exception handler inside is somehow set to the function, and also cannot be called. |
| 7 | Internal Run-Time Handler Exception Failure Uncaught exception, and the exception handler to handle its own throws an exception. For example, if process.on("uncaughtException") or domain.on("error") throws an exception. |
| 8 | unused retention |
| 9 | Invalid argument It may be unknown parameters or parameter to value. |
| 10 | Internal JavaScript Run-Time failed JavaScript source code is generated when errors are triggered in the Node process, very rarely, only when there is development of Node. |
| 12 | Invalid Debug Argument --debug option set and/or --debug-BRK, but selected the wrong port. |
| > 128 | Signal outputs If a node receives a fatal signal, such as SIGKILL or SIGHUP, then the return code is 128 plus the signal code. This is standard Unix practice, high code on the output signals. |
process attributes
The process provides many useful properties, ease of interaction, that we can better control the system:
| Qty. | Property & Description |
|---|---|
| 1 | STDOUT Standard output stream. |
| 2 | STDERR Standard error stream. |
| 3 | STDIN Standard input stream. |
| 4 | ARGV The ARGV property returns an array of various options for executing a command line script when composing. Its first members are always a node, its second member is the script file name, and the remaining members are script file parameters. |
| 5 | execPath Returns the absolute path of the current script execution binary node. |
| 6 | execArgv Returns the array member located under the command line script executed between the node executable command line parameters of the script file. |
| 7 | ENV Returns an object, the members of the current shell environment variable |
| 8 | ExitCode The exit code for the process, if the process is presented with process.exit() exit, without specifying an exit code. |
| 9 | version node version, such as v0.10.18. |
| 10 | versions A property that contains the versions of nodes and dependencies. |
| 11 | config The object that contains the current node is used to compile the executable javascript options configuration file. This is the same run./configure script created by the "config.gypi" file. |
| 12 | PID - regulator
Current process number. |
| 13 | Name Process name, default "node", you can customize the value. |
| 14 | arch Current CPU architecture: "arm", "ia32" or "64". |
| 15 | platform Run the program where the platform is "Darwin", "FreeBSD", "Linux", "SunOS" or "win32" |
| 16 | mainModule require.main alternative methods. Various points, if the main module changes at runtime, require.main may keep falling back to the old module. Both are considered to belong to the same module. |
examples
Create a main.js file, code like this:
// 输出到终端 process.stdout.write("Hello World!" + "\n"); // 通过参数读取 process.argv.forEach(function(val, index, array) ( console.log(index + ": " + val); )); // 获取执行路局 console.log(process.execPath); // 平台信息 console.log(process.platform);
The main.js executable file, the code looks like this:
$ node main.js Hello World! 0: node 1: /web/www/node/main.js /usr/local/node/0.10.36/bin/node darwin
Method Reference Guide
The process provides many useful methods to facilitate more efficient control of our interactive system:
| No. | Method and description |
|---|---|
| 1 | abort() This will raise the interrupt node trigger event. This will cause node to exit and create a dump file. |
| 2 | ChDir (directory) Change the process's current working directory if the operation cannot quit. |
| 3 | EAR () Returns the working directory of the current process |
| 4 | exit([code]) Ends the process with the specified code. If this parameter is omitted, it will use code 0. |
| 5 | getgid() Get process group identification (see getgid(2)). When a group was purchased a digital ID rather than a name. |
| 6 | setgid(ID) Setting up the group identification process (see setgid (2)). The ID can take a numeric or group name. If you specify a group name, blocking will be allowed waiting for a digital ID. Note: This function can only be used (eg non-Windows and Android) on POSIX platforms. |
| 7 | getuid() Get the user's identification process (see getuid(2)). This is a numeric user ID, not a user name. Note: This function can only be used (eg non-Windows and Android) on POSIX platforms. |
| 8 | UIP (ID) Process setup user ID (see UIP (2)). Retrieving a digital identifier or name string. If you specify a group name, blocking will be allowed waiting for a digital ID. Note: This function can only be used (eg non-Windows and Android) on POSIX platforms. |
| 9 | getgroups() The process of returning the group ID array. The POSIX system does not guarantee that it is, but Node.js is guaranteed to be there. Note: This function can only be used (eg non-Windows and Android) on POSIX platforms. |
| 10 | setgroups Set the process group ID. It is eligible to work, all you need is to have superuser privileges, or have the CAP_SETGID capability. Note: This function can only be used (eg non-Windows and Android) on POSIX platforms. |
| 11 | initgroups(user, extra_group) Reading / etc. /group, and initializes the group access list, all members of the group are located. It is eligible to work, all you need is to have superuser privileges, or have the CAP_SETGID capability. Note: This function can only be used (eg non-Windows and Android) on POSIX platforms. |
| 12 | kill (IDP [signal]) Sends a signal to a process. The ID is the process identifier, and the signal is a string indicating the signal being transmitted. Signal names are strings like "SIGINT" or "" SIGHUP. If this parameter is omitted, the signal will be "SIGTERM". |
| 13 | MemoryUsage() It returns an object that describes the process used by the node's memory status bytes. |
| 14 | nextTick(callback) After the current function callback event loop ends. |
| 15 | Umask ([mask]) Set or read process mask file. Child processes inherit this mask from the parent process. If the mask argument is true, then it returns the old mask. Otherwise, it returns the current mask. |
| 16 | Spent() Returns the number of seconds Node has already started. |
| 17 | hrtime() Time resolution of the current process, specified as [seconds] array nanoseconds. This is relative to any past event. This value has nothing to do with the date, so it does not affect clock drift. The main purpose is over a precise period of time to measure the performance of the program. Before the result can be passed to the current process.hrtime(), it will return the time difference between them, for the reference and time interval measurement. |
examples
Create a main.js file, code like this:
// 输出当前目录 console.log("当前目录: " + process.cwd()); // 输出当前版本 console.log("当前版本: " + process.version); // 输出内存使用情况 console.log(process.memoryUsage());In a node, you can set global variables using the "global" or "GLOBAL" object:
GLOBAL._ = require("underscore"); // but you "shouldn"t" do this! (see note below)
or more useful...
GLOBAL.window = GLOBAL; // like in the browser
From the node, you can see that they are stitched together:
Node-v0.6.6/src/node.js:28:global = this; 128: global.GLOBAL = global;
In the above code, "this" is the global context. With the commonJS module (which node uses), this "object" inside the module (i.e. "your code") is NOT the global context. For proof of this, see below where I spew out "this" object and then the giant "GLOBAL" object.
Console.log("\nTHIS:"); console.log(this); console.log("\nGLOBAL:"); console.log(global); /* outputs ... THIS: {} GLOBAL: ( ArrayBuffer: , Int8Array: ( BYTES_PER_ELEMENT: 1 ), Uint8Array: ( BYTES_PER_ELEMENT: 1 ), Int16Array: ( BYTES_PER_ELEMENT: 2 ), Uint16Array: ( BYTES_PER_ELEMENT: 2 ), Int32Array: ( BYTES_PER_ELEMENT: 4 ), Uint32Array: ( BYTES_PER _ELEMENT: 4 ), Float32Array: ( BYTES_PER_ELEMENT: 4 ), Float64Array: ( BYTES_PER_ELEMENT: 8 ), DataView: , global: , process: ( EventEmitter: , title: "node", assert: , version: "v0.6.5", _tickCallback: , moduleLoadList: [ "Binding evals", "Binding natives", "NativeModule events", "NativeModule buffer", "Binding buffer", "NativeModule assert", "NativeModule util", "NativeModule path", "NativeModule module", "NativeModule fs", "Binding fs", "Binding constants", "NativeModule stream", "NativeModule console", "Binding tty_wrap", "NativeModule tty", "NativeModule net", "NativeModule timers", "Binding timer_wrap", "NativeModule _linklist" ], versions: ( node: "0.6.5", v8: "3.6.6.11", ares: "1.7.5-DEV", uv: "0.6", openssl: "0.9.8n" ), nextTick: , stdout: , arch: "x64", stderr: , platform: "darwin", argv: [ "node", "/workspace/zd/zgap/darwin-js/index.js" ], stdin: , env: ( TERM_PROGRAM: "iTerm.app", "COM_GOOGLE_CHROME_FRAMEWORK_SERVICE_PROCESS/USERS/DDOPSON/LIBRARY/APPLICATION_SUPPORT/GOOGLE/CHROME_SOCKET": "/tmp/launch-nNl1vo/ServiceProcessSocket", TERM: "xterm", SHELL: "/bin/bash", TMPDIR: "/var/folders/2h/2hQmtmXlFT4yVGtr5DBpdl9LAiQ/-Tmp-/", Apple_PubSub_Socket_Render: "/tmp/launch-9Ga0PT/Render", USER: "ddopson", COMMAND_MODE: "unix2003", SSH_AUTH_SOCK: "/tmp/launch -sD905b/Listeners", __CF_USER_TEXT_ENCODING: "0x12D732E7:0:0", PATH: "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:~/bin:/usr/X11 /bin", PWD: "/workspace/zd/zgap/darwin-js", LANG: "en_US.UTF-8", ITERM_PROFILE: "Default", SHLVL: "1", COLORFGBG: "7;0", HOME : "/Users/ddopson", ITERM_SESSION_ID: "w0t0p0", LOGNAME: "ddopson", DISPLAY: "/tmp/launch-l9RQXI/org.x:0", OLDPWD: "/workspace/zd/zgap/darwin-js /external", _: "./index.js"), openStdin: , exit: , pid: 10321, features: ( debug: false, uv: true, ipv6: true, tls_npn: false, tls_sni: true, tls: true ), kill: , execPath: "/usr/local/bin/node", addListener: , _needTickCallback: , on: , removeListener: , reallyExit: , chdir: , debug: , error: , cwd: , watchFile: , umask : , getuid: , unwatchFile: , mixin: , setuid: , setgid: , createChildProcess: , getgid: , inherits: , _kill: , _byteLength: , mainModule: ( id: ". ", exports: (), parent: null, filename: "/workspace/zd/zgap/darwin-js/index.js", loaded: false, exited: false, children: , paths: ), _debugProcess: , dlopen: , uptime: , memoryUsage: , uvCounters: , binding: ), GLOBAL: , root: , Buffer: ( poolSize: 8192, isBuffer: , byteLength: , _charsWritten: 8 ), setTimeout: , setInterval: , clearTimeout: , clearInterval: , console: , window: , navigator: () ) */
**Note: Regarding the "GLOBAL._" setting, in general you should just do var _ = require("underscore"); . Yes, you do this in every file that uses underscore, just like in Java you do import com.foo.bar; . This makes it easier to determine what your code is doing because the links between files are "explicit". Mildly annoying, but good. This is a sermon.
There is an exception to every rule. I had exactly one instance where I needed to set "GLOBAL._". I was creating a system for defining "config" files that were mostly JSON, but were "written in JS" to add a little more flexibility. There were no "require" statements in such config files, but I wanted them to have access to underscore (the ENTIRE system was based on underscore and underscore patterns), so I would set "GLOBAL._" before evaluating "config". So yes, for every rule there is an exception somewhere. But you have a good reason, not just "I'm tired of typing" so I want to break the agreement."