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!