Get started with NodeJS - All you need to know

Node.js is a cross-platform, open-source JavaScript runtime environment that enables developers to use JavaScript to write command-line tools and server-side scripting applications for running on the server-side, outside of the web browser. Here is all you need to know to get started.

Node.js is a cross-platform, open-source JavaScript runtime environment built on the V8 JavaScript engine used to build scalable, high-performance network applications. It enables developers to use JavaScript to write command-line tools and server-side scripting applications for running on the server-side, outside of the web browser.

Node.js allows developers to use JavaScript on the server-side, which provides several benefits, such as faster development, reusability of code, and the ability to use a single language across the whole stack, from the front-end to the back-end. Node.js is event-driven, meaning it operates on a single thread and uses non-blocking I/O to handle multiple requests concurrently, resulting in highly scalable applications.

Node.js is widely used for building real-time web applications, APIs, microservices, and web servers. It is also commonly used for building desktop applications, mobile applications, and IoT applications. The Node.js package ecosystem, npm, is one of the largest open-source libraries of reusable code in the world, providing developers with a wide range of tools and modules to build their applications.

Get started with NodeJS

Here are the general steps you can follow to get started with Node.js:

Install Node.js

To get started, go to the official Node.js website (https://nodejs.org/en/download/) and download and install the appropriate version for your operating system.

Set up your IDE

There are many IDEs you can use to develop Node.js applications. One of the most popular options is Visual Studio Code (https://code.visualstudio.com/). Install Visual Studio Code and any relevant extensions for Node.js development.

Create a new Node.js project

Open Visual Studio Code and create a new folder for your Node.js project. Open a new terminal window in Visual Studio Code and navigate to the new project folder. Run the following command to initialize a new Node.js project:

npm init -y

This will create a new package.json file in your project folder, which will be used to manage your project dependencies.

Write your first Node.js script

Create a new file in your project folder called index.js. This will be the main entry point for your application. Here's an example script that prints "Hello, world!" to the console:

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

Run your script

Open a terminal window in Visual Studio Code and navigate to your project folder. Run the following command to execute your script:

node index.js

You should see "Hello, world!" printed to the console.

Read and write files

Node.js provides built-in modules for reading and writing files. Here's an example script that reads a text file called "example.txt" and prints its contents to the console:

const fs = require("fs");

fs.readFile("example.txt", "utf-8", (err, data) => {
  if (err) {
    console.error(err);
  } else {
    console.log(data);
  }
});

This script uses the "fs" module to read the contents of the file "example.txt". The "readFile" method takes three arguments: the name of the file to read, the encoding (in this case, "utf-8" to read the file as a text file), and a callback function that is called when the file has been read.

Use third-party modules

Node.js has a vast ecosystem of third-party modules that you can use to add functionality to your application. You can use the npm package manager to install and manage these modules. Here's an example script that uses the popular "lodash" module to calculate the sum of an array of numbers:

const _ = require("lodash");

const numbers = [1, 2, 3, 4, 5];
const sum = _.sum(numbers);
console.log(sum);

This script uses the "lodash" module, which provides a wide range of utility functions for JavaScript. The "sum" method is used to calculate the sum of the numbers in the array.

These are just a few examples of the many things you can do with Node.js. With a good understanding of JavaScript and the Node.js API, you can build a wide range of server-side applications, including web servers, APIs, and command-line tools.

How does NodeJS differ from writing client side JavaScript?

Node.js and client-side JavaScript have several key differences:

Environment

Node.js is a server-side environment, while client-side JavaScript runs in the web browser. This means that Node.js can access resources and perform tasks that are not available to client-side JavaScript, such as reading and writing files, making network requests, and interacting with databases.

Here's an example of reading a file in Node.js:

const fs = require("fs");

fs.readFile("example.txt", "utf-8", (err, data) => {
  if (err) {
    console.error(err);
  } else {
    console.log(data);
  }
});

In client-side JavaScript, you cannot directly read files from the file system for security reasons.

APIs

Node.js provides a different set of APIs than client-side JavaScript, focused on server-side functionality. For example, Node.js has APIs for handling HTTP requests, working with file systems, and interacting with databases:

const http = require("http");

const server = http.createServer((req, res) => {
  res.writeHead(200, { "Content-Type": "text/plain" });
  res.end("Hello, world!\n");
});

server.listen(3000, () => {
  console.log("Server running on http://localhost:3000");
});

This script creates a simple HTTP server in Node.js. In client-side JavaScript, you cannot directly create an HTTP server.

Concurrency

Node.js uses a non-blocking I/O model and an event-driven architecture, which allows it to handle multiple requests concurrently without blocking the execution of other requests. Here's an example of handling HTTP requests concurrently in Node.js:

const http = require("http");

const server = http.createServer((req, res) => {
  setTimeout(() => {
    res.writeHead(200, { "Content-Type": "text/plain" });
    res.end("Hello, world!\n");
  }, 5000);
});

server.listen(3000, () => {
  console.log("Server running on http://localhost:3000");
});

This script creates a simple HTTP server that responds to requests after a 5-second delay. Because of the non-blocking I/O model, the server can handle multiple requests concurrently, even with the delay. In client-side JavaScript, you typically do not need to handle concurrency in this way.

Execution context

Node.js runs in a separate process from the web browser, with its own global object, execution context, and modules. This means that the code written for Node.js may not work in the browser, and vice versa.

Modules

Node.js uses the CommonJS module format, which allows developers to write modular code with clear dependencies and exports. Here's an example of a Node.js module:

// math.js

function add(a, b) {
  return a + b;
}

function subtract(a, b) {
  return a - b;
}

module.exports = {
  add,
  subtract,
};

This script exports two functions, "add" and "subtract", using the CommonJS module format. In client-side JavaScript, you typically use the ES6 module format, which has a different syntax and requires a build step to work in the browser.

These examples illustrate some of the key differences between Node.js and client-side JavaScript. While there are some similarities between the two, they have different APIs, execution contexts, and use cases.

The current state of NodeJS

Node.js is currently in a mature and stable state, with a large and active community of developers and a thriving ecosystem of libraries and tools. The most recent stable release of Node.js as of my knowledge cutoff (September 2021) was version 16.8.0, released in August 2021, with several new features, improvements, and bug fixes.

Node.js continues to be widely used for building server-side applications, especially in the web development space. Its event-driven architecture and non-blocking I/O model make it well-suited for building highly scalable and performant applications, and its integration with the V8 engine allows it to take advantage of the latest JavaScript features.

In addition to web development, Node.js is also being used in other areas such as IoT, desktop applications, and machine learning. For example, the popular framework Electron, which is built on top of Node.js, is used for building cross-platform desktop applications.

Overall, the current state of Node.js is very strong, with a large and active community and continued growth and adoption in a wide range of industries and use cases.

Updated April 14, 2023