Day 3/10: Understanding the Essentials

Introduction

Welcome to Day 3 of our Node.js in 10 days series! Today, we'll dive into some fundamental topics that are essential for any Node.js developer.
In Day 3, we'll focus on working with modules, interacting with the file system, and using NPM (Node Package Manager) to manage project dependencies.
These topics are crucial for building efficient and modular Node.js applications.

Module 1: Introduction to Node.js Modules

1.1 Understanding Modules

In Node.js, modules are a way to organize and encapsulate code.
Think of them as building blocks for your application, making your code more maintainable and reusable.
We'll explore why modularization is vital in Node.js development.

1.2 Core Modules vs. External Modules

Node.js provides core modules for common tasks like working with the file system and networking.
External modules, hosted on the npm registry, extend Node.js's capabilities.
We'll discuss how to use both core and external modules effectively.

Example 1: Creating and Using Modules

We'll illustrate module creation and usage with a simple "greeting" module.
This hands-on example will show you how to export and import modules, a fundamental skill for Node.js developers.

// Creating a module.
// myModule.js
module.exports = {
  greet: function (name) {
    return `Hello, ${name}!`;
  },
};

// Using the module.
const myModule = require('./myModule');
console.log(myModule.greet('Alice')); // Output: Hello, Alice!

Module 2: Working with the File System (fs)

2.1 Reading and Writing Files

Node.js's 'fs' module provides methods to work with the file system.
We'll explore how to read data from files and write data to files, emphasizing proper error handling.

2.2 Working with Directories

Managing directories is essential when working with files.
We'll cover creating, reading, deleting directories, and listing files within directories.

Example 2: Reading and Writing Files

You'll see how to read and write files asynchronously and handle errors gracefully.

// Reading a file.
const fs = require('fs');
fs.readFile('example.txt', 'utf-8', (err, data) => {
  if (err) {
    console.error(err);
    return;
  }
  console.log(data);
});

// Writing to a file.
fs.writeFile('output.txt', 'Hello, Node.js!', (err) => {
  if (err) {
    console.error(err);
    return;
  }
  console.log('File written successfully.');
});

Module 3: Core Modules for Web Servers

3.1 Creating a Basic HTTP Server

We'll explore Node.js's 'http' module to create a basic HTTP server.
You'll learn how to handle incoming HTTP requests and send responses.

3.2 Building an Express.js Web Application

Express.js is a popular web framework for Node.js.
We'll introduce you to Express.js, demonstrate setting up routes, middleware, and serving static files.

Example 3: Creating a Basic HTTP Server

This example will show you how to create a basic HTTP server, a foundation for building web applications.

// Creating an HTTP server.
const http = require('http');

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello, Node.js Server!');
});

const port = 3000;
server.listen(port, () => {
  console.log(`Server listening on port ${port}`);
});

Module 4: NPM (Node Package Manager)

4.1 Managing Dependencies

NPM simplifies managing project dependencies.
We'll cover installing, updating, and removing packages, and explain the 'package.json' file.

4.2 Publishing Your Own Modules

If you create a useful Node.js module, we'll guide you on how to publish it on npm.
Best practices for versioning and documentation will be discussed.

Example 4: Installing and Using npm Packages

This example demonstrates how to use npm to install external packages and leverage their functionality in your projects.

# Install a package using npm.
npm install lodash

# Using the installed package in your Node.js code.
const _ = require('lodash');
const result = _.sum([1, 2, 3, 4, 5]);
console.log(result); // Output: 15

Conclusion

Day 3 has equipped you with valuable skills for building Node.js applications.
You now understand modules, the file system, and how to manage dependencies with NPM.
These are foundational skills that will serve you well in your Node.js development journey.

Homework

Practice creating and using your own Node.js modules.
Explore the 'fs' module by performing file read and write operations.
Try creating a simple web server using the 'http' module or dive deeper into Express.js.

Next Class Preview

In Day 4, we'll explore routing, middleware, and creating RESTful APIs using Express.js.
We'll dive deeper into building robust web applications with Node.js.

Thank you, and see you in Day 4!