Sending Command Line Arguments to NPM Script
Last Updated :
28 Mar, 2024
In the sector of NodeJS development, NPM (Node Package Manager) scripts are a effective tool for automating numerous tasks like strolling exams, building the mission, or starting a improvement server. However, there are times while you need to bypass arguments to these scripts to customize their behavior. This article will discover how you can ship command line arguments to NPM scripts.
We will discuss the following methods to send command line arguments to NPM Script:
Using process.argv()
1. Sending a single argument to an NPM script
Explanation: In this code we're executing an NPM script named "hello" that's described inside the package.json file. By running NPM run hello and passing the argument -- --name=John through the command line, the script script.js accesses this argument and outputs a greeting message. It prints "Hello, John!" which indicate that argument which was send has successfull.
Note: Install the minimist package for using this approach
$ npm i minimist
CODE
// package.json
{
"scripts": {
"hello": "node script.js"
}
}
Terminal
$ npm run hello -- --name=John
JavaScript
// script.js
const args = require('minimist')(process.argv.slice(2));
const name = args['name'];
console.log(`Hello ${name}!`);
Output:
Hello, John!
2. Sending multiple arguments to an npm script:
Explanation: We're running an npm script referred to as "greet", passing multiple arguments through the command line the usage of --. The script greet.Js processes those arguments and outputs a greeting message accordingly. In this situation, it prints "Hello, John!" because we provided the name "John" and the greeting "Hello" as arguments.
Note: Install the minimist package for using this approach
$ npm i minimist
CODE
// package.json
{
"scripts": {
"greet": "node greet.js"
}
}
Terminal
$ npm run greet -- --name=John --greeting=Hello
JavaScript
// greet.js
const args = require('minimist')(process.argv.slice(2));
const name = args['name'];
const greeting = args['greeting'];
console.log(`${greeting}, ${name}!`);
Output:
Hello, John!
Using npm_config_ Method
1. Sending a single argument to an npm script:
Explanation: In this code we are running an npm script named "hello" defined in package.json. using NPM run hello, followed by --name="Jane" in the terminal, we have passed a single argument to the script script.js. The script then uses this argument to output a greeting message "Hello Jane !".
CODE
// package.json
{
"scripts": {
"hello": "node script.js"
}
}
Terminal
$ npm run hello --name="Jane"
JavaScript
const nname = process.env.npm_config_name ? process.env.npm_config_name : "John"
console.log("Hello", nname, "!")
2. Sending multiple arguments to an npm script:
Explanation: in this code we are excuting an npm script named "greet" specified in package.json. By running npm run hello, followed by --firstName="Jason" --lastName="Roy" in the command line, we are passing multiple arguments to the script greet.js. The script accesses these arguments and generates a greeting message accordingly. In this case, it's output is "Hello Jason Roy"
CODE
// package.json
{
"scripts": {
"hello": "node script.js"
}
}
Terminal:
$ npm run hello --firstName="Jason" --lastName="Roy"
JavaScript
const firstName = process.env.npm_config_firstName ?
process.env.npm_config_firstName : "John"
const lastName = process.env.npm_config_lastName ?
process.env.npm_config_lastName : "Doe"
console.log("Hello", firstName, lastName)
Similar Reads
How to Read Command Line Arguments in Node ? Command-line arguments (CLI) consist of text strings utilized to provide extra information to a program during its execution via the command line interface of an operating system. Node facilitates the retrieval of these arguments through the global object, specifically the process object. ApproachTo
2 min read
Bash Script - How to use Command Line Arguments In this article, let us see about Command Line Arguments usage in Bash script. Arguments are inputs that are necessary to process the flow. Instead of getting input from a shell program or assigning it to the program, the arguments are passed in the execution part. Positional Parameters Command-line
4 min read
How to Parse Command Line Arguments in Node ? Command-line arguments, in the context of a command-line interface (CLI), are text strings that provide extra information to a program when it is executed.In Nodejs, these arguments are accessible through an array known as argv (arguments values), where the shell passes all received command-line arg
3 min read
How to print command line arguments passed to the script in Node.js ? Node.js is an open-source and cross-platform runtime environment built on Chrome's V8 engine that enables us to use JavaScript outside the browser. Node.js helps us to use build server-side applications using JavaScript. In Node.js if you want to print the command line arguments then we can access
2 min read
Command Line Arguments in ElectronJS ElectronJS is an Open Source Framework used for building Cross-Platform native desktop applications using web technologies such as HTML, CSS, and JavaScript which are capable of running on Windows, macOS, and Linux operating systems. It combines the Chromium engine and NodeJS into a Single Runtime.
6 min read
Introduction to NPM scripts NPM is a Node Package Manager. It is the world's largest Software Registry. This registry contains over 800,000 code packages. Many Open-source developers use npm to share software. Many organizations also use npm to manage private development. "npm scripts" are the entries in the scripts field of t
2 min read
How to Change npm start Script of Node.js ? In Node.js, npm (Node Package Manager) provides a convenient way to manage project scripts through the scripts field in the package.json file. By default, the npm start command is used to start your Node.js application. However, you might need to customize this command to suit specific requirements,
3 min read
How to execute TypeScript file using command line? TypeScript is a statically-typed superset of JavaScript that adds optional type annotations and compiles to plain JavaScript. It helps catch errors during development. To execute a TypeScript file from the command line, compile it using tsc filename.ts, then run the output JavaScript file with node.
2 min read
How to Build a JavaScript Command Line Interface (CLI) with Node.js In this article, we will see how to create a JavaScript CLI with the help of NodeJs.JavaScript being an interpreter language, it is a very dynamic language, due to which it provides us with many facilities, due to which many tasks become very easy and anyone can understand them very easily, so in to
4 min read
Pass function and arguments from node.js to Python Prerequisites: How to run python scripts in node.js using the child_process module. In this article, we are going to learn how to pass functions and arguments from node.js to Python using child_process. Although Node.js is one of the most widely used web development frameworks, it lacks machine lear
4 min read