Master Node.js: From Basics to Production

Node.js is an open source, cross-platform runtime environment and library that is used for running web applications outside the client’s browser.

Node.js is an open-source and cross-platform JavaScript runtime environment.

It is a popular tool for almost any kind of project! Node.js runs the V8 JavaScript engine, Google Chrome’s core, outside the browser.

Node.js is a cross-platform runtime, perfect for a wide range of use cases.

Its huge community makes it easy to get started. It uses the V8 engine to compile JavaScript and runs at lightning-fast speeds.

Node.js was written initially by Ryan Dahl in 2009, about thirteen years after the introduction of the first server-side JavaScript environment, Netscape’s LiveWire Pro Web.

Both the browser and Node.js use JavaScript as their programming language.

Building apps that run in the browser is entirely different than building a Node.js application. Even though it’s always JavaScript, some key differences make the experience radically different.

The usual way to run a Node.js program is to run the globally available node command (once you install Node.js) and pass the name of the file you want to execute.

We split our code into different files to maintain, organize and reuse code whenever possible.

A module system allows us to split and include code and import code written by other developers whenever required.

CommonJS and ES (EcmaScript) are module systems used in Node.

CommonJS is the default module system. However, a new module system was recently added to NodeJS - ES modules.

ESM (ECMAScript Modules) is a standardized module system in JavaScript that allows for the organized, maintainable, and reusable structuring of code.

Modules are the collection of JavaScript codes in a separate logical file that can be used in external applications based on their related functionality.

There are two ways to create modules in Node.js i.e. either via CommonJS or ESM.

In browsers, the top-level scope is the global scope, and its global object is called the window object.

Within the browser, var something will define a new global variable inside the window object.

In Node.js, this is different.

npm is the standard package manager for Node.js.

NodeJS and NPM allow two methods of installing dependencies/packages: Local and Global.

This is mainly used when adding a package or dependency as part of a specific project you’re working on.

Locally installed packages are available only to the project where the packages are installed, while the globally installed packages can be used any where without installing them into a project.

Another use case of the global packages is when using CLI tools.

npm provides various features to help install and maintain the project’s dependencies.

Dependencies get updates with new features and fixes, so upgrading to a newer version is recommended. We use npm update commands for this.

In Node.js, npm scripts are used for the purpose of initiating a server, starting the build of a project, and also for running the tests. We can define this scripts in the package.json file of the folder. Also, we can split the huge scripts into many smaller parts if it is needed.

Workspace is a generic term that refers to the set of npm CLI features that support managing multiple packages from your local file system from within a singular top-level root package.

npm packages allow you to bundle some specific functionality into a reusable package which can then be uploaded to some package registry such as npm or GitHub packages and then be installed and reused in projects using npm.

Semantic Versioning is a standard for versioning software that’s widely adopted in the npm ecosystem.

It provides a clear and consistent way to communicate changes in a software package to users.

Error handling is a way to find bugs and solve them as quickly as humanly possible. The errors in Node.js can be either operation or programmer errors. Read the articles linked below to understand how to handle different types of errors in Node.js

JavaScript Errors are used by JavaScript to inform developers about various issue in the script being executed.

These issues can be syntax error where the developer/programmer has used the wrong syntax, it can be due to some wrong user input or some other problem.

Node.js generates system errors when exceptions occur within its runtime environment.

These usually occur when an application violates an operating system constraint.

User specified errors can be created by extending the base Error object, a built-in error class.

When creating errors in this manner, you should pass a message string that describes the error.

An AssertionError in Node.js is an error that is thrown when the assert module determines that a given expression is not truthy.

The assert module is a built-in Node.js module that provides a simple set of assertion tests that can be used to test the behavior of your code.

When a JavaScript error is not properly handled, an uncaughtException is emitted.

These suggest the programmer has made an error, and they should be treated with the utmost priority.

Errors must always be handled.

If you are using synchronous programming you could use a try catch. But this does not work if you work asynchronous!

Async errors will only be handled inside the callback function!

The stack trace is used to trace the active stack frames at a particular instance during the execution of a program.

The stack trace is useful while debugging code as it shows the exact point that has caused an error.

Node.js includes a command-line debugging utility.

The Node.js debugger client is not a full-featured debugger, but simple stepping and inspection are possible.

npx is a very powerful command that’s been available in npm starting version 5.2, released in July 2017.

If you don’t want to install npm, you can install npx as a standalone package.

Asynchronous code means that things can happen independently of the main program flow, async functions in JavaScript are processed in the background without blocking other requests.

It ensures non-blocking code execution.

A promise is commonly defined as a proxy for a value that will eventually become available.

Asynchronous functions use promise behind the scenes, so understanding how promises work is fundamental to understanding how “async” and “await” works.

Async/Await is a special syntax to work with promises in a more comfortable fashion.

It’s easy to understand and use.

Node.js, being an asynchronous platform, doesn’t wait around for things like file I/O to finish - Node.js uses callbacks.

A callback is a function called at the completion of a given task; this prevents any blocking, and allows other code to be run in the meantime.

The setTimeout runs a function after the specified period expires.

Times are declared in milliseconds.

The setInterval() method helps us to repeatedly execute a function after a fixed delay.

It returns a unique interval ID which can later be used by the clearInterval() method, which stops further repeated execution of the function.

The setImmediate function delays the execution of a function to be called after the current event loops finish all their execution. It’s very similar to calling setTimeout with 0 ms delay.

Every time the event loop takes a full trip, we call it a tick.

When we pass a function to process.nextTick(), we instruct the engine to invoke this function at the end of the current operation before the next event loop tick starts.

In Node.js, an event can be described simply as a string with a corresponding callback.

An event can be “emitted” (or, in other words, the corresponding callback be called) multiple times or you can choose to only listen for the first time it is emitted.

The Event Loop is one of the most critical aspects of Node.js. Why is this so important? Because it explains how Node.js can be asynchronous and have non-blocking I/O, it explains the “killer feature” of Node.js, which made it this successful.

You can programmatically manipulate files in Node.js with the built-in fs module. The name is short for “file system,” and the module contains all the functions you need to read, write, and delete files on the local machine.

The process.cwd() method returns the current working directory of the Node.js process.

The path module provides utilities for working with file and directory paths. It’s built-in to Node.js core and can simply be used by requiring it.

File System or fs module is a built in module in Node that enables interacting with the file system using JavaScript. All file system operations have synchronous, callback, and promise-based forms, and are accessible using both CommonJS syntax and ES6 Modules.

The __dirname in a node script returns the path of the folder where the current JavaScript file resides. __filename and __dirname are used to get the filename and directory name of the currently executing file.

The __filename in Node.js returns the filename of the executed code. It gives the absolute path of the code file. The following approach covers implementing __filename in the Node.js project.

The glob pattern is most commonly used to specify filenames, called wildcard characters, and strings, called wildcard matching.

User-friendly glob matching Based on fast-glob but adds a bunch of useful features.

fs-extra adds file system methods that aren’t included in the native fs module and adds promise support to the fs methods. It also uses graceful-fs to prevent EMFILE errors. It should be a drop in replacement for fs.

Chokidar is a fast open-source file watcher for node. js. You give it a bunch of files, it watches them for changes and notifies you every time an old file is edited; or a new file is created.

Command Line Applications are applications that can be run from the command line. They are also called CLI (Command Line Interface) applications. Users can interact with clients entirely by terminal commands. They are very useful for automation and building tools.

dotenv is a zero-dependency module that loads environment variables from a .env file into process.env. Storing configuration in the environment separate from code is based on The Twelve-Factor App methodology.

In Node. js, process. env is a global variable that is injected during runtime. It is a view of the state of the system environment variables. When we set an environment variable, it is loaded into process.env during runtime and can later be accessed.

Exiting is a way of terminating a Node.js process by using node.js process module.

The process.stdin is a standard Readable stream which listens for user input and is accessible via the process module. It uses on() function to listen for input events.

Prompts is a higher level and user friendly interface built on top of Node.js’s inbuilt Readline module. It supports different type of prompts such as text, password, autocomplete, date, etc. It is an interactive module and comes with inbuilt validation support.

Inquirer.js is a collection of common interactive command line interfaces for taking inputs from user.

It is promise based and supports chaining series of prompt questions together, receiving text input, checkboxes, lists of choices and much more.

The process.stdout property is an inbuilt application programming interface of the process module which is used to send data out of our program. A Writable Stream to stdout. It implements a write() method. console.log() prints to the process.stdout.write() with formatted output or new line.

Chalk is a clean and focused library used to do string styling in your terminal applications. With it, you can print different styled messages to your console such as changing font colors, font boldness, font opacity, and the background of any message printed on your console.

This package aims to fully implement the FIGfont spec in JavaScript, which represents the graphical arrangement of characters representing larger characters. It works in the browser and with Node.js.

CLI-Progress is a package that provides a custom progress bar for CLI applications.

process.argv is an array of parameters that are sent when you run a Node.js file or Node.js process.

Commander is a light-weight, expressive, and powerful command-line framework for node.js. with Commander.js you can create your own command-line interface (CLI).

API is the acronym for Application Programming Interface, which is a software intermediary that allows two applications to talk to each other.

Express is a node js web application framework that provides broad features for building web and mobile applications. It is used to build a single page, multi-page, and hybrid web application.

Fastify is a web framework highly focused on providing the best developer experience with the least overhead and a powerful plugin architecture, inspired by Hapi and Express.