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 Golang
Command-line arguments are a way to provide the parameters or arguments to the main function of a program. Similarly, In Go, we use this technique to pass the arguments at the run time of a program. In Golang, we have a package called as os package that contains an array called as "Args". Args is an
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
Multi-Line Comment in Shell Script
Comments are quite a crucial part of a program or a code-base. It helps in understanding the code, improves code-readability, and also helps in enhancing the structure of the program. We often write single-line comments in our programs as they are quite self-explanatory and require few words to desc
2 min read
How to Read Command Line Parameters from an R Script?
Reading command line parameters in an R script is essential for creating flexible and reusable scripts that can handle different inputs without modifying the code. This is particularly useful for automation and batch-processing tasks. This article will guide you through the process of reading comman
3 min read
Node.js NPM string-to-arraybuffer Module
NPM(Node Package Manager) is a package manager of Node.js packages. There is a NPM package called 'shortid' used to short non-sequential url-friendly unique ids. Command to install:Â Â npm install string-to-arraybuffer Syntax to import the package in local file const str2ab = require('string-to-array
5 min read