Shulou(Shulou.com)06/03 Report--

This article will explain in detail the example analysis of the node.js command line tool. The editor thinks it is very practical, so I share it for you as a reference. I hope you can get something after reading this article.

one。 Let's learn about package.json first.

The root directory of each project has a package.json file that defines the various modules required for the project, as well as the project configuration information. Here is a relatively complete package.json file.

{"name": "vue-cli", "version": "2.9.3", "description": "A simple CLI for scaffolding Vue.js projects.", "preferGlobal": true, "bin": {"vue": "bin/vue", "vue-init": "bin/vue-init", "vue-list": "bin/vue-list"}, "repository": {"type": "" "url": "}," keywords ": []," author ":" litongqian "," license ":" MIT "," bugs ": {" url ":"}, "homepage": "", "scripts": {"test": "npm run lint & npm run e2e", "start": "node index.js"}, "dependencies": {"async": "^ 2.4.0" "chalk": "^ 2.1.0",}, "devDependencies": {"chai": "^ 4.1.2", "eslint": "^ 3.19.0",}, "engines": {"node": "> = 6.0.0"}}

1. Where the scripts field

Specifies the npm command line abbreviation for running script commands, for example, start specifies the command to be executed when running npm run start.

2. Bin field

The bin item is used to specify the location of the executable corresponding to each internal command.

"bin": {"vue": "bin/vue", "vue-init": "bin/vue-init", "vue-list": "bin/vue-list"}

The above code specifies that the executable file corresponding to the vue command is vue under the bin subdirectory.

3. Npm link

When developing NPM modules, we sometimes hope that require ('myModule') will automatically load modules in native development while we are developing and trying them out, for example, when debugging locally. Node stipulates that when using a module, it needs to be installed in the global or project's node_modules directory. For modules under development, the solution is to generate a symbolic link in the global node_modules directory that points to the module's local directory.

Npm link can do this, and the symbolic link will be established automatically.

Imagine a scenario where you develop a module myModule with the directory src/myModule, which is used by your own project myProject, and the project directory is src/myProject. First, run the npm link command under the module directory (src/myModule).

Src/myModule$ npm link

The above command generates a symbolic link file in the global module directory of NPM, whose name is the module name specified in the package.json file.

/ path/to/global/node_modules/myModule-> src/myModule

At this point, the myModule module can be called globally. However, if we want to install this module in the project, we need to do the following steps.

Change to the project directory, run the npm link command again, and specify the module name.

Src/myProject$ npm link myModule

The above command is equivalent to generating a symbolic link for the local module.

The copy code is as follows:

Src/myProject/node_modules/myModule-> / path/to/global/node_modules/myModule

Then, you can load the module in your project.

Var myModule = require ('myModule')

In this way, any changes to myModule can be directly reflected in the myProject project. However, there is a risk that any changes to myModule in the myProject directory will be reflected in the module's source code.

If your project no longer needs this module, you can use the npm unlink command in the project directory to remove the symbolic link.

Src/myProject$ npm unlink myModule

two。 Executable script

Write a simple script hello

$mkdir hello # create a folder

$cd hello & & touch hello # create a command file

#! / usr/bin/env nodeconsole.log ('hello world')

Be sure to add the line #! / usr/bin/env node to the header of the file, which means that node is used as the interpreter of the script, and the path of node is found through env, which can avoid the problem caused by different installation paths of node.

Open / usr/bin/env, you can view the PATH, and the operating system finds the node through the path

Then, modify the permissions of hello.

$chmod 755 hello$./hello

If you want to remove the path in front of hello, you can add the path of hello to the environment variable PATH. However, another better approach is to create a new package.json in the current directory and write the following.

{"name": "hello", "bin": {"hello": ". / hello"}}

Then execute the npm link command. If you don't understand, look up there.

$npm link

After execution, a global mapping relationship is generated, and the hello command can be used globally.

three。 Command line argument

Command-line arguments can be obtained with the system variable process.argv.

Modify hello script

#! / usr/bin/env nodeconsole.log ('hello', process.argv)

Where process is the global variable in the node process, process.argv is an array, each part of the command line is stored in the array, argv [0] is the installation path of node, argv [1] is the main module file path, and the rest are subcommands or parameters, as follows:

$hello a b c

The value of # process.argv is ['/ usr/local/bin/node','/ usr/local/bin/hello', 'a', 'baked,' c']

Scripts can create new child processes through the child_process module to execute Unix system commands and modify hello

The exec method is used to execute the bash command. The exec method can accept up to two parameters, the first parameter is the shell command to be executed, and the second parameter is the callback function, which accepts three parameters, namely, the error occurred, the display result of the standard output, and the display result of the standard error.

#! / usr/bin/env nodevar name = process.argv [2]; var exec = require ('child_process'). Exec;var child = exec (' echo hello'+ name, function (err, stdout, stderr) {if (err) throw err; console.log (stdout);})

Execute $hello litongqian

If we want to view all the files, modify the hello

Var name = process.argv [2]; var exec = require ('child_process'). Exec;var child = exec (name, function (err, stdout, stderr) {if (err) throw err; console.log (stdout);})

Execute $hello ls

There are three files in the hello directory

4. Shelljs module

The shell.js module repackages child_process to make it more convenient to call system commands. It needs to be used after installation.

Npm install-save shelljs

Then, rewrite the script.

#! / usr/bin/env nodevar name = process.argv [2]; var shell = require ("shelljs"); shell.exec ("echo hello" + name)

5. Yargs module

Shelljs only solves how to invoke shell commands, while the yargs module can solve how to handle command-line arguments. It also needs to be installed.

$npm install-save yargs

The yargs module provides an argv object for reading command-line arguments. Please look at the rewritten hello.

#! / usr/bin/env nodevar argv = require ('yargs') .argv;console.log (' hello', argv.name)

When in use, the following two uses can be used.

$hello-name=tomhello tom$ hello-name tomhello tom

In other words, the original return value of process.argv is as follows.

$node hello-name=tom ['node',' / usr/local/bin/hell','- name=tom']

Yargs can change the above result to an object, and each parameter item is a key-value pair.

six。 Publish command package

Publish via npm publish as long as you have a npm account. You can view the npm official documentation on how to do this.

This article uses native node.js to develop command tools, while vue-cli uses commander.js to simplify command tool development.

Understand the implementation process, to learn the corresponding module, it is good to know the principle!

Finally: sometimes the command line we use is not globally installed, but locally installed

1. Package.json bin field

The bin entry is used to specify the location of the executable corresponding to each internal command.

"name": "someTool", "bin": {"someTool": ". / bin/someTool.js"}

The above code specifies that the executable file corresponding to the someTool command is someTool.js under the bin subdirectory.

When a project relies on the someTool tool above, it is only installed locally

{"name": "myproject", "devDependencies": {"someTool": "latest"}, "scripts": {start: 'someTool build' / / equivalent to start:'. / node_modules/someTool/someTool.js build'}}

Npm will look for this file and establish a symbolic link in the node_modules/.bin/ directory. In the above example, someTool.js establishes the symbolic link npm_modules/.bin/someTool. Because the node_modules/.bin/ directory adds the system's PATH variable at run time, when you run npm, you can invoke these scripts directly through commands without a path.

Therefore, the method of writing like the above can be abbreviated.

Scripts: {start:'. / node_modules/someTool/someTool.js build'} / / abbreviated as scripts: {start: 'someTool build'}

All commands in the node_modules/.bin/ directory can be run in npm run [command] format. At the command line, type npm run, and then press the tab key, and all available commands are displayed.

1. Npm run

In the above code, the scripts field specifies two commands, start. Type npm run-script start or npm run start, and someTool build will be executed. Npm run is an acronym for npm run-script, and the former is generally used, but the latter better reflects the nature of the command.

The npm run command automatically adds the node_modules/.bin directory to the environment variable $PATH, so there is no need to add a path to the command in the scripts field, which avoids the global installation of the NPM module.

If npm run runs without any parameters, it will list all the script commands that can be executed in package.json.

Npm has two built-in command abbreviations, npm test is equivalent to executing npm run test, and npm start is equivalent to executing npm run start.

Npm run creates a Shell, executes the specified command, and temporarily adds node_modules/.bin to the PATH variable, which means that the local module can be run directly.

For example, you execute the ESLint installation command.

$npm i eslint-save-dev

After running the above command, two results are produced. First, ESLint is installed into the node_modules subdirectory of the current directory; second, the node_modules/.bin directory generates a symbolic link node_modules/.bin/eslint that points to the executable script for the ESLint module.

Then, you can reference the script eslint without a path in the script property of package.json.

{"name": "Test Project", "devDependencies": {"eslint": "^ 1.10.3"}, "scripts": {"lint": "eslint."}}

When you run npm run lint, it automatically executes. / node_modules/.bin/eslint. .

If you run npm run directly without giving any parameters, all commands under the scripts attribute will be listed.

$npm runAvailable scripts in the user-service package: lint jshint * *. Js test mocha test/ 's article on "sample Analysis of node.js Command Line tools" ends here. I hope the above content can be helpful to you so that you can learn more knowledge. if you think the article is good, please share it for more people to see.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.