Introduction to Node.js

• Node.js is an open-source JavaScript runtime environment for server-side JavaScript execution
• Node.js is used for creating web applications, back-end APIs, and websites
• Node.js runs on Chrome's V8 JavaScript engine for server-side programming
• Ryan Dahl developed Node.js in 2009
• Node.js is free to use and has a large, active developer community
• Node.js is used by organizations like Netflix, NASA, LinkedIn, and Paypal

Features

• Cross-platform compatibility with Windows, Linux, macOS, and Unix
• Asynchronous, event-driven model is memory efficient
• Non-blocking, handles concurrent connections without blocking threads
• Built on Chrome's V8 JavaScript engine

Use Cases

• Creating web servers
• Building data-intensive applications
• Collecting form data
• Adding, deleting, and modifying database data

First Application

• A basic Node.js application prints "Hello, World!" to the console
• To run it, save the following code to a file called "app.js": console.log('Hello, World!');
• Execute it by navigating to the directory in your terminal and running node app.js

REPL Terminal

• REPL means Read-Eval-Print Loop which is an interactive environment provided by Node.js to execute JavaScript code.
• Start the REPL by typing node in the terminal
• Use .help to see available commands:
  • .break: Exits from a multiline expression
  • .clear: Clears all variables and functions
  • .save: Saves the current REPL session to a file
  • .load: Loads a file into the current REPL session
  • .exit: Exits the REPL

Stopping REPL

• Exit the REPL using .exit or pressing Ctrl + C twice

NPM (Node Package Manager)

• NPM is the default package manager for Node.js
• NPM is used to install, update, and manage dependencies in Node.js projects
• Install modules using: npm install <module name>
• Example: npm install express (installs the Express module)
• package.json file is the heart of any Node.js project
• package.json is the manifest file containing metadata, manages dependencies, scripts, version, and settings

Attributes of package.json

• name: Project name
• version: Project version
• description: Brief project description
• main: Application entry point
• scripts: Run with npm run
• dependencies: Required dependencies
• devDependencies: Development dependencies
• author: Author of the project
• license: Project license

Uninstalling Module

• Uninstall a module with: npm uninstall
• Example: npm uninstall express which removes the express module and updates related files

Updating Module

• Update a module to the latest version: npm update <module-name>
• To update all modules: npm update

Searching Module

• To search for a module, use the command npm search <search-term> with the search term

Creating a Module

• A module in Node.js is a JavaScript file that exports functionalities
• To use a module in another file, use require('./myModule');

Callback Concept

• A callback is a function passed as an argument to another function
• Callbacks are invoked inside the outer function to complete a routine or action

Blocking and Non-Blocking Code

• Blocking code executes synchronously, each operation waits for the previous one to complete
• Non-blocking code executes asynchronously, operations can start before the previous ones have completed

Blocking Code Example

• Synchronous code will only print the last console statement after file.txt is read
• The fs.readFileSync function blocks execution until the file is completely read

Non-Blocking Code Example

• Asynchronous code will print the last console statement without waiting for file.txt to be read
• The fs.readFile function doesn't block execution, the operations happen in the background

Event Loop

• The event loop enables Node.js to perform non-blocking, asynchronous operations in a single thread
• This is what allows Node.js to remain responsive, and also handle multiple operations

Event Loop Working

• Node.js uses a single-threaded event loop model
• Tasks such as I/O operations are offloaded to the system kernel, which is multi-threaded
• This enables multiple operations to occur concurrently without blocking the main thread

Phases of the Event Loop

• Timers: Executes callbacks scheduled by setTimeout() and setInterval()
• I/O Callbacks: Executes callbacks for system operations (e.g., TCP errors)
• Poll: Retrieves new I/O events and their callbacks
• Check: Executes callbacks scheduled by setImmediate()
• Close Callbacks: Executes close event callbacks (e.g., socket.on('close', ...)

Synchronous Code

• Synchronous Code executes immediately from the start

Next Tick Queue

• Callbacks that run after the current operation completes, before the event loop continues

Timer Phase

• Schedule to run in the next cycle of the event loop

Check Phase

• Scheduled to run after the poll phase

Poll Phase

• The poll phase waits for I/O events
• The File read will complete and the callback will be executed in this Phase

Key Points

• Node.js uses a single thread but handles multiple I/O operations using the system's capabilities
• Operations like network requests and file system operations are non-blocking
• Callbacks and Promises help handle asynchronous operations
• Event loop has distinct phases for handling timers, I/O callbacks, and other operations

Event-Driven Programming

• Node.js follows an event-driven programming model
• Program flow is determined by events like user actions or sensor outputs
• The program responds to new events without waiting for operations to complete

EventEmitter Class

• The EventEmitter class is a Node.js module for creating and handling custom events
• EventEmitter enables objects to emit named events that trigger listeners

Importing EventEmitter

• Importing EventEmitter with const EventEmitter = require('events');

EventEmitter Methods

• .on(event, listener): Registers a listener for the specified event
• .emit(event, [...args]): Emits the specified event, calls all listeners
• .once(event, listener): Registers a one-time listener for the specified event
• .removeListener(event, listener): Removes a specific listener from the event
• .removeAllListeners([event]): Removes all listeners for the specified event

EventEmitter Class Methods

• EventEmitter.defaultMaxListeners: Sets the maximum number of listeners for a single event, The default value is 10.
• EventEmitter.listenerCount(emitter, event): Returns the number of listeners for the specified event.

EventEmitter Events

• newListener: Emitted when a new listener is added
• removeListener: Emitted when a listener is removed

Streams

• Streams are used to handle data in chunks, instead of all at once

Types of Streams

• Readable Streams: Data can be read from these streams (e.g., fs.createReadStream())
• Writable Streams: Data can be written to these streams (e.g., fs.createWriteStream())
• Duplex Streams: Streams readable and writable (e.g., net.Socket)
• Transform Streams: Duplex streams that modify data while reading/writing (e.g., zlib.createGzip())

Reading from a Stream

• To implement a data stream to read some data from a file
• Events are emitted when data is read
  • data event is emitted when data is available
  • end event is emitted when all data has been read
  • error event is emitted if any error occurs

Writing to a Stream

• Implementation of a stream to write to a file
• This stream has parameters to determine how to write to the file
  • What data to write
  • What the encoding of the data is

Web Module

• A web server handles HTTP requests from clients and serves responses
• Web servers respond with HTML pages, images, stylesheets, and scripts

Web Application Architecture

• Client (User's web browser or application)
• Server (Backend application) processes requests, runs business logic, and communicates with databases
• Database (Stores and retrieves data)

Creating a Web Server using Node.js

• A basic HTTP server uses the http module
  • Import the HTTP module
  • Respond with a status code of 200 (OK)
  • Set the content type to plain text
  • Set the server to listen on port 3000 and localhost (127.0.0.1)
    • After this has been implemented, any client making a request to the address will see the 'Hello World' application
• The HTTP module is used to make requests
  • Define request options (hostname, port, path, method)
  • Handle data chunks to see the logs
  • Handle any errors from the client
  • Handle the completion of the response

Creating a Web Client using Node.js

• The HTTP module also creates web clients using Node.js
  • The client must define the following in the HTTP request
    • Hostname to the host ip
    • What port to connect to
    • Where to find the route
    • Make the kind of get request that is preferred
  • These clients will then be able to get a response

Node.js File System (fs) Module

• The Node.js File System (fs) module is for working with the file system including both synchronous and asynchronous methods for operations

Synchronous and Asynchronous Operations

• Synchronous Operations
• Execute line by line, pausing execution until the operation completes
• Example: fs.readFileSync()
• Asynchronous Operations
• Execute without blocking the main thread, allowing other operations to run simultaneously.
• Example: fs.readFile()

Opening a File

• Asynchronous: fs.open(path, flags, mode, callback)
• Synchronous: fs.openSync(path, flags, mode)
• Flags in example:
• 'r' - read
• 'w' - write
• 'a' - append.js

Writing to a File

• Asynchronous: fs.writeFile(file, data, options, callback)
• Synchronous: fs.writeFileSync(file, data, options)

Reading a File

• Asynchronous: fs.readFile(path, options, callback)
• Synchronous: fs.readFileSync(path, options)

Creating a Directory

• Asynchronous: fs.mkdir(path, options, callback)
• Synchronous: fs.mkdirSync(path, options)

Removing a Directory

• Asynchronous: fs.rmdir(path, callback)
• Synchronous: fs.rmdirSync(path)