Learn Node.js by exemples: from beginner to advanced

Learn how var and let differ in scope from global to block, and see how this affects functions, loops, and memory to reduce bugs and reuse names safely.

Understand that in JavaScript the this keyword refers to the calling context, not a class instance, often pointing to the global object and binding via function calls and prototype inheritance.

Learn how callbacks enable asynchronous JavaScript by passing a function to run after a delay, using setTimeout to simulate server responses and handle data in a callback.

Learn how to handle errors in Node.js callbacks using the error-first convention, where the callback receives an error parameter first and, if no error, the data is processed.

Learn how promises replace callbacks to manage asynchronous tasks in JavaScript. Create a promise, resolve with data, or reject on error, and use then and catch to handle outcomes.

Learn how to chain promises in Node.js by using then and catch to manage multiple asynchronous tasks, handle errors, and apply Promise.all for parallel execution.

Learn how to convert promises to readable code using the async and await pattern, wrapping asynchronous tasks in a synchronous style, with proper error handling via try, catch, and reject.

Learn how require loads dependencies, executes a module once, and caches its exports, so subsequent requires reuse the same object from the same location, as shown with two example modules.

Install commander and set up a node.js cli project with an indexed entry point. Use npm install to add dependencies and parse arguments, including version output, with commander.

Turn our Node.js application into a real command line tool by adding a bin folder, a shebang, and executable permissions, then install it globally to use via the terminal.

Create your first module in node.js by building a launch function and exporting it through a library module. Prepare for file system work and future database integration.

Learn to use the node fs module to save a json database with books, users, and rents to a file. Reading from the file appears in the next video.

Learn how to read a database file with the fs module, handle utf-8 encoding, parse content into memory, use callbacks to launch the program, and prepare for promise-based refactoring.

Learn to implement the factory pattern in the node.js model layer, creating functions like createBook and createRent within a src/model folder for a layered architecture.

Initialize the database module to read and write to a file, expose only the necessary functions, and cache a connected object so subsequent calls reuse it.

Implement add functions for books and users, validate duplication in the database, and return a structured response; manage rentals with rent objects and persist changes.

Build and organize node.js controllers for users, books, and rents, validating input and delegating to a database layer through promise-based operations.

Explore the behavior of node timing functions setImmediate, setTimeout, and process.nextTick, and learn how their scheduling influences the execution order of callbacks in the event loop.

Learn how events in JavaScript are messages emitted by objects, such as line events when a line prints, and how multiple handlers run in the order added.

Spawn a child process with fork to run long tasks without blocking the event loop, using event emitters and interprocess messages to keep Express routes responsive.

Explore how Node.js streams transform data on the fly, including turning text into caps and duplex streams that handle input and output, with memory-efficient file copy.

Explore how readable streams in Node.js manage data with an internal buffer and high watermark, contrasting pull and flow modes, and handling data with read calls or data events.

Explore how the pipe operator connects a readable stream to a writable stream, piping data automatically from reader to writer and simplifying the flow into a custom pipeline.

Learn how duplex streams enable simultaneous writing and reading through writer and reader buffers, and transform streams that convert data, using the transform function and pipe operator.

Explore socket communication with the net module by creating a simple server and client that exchange data over a duplex socket, decode to utf-8, and handle post and get requests.

Create a basic http server from scratch using the http module, handling requests and responses as streams, and route them with a switch while preparing for express-based apis.

Discover how Docker packages apps and dependencies into portable containers that run on any OS without extra installs. Learn how the Docker engine and containers differ from virtual machines.

Build a node-based docker image from a base node image, install dependencies with npm install, expose port 9000, and run it with port mapping to access the app locally.

Learn to create a CouchDB database, design a design document with a tropical view, and use map and reduce functions to query and index documents efficiently.

Define and deploy a list function in a design document to query a view using a weight parameter. Include docs, disable reduce, and format the resulting items for output.

Create a validate document function to enforce rules before adding new documents to the database, checking document type and allowed values like fruit and tropical.

Learn how to download and install Postman on Windows, macOS, or Linux, then explore the Postman interface and begin using it to build your API.

Build an api with Express by creating a project, defining a get route that returns hello, and a post route that decodes the request body to utf-8 and parses json.

Create an Express server with a router, using regular expression routes, parameterized routes, and query parameters. Access req.params and req.query, and run on port 8000 with /api.

Learn how to set up Mocha and Chai, write test specs with describe and it, and use assert, expect, and should to verify simple functions like hello and add.

Install gulp CLI globally and set up gulp in your project, then create a gulpfile.js and configure a sample task in package.json to see how gulp.js manages tasks.

Create and organize node.js database models, including book and user models, using factory functions and a uuid for IDs, then wire an index module and a standardized database response.

Implement the create operation of CRUD by adding a function that inserts a book into the database, uses async/await with try/catch, and checks library design document view to avoid duplicates.

Implement read operations in the Node.js CRUD module by author: query the books view, include documents, and use list by author to retrieve books by a given author.

Explore logging with Winston in Node.js by creating reusable loggers, applying formats and transports, and logging info and errors to files for debugging and monitoring.

Implement a book controller in Node.js using class syntax, connect to the data layer, handle create and get operations with the database module, and return secure controller responses.

Implement a user controller modeled after the book controller with create, delete, and get. Validate IDs with the validator module, remove password and revision, then return user and export controller.

Build an API to fetch all books and add search functionality using query parameters to filter by title or author, with proper controller integration and response handling.

Learn to build a book API by implementing a post /books route, using body-parser middleware, validating title and year, and wiring controllers, models, and database for clean separation of concerns.

Learn how cookies maintain application state in Node.js and Express by setting and reading cookies, using a cookie parser, and signing cookies with a secret to securely personalize user sessions.

Create the first menu component in Angular with TypeScript, featuring a Bootstrap navigation bar, a title/author search, and keyup event handling to update the query.

Define routes with path and component, declare new components, and wire router links and a router outlet to enable navigation and routing tracing in an Angular app.

Add a new user through a form using a user service, sending email and password via an observable and subscribe, then verify database entry.

Initialize a component with a book service to fetch all books from the database and display them in a table with title, author, and actions, including returning rented books.

Create an advanced book component with a form for title, author, and year, wiring a create book function to a book service and routing to add and manage books.

Implement a search service that holds results as a subject of books, queries by title or author via HTTP GET, and displays clickable results in the search results component.

Integrate the Angular UI with the Node.js app by building the library, serving static files from distribution folder, and loading the compiled JavaScript into production, with route guards for authorization.

Explore angular routing guards using CanActivate to protect routes with a user service, enforcing authorization while keeping home and login accessible.

Compare backend routes and Angular routes, and how browser requests interact with router links. Implement solutions: redirect unknown routes to the homepage, or use server-side regular expressions.