Node.js Basics: Your First Steps into Server-Side JavaScript

5. Creating a Simple HTTP Server

This section demonstrates one of Node.js's primary use cases: creating a basic web server using the built-in `http` module.

Objectively, the `http` core module provides functionality to create HTTP servers that can listen for incoming requests and send back responses.

Delving deeper into the process: 1. Require the `http` module: `const http = require('http');`. 2. Use `http.createServer()`: This method takes a callback function (request listener) that executes for each incoming request. This function receives two arguments: `request` (an object containing information about the incoming request) and `response` (an object used to send data back to the client). 3. Inside the callback: Set response headers (e.g., `response.writeHead(200, {'Content-Type': 'text/plain'});`) and send the response body (e.g., `response.end('Hello World\n');`). 4. Call `.listen()` on the created server object: Specify the port number and optional hostname to start listening for connections (e.g., `server.listen(3000, '127.0.0.1', () => { ... });`).

Further considerations mention that this is a very basic server; real-world applications typically use frameworks like Express.js built on top of the `http` module to simplify routing, middleware handling, and other common web server tasks.

One of the most common tasks for Node.js is building web servers or APIs. The built-in `http` module allows you to create a basic server relatively easily.

Here's a minimal example:

// 1. Import the http core module
const http = require('http');

// Define the hostname and port
const hostname = '127.0.0.1'; // Standard loopback address (localhost)
const port = 3000;

// 2. Create the server
// The function passed to createServer is the request listener.
// It runs every time a request hits the server.
const server = http.createServer((req, res) => {
  // req: IncomingMessage object (request details like URL, method, headers)
  // res: ServerResponse object (used to send response back)

  // 3. Set the response status code and headers
  res.statusCode = 200; // OK
  res.setHeader('Content-Type', 'text/plain');

  // 4. Write the response body and end the response
  res.end('Hello World from Node.js!\n');
});

// 5. Start the server and make it listen on the specified port and hostname
server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});

To run this:

1. Save the code in a file (e.g., `server.js`).
2. Open your terminal in the same directory.
3. Run the command: `node server.js`
4. Open your web browser and navigate to `http://127.0.0.1:3000/` (or `http://localhost:3000/`).

You should see "Hello World from Node.js!" displayed. This demonstrates Node.js handling an HTTP request and sending a response.

While functional, building complex applications directly with the `http` module can be cumbersome. Frameworks like Express.js provide higher-level abstractions to simplify routing, middleware, request/response handling, and more.

6. Working with the File System (`fs` Module)

This section introduces Node.js's capabilities for interacting with the computer's file system using the built-in `fs` module.

Objectively, the `fs` module provides functions for performing various file system operations like reading files, writing files, checking file existence, creating directories, etc.

Delving deeper: * Asynchronous Operations: Most `fs` methods are asynchronous and non-blocking (e.g., `fs.readFile()`, `fs.writeFile()`). They accept a callback function that executes when the operation completes (either with data or an error). This is the preferred approach in Node.js to avoid blocking the event loop. * Synchronous Operations: For convenience in simple scripts or startup processes, synchronous versions are often available (e.g., `fs.readFileSync()`, `fs.writeFileSync()`). These block the event loop until the operation finishes and should generally be avoided in server applications handling concurrent requests. * Error Handling: Asynchronous methods typically pass an `error` object as the first argument to their callback function. Always check for errors.

Further considerations involve using the `path` module in conjunction with `fs` for constructing file paths reliably across different operating systems.

Node.js provides powerful tools for interacting with the file system through its core `fs` module. This allows your server-side JavaScript to read configuration files, write log files, serve static assets, and more.

Key characteristics of the `fs` module:

• Asynchronous by Default: Most file system operations can take time. To avoid blocking the single Node.js thread, the primary methods are asynchronous. They take a callback function as the last argument, which is executed once the operation completes. The first argument to the callback is typically an error object (or `null` if successful).
• Synchronous Alternatives: For many asynchronous methods, there's a synchronous counterpart (usually ending with `Sync`, e.g., `readFileSync`). These block execution until the operation completes. While sometimes useful for simple scripts or initial setup, avoid using synchronous methods in server applications handling multiple requests, as they will block the entire event loop.
• Error Handling: Always check for errors passed to the callback function in asynchronous operations.

const fs = require('fs');
const path = require('path'); // Core module for path manipulation

// --- Asynchronous File Reading ---
const filePathRead = path.join(__dirname, 'example.txt'); // Construct path safely

// Assume example.txt contains "Hello from file!"
fs.readFile(filePathRead, 'utf8', (err, data) => {
  if (err) {
    console.error('Error reading file:', err);
    return;
  }
  console.log('File content (async):', data);
  // Output: File content (async): Hello from file!
});

console.log('Reading file asynchronously...'); // This logs first

// --- Asynchronous File Writing ---
const filePathWrite = path.join(__dirname, 'output.txt');
const contentToWrite = 'Writing this content!';

fs.writeFile(filePathWrite, contentToWrite, 'utf8', (err) => {
  if (err) {
    console.error('Error writing file:', err);
    return;
  }
  console.log('File written successfully (async).');
});

console.log('Writing file asynchronously...'); // This logs while writing happens

// --- Synchronous File Reading (Use with caution!) ---
try {
  const dataSync = fs.readFileSync(filePathRead, 'utf8');
  console.log('File content (sync):', dataSync);
    // Output: File content (sync): Hello from file!
} catch (err) {
  console.error('Error reading file sync:', err);
}

console.log('After sync read attempt.'); // This logs only after sync read finishes