Introduction and Setup

In the world of NodeJS development, mastering the command line interface (CLI) is essential for efficiently executing JavaScript code outside of a browser environment.

Whether you're a beginner exploring the basics or an experienced developer seeking to optimize your workflow, understanding the various methods and common command line options for running Node.js scripts is key.

In this seriess part, we'll discuss some fundamentals of running NodeJS scripts from the CLI.

We'll explore different approaches, from using the `node` command to executing scripts with `shebang` notation and leveraging tools like `npx` and `pkg`.

Along the way, we'll uncover common command line options and best practices for seamless script execution.

First let's start with setting up nodeJS and get our environment ready to go.

Setting Up Node.js

Before we can start running Node.js scripts from the command line, we need to ensure that Node.js is properly installed on our system.

Fortunately, setting up Node.js is a straightforward process, regardless of your operating system.

Installing Node.js:

1. 1.Download NodeJS: Visit the official NodeJS website and download the appropriate installer for your operating system.
   
2. 2.Install NodeJS: Follow the installation instructions provided by the installer. NodeJS typically includes both the Node runtime and the npm package manager.
   
3. 3.Verify Installation: After installation, open your terminal or command prompt and run the following commands to verify that NodeJS and npm are installed correctly:

node -v
npm -v

These commands should print the installed versions of Node.js and npm, respectively.

Now the above is pretty straightforward, but in some cases, you may encounter some issues. If that happens, then check out this guide for a more detailed overview of the setup process : .

Running NodeJS Scripts using the node Command

The most common and straightforward way to execute nodeJS scripts is by using the node command in the command line interface.

With the node command, you can run :

• ➢JavaScript files directly,
• ➢execute inline code, and
• ➢pass command line arguments to your scripts.
  

Executing JavaScript Files:

To run a nodeJS script saved in a file, simply navigate to the directory containing the script in your terminal and use the node command followed by the filename:

node script.js

Assuming your file is also named `script.js`, this command will execute the script and output the result(if any) to the console.

Executing Inline Code:

In addition to running script files, you can also execute JavaScript code directly from the command line using the `-e` flag followed by the code to execute:

node -e "console.log('C\'est moi, NodeJS😎')"

This command should print `C'est moi, NodeJS😎` to the console.

Common Command Line Options:

The node command supports several command line options to customize script execution. Let's go through a few common ones.

• ➢-e <script>: Execute JavaScript code passed as a string argument as shown above
• ➢-r <module>: Preload a `module` before executing the script.

node -r esm script.js

In the place of esm, you used cjs which is the default module system for node.

Using ESM module system, let's you use modern javascript syntax like `import` instead of require when loading modules.

node -r esm -e "import fs from 'fs'; fs.access(filePath, (err) => { if (!err) console.log('You have access!'); })"

Make sure you've install esm npm install -g esm before running the above command.

• ➢--watch: Automatically restart script on file changes.

node --watch script.js

This command watches the specified script file for changes and automatically restarts the script whenever modifications are detected, facilitating development workflows.

Test:
- Add this line to the script.js file console.log("Initial content") and run the above command in your terminal.

- Change the content to console.log("Updated content").

As you can see, by leveraging these options, you can tailor the behavior of the node command to suit your specific requirements and workflows.

Using Shebang to Execute NodeJS Scripts

Above, you are explicitly telling the shell to run your script with node. But there are other ways to execute nodejs script and we'll explore a few below.

Using Shebang

In Unix-like operating systems (such as Linux and macOS), the shebang (#!) notation is used to specify the interpreter for executable scripts. By including a shebang line at the beginning of a script file, you can indicate the path to the interpreter that should be used to execute the script.

The shebang line consists of the characters `#!` followed by the path to the interpreter.

For Node.js scripts, the shebang line typically points to the `node` interpreter.

#!/usr/bin/env node

This shebang line tells the system to use the node interpreter located in the system's environment (/usr/bin/env) to execute the script.

Creating Executable Scripts:

To create an executable Node.js script with shebang, follow these steps:

• ➢Add Shebang Line: Open your text editor and add the shebang line at the beginning of your NodeJS script file.

#!/usr/bin/env node

console.log('Hello, world!');

NB: Make sure you replace the execution path (/usr/bin/env) with yours!

• ➢Make Script Executable: Make the script file executable using the chmod command:
  
  The `chmod` command stands for `change mode` and is used to modify the file mode bits of a file. In the context of making scripts executable, we use `chmod` to add the execute permission to the script file.

chmod +x script.js

• ➢Execute Script: Now you can run the script directly from the command line without specifying the node interpreter:

./script.js

You should get hello, world log on the terminal output.

Benefits of Shebang:

Using shebang to execute nodeJS scripts offers several benefits:

• ➢Portability: Shebang allows scripts to be executed across different Unix-like systems without hardcoding the path to the interpreter.
• ➢Ease of Use: Once a script is made executable, it can be run like any other command, simplifying execution.
• ➢Flexibility: Shebang provides flexibility in specifying the interpreter, enabling the use of different nodeJS versions or alternative interpreters.

Common Command Line Options and Best Practices

When running nodeJS scripts from the command line, there are several common options and best practices to consider.

These options can enhance the execution process and provide additional functionality to your scripts.

Some Command Line Options

• ➢--inspect: Enables the Node.js inspector for debugging and profiling. It allows you to connect Chrome DevTools or any other inspector client to debug and profile your nodeJS applications.

node --inspect script.js

• ➢--require: Preloads a module before executing the script. This option is useful for loading modules such as `dotenv` for environment configuration or custom utilities.

node --require dotenv/config script.js

• ➢--experimental-modules: Enables support for ECMAScript modules (ESM), which allows you to use import and export statements instead of require().

node --experimental-modules script.mjs

For the full list of options available for use, visit the offical page or use this command to list out all option: node -help.

Conclusion

Running nodeJS scripts from the command line is a fundamental aspect of Node.js development, enabling developers to execute scripts, automate tasks, and build powerful applications.

By leveraging command line options, best practices, and troubleshooting strategies, developers can optimize script execution, enhance reliability, and streamline development workflows.

Moving Forward: As you continue to develop nodeJS applications and scripts, remember the importance of running scripts effectively from the command line.

It's important to stay informed about new command line options, best practices, and tools that can improve your development experience and streamline your workflow.

By upping your skills in running nodeJS scripts from the command line, you can unlock the full potential of node and build robust, efficient applications that meet the needs of your users and stakeholders.

In the next part, we'll discuss reading and setting environment variable in nodeJS.