Introduction

Node.js is an open-source, cross-platform, back-end JavaScript runtime environment that executes JavaScript code outside a web browser. It's built on Chrome's V8 JavaScript engine and is widely used for developing scalable server-side applications, APIs, and microservices.

Node.js Program Basics

Basic Syntax and structure of Node.js programs

Node.js programs are written in JavaScript and follow a similar syntax to client-side JavaScript. They typically consist of modules, which are files containing JavaScript code. The entry point is usually a file named index.js or server.js.

// Simple Node.js program
console.log("Hello, world!");

Modules and require()

Node.js uses a module system to organize code. The require() function is used to import modules. Modules can be built-in (like fs for file system access), from the Node.js standard library, or from external packages installed using npm (Node Package Manager).

const fs = require('fs');
// Accessing file system module

Event loop and asynchronous programming

Node.js is built on an event loop, which allows it to handle multiple requests concurrently without blocking. This makes it highly efficient for I/O-bound operations. Asynchronous programming is essential to take full advantage of the event loop.

// Asynchronous operation example
fs.readFile('myFile.txt', (err, data) => {
    if (err) throw err;
    console.log(data);
});
console.log("This will execute before the file is read");

Callback functions

Callback functions are used to handle the results of asynchronous operations. They are passed as arguments to asynchronous functions and are executed when the operation completes.

// Callback function example
function myAsyncOperation(callback) {
    setTimeout(() => {
    callback(null, 'Operation completed');
  }, 1000);
}
// Using the callback function
myAsyncOperation((err, result) => {
    if (err) console.error(err);
    console.log(result);});

Error Handling

Proper error handling is crucial. Node.js uses try...catch blocks and error-first callbacks for handling exceptions.

try {  // Code that might throw an error
  let result = 10 / 0;
} catch (error) {
  console.error("An error occurred:", error);  // Handle the error appropriately
}

Node.js Coding Examples

Simple 'Hello, world!' program

This demonstrates the simplest Node.js program.

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

Working with file system modules

This example shows how to read a file using the fs module.

const fs = require('fs');
fs.readFile('myFile.txt', 'utf8', (err, data) => {
    if (err) throw err;
    console.log(data);
});

Creating a simple web server

This illustrates a basic HTTP server using Node.js's http module.

const http = require('http');
const server = http.createServer((req, res) => {
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Hello from Node.js server!');});
    server.listen(3000, () => {
    console.log('Server listening on port 3000');
});

Example of Asynchronous operation

This demonstrates an asynchronous operation using setTimeout.

setTimeout(() => {
    console.log('This is asynchronous');
}, 2000);
console.log('This executes immediately');

Example of handling errors

This shows error handling within an asynchronous function.

const fs = require('fs');
fs.readFile('nonExistentFile.txt', 'utf8', (err, data) => {
    if (err) {
        console.error('Error reading file:', err);
    } else {
        console.log(data);
    }
});

Summary

• Node.js is a powerful JavaScript runtime environment for server-side applications.
• It uses an event loop for efficient asynchronous programming.
• Modules and the require() function facilitate code organization.
• Error handling is essential for robust applications.
• Asynchronous operations are fundamental to Node.js development.