Frontend Masters - Introduction to Node.js, v3 2023

Take your JavaScript skills to the server with Node.js! Figure out how to assemble command-line interfaces, read and compose from files and databases, and make scalable servers. Utilize third-party modules, asynchronous coding, and CRUD operations. Test your code with Jest. Gain every one of the skills you really want to foster professional Node.js applications!

This course and others like it are accessible as a feature of our Frontend Masters video membership.

 

Table of Contents

Introduction

00:00:00 - 00:04:20

Introduction

Scott Moss introduces the course by providing some personal and professional foundation. An outline of the material that will be covered and course assets are additionally given in this fragment.

Node Fundamentals

00:04:21 - 00:08:06

History of Node.js

Scott sums up Node.js as a JavaScript runtime utilized beyond internet browsers. Made by Ryan Dahl in 2009, it defeated internet browser limits and server-side scripting inefficiencies.

00:08:07 - 00:14:02

Non-Blocking I/O

Scott explains the non-blocking I/O model utilized by Node.js to deal with simultaneous associations in superior execution network applications. Key elements, for example, occasion circles, callbacks, non-blocking APIs, and its single-strung nature, add to its proficiency.

00:14:03 - 00:23:39

Hi World

Scott strolls through the arrangement of Node.js and a variant chief called nvm. The section includes creating a basic Node.js program that prints to the terminal.

00:23:40 - 00:31:28

Program versus Node.js

Scott explains the distinctions between how JavaScript is taken care of in the program and Node.js, offering an outline of the Node.js REPL. The portion covers contrasts in the worldwide article, modules, DOM, and control center.

Creating a CLI

00:31:29 - 00:40:57

Process and Climate

Scott explains the worldwide cycle object, highlighting normally utilized properties and strategies joined to it. The portion additionally covers using process.env to get to climate factors.

00:40:58 - 00:53:40

Custom CLI Arrangement

Scott explains command-line interfaces, shows creating a Node.js project using npm, and covers the contents of the produced package.json record. The fragment likewise includes linking to the document and defining the content's current circumstance with a hashbang.

00:53:41 - 00:57:43

Processing CLI Contentions

Scott strolls through the method involved with building out the rationale for a custom note-taking CLI, enabling it to acknowledge input from the terminal as another note.

Modules

00:57:44 - 01:04:54

Modules Outline

Scott talks about Node.js modules, which are independent bits of code intended to perform explicit errands. Node.js has three sorts of modules: internal, client made, and third-party modules.

01:04:55 - 01:11:59

Importing and Exporting Modules

Scott exhibits how to import both internal and outside modules in Node.js. The distinctions between using 'require' and 'import' for including outer modules are additionally explained in this portion.

01:12:00 - 01:18:43

Thinking in Modules

Scott examines things to remember while developing modules for Node.js applications. This fragment covers topics, for example, module contents, product and import designs, and index.js designs.

01:18:44 - 01:28:50

Internal and outsider Modules

Scott talks about worked in modules that are accessible within the Node.js climate. Installing, updating, and removing third-party modules using npm is additionally canvassed in this section.

01:28:51 - 01:36:14

Using the yargs Module

Scott exhibits the installation and utilization of the third-party yargs module to carry out an assistance command for the custom note-taking CLI.

01:36:15 - 01:43:23

Notes Application Commands

Scott sets up the establishment for CLI commands like new, all, find, eliminate, web, and clean.

Document I/O

01:43:24 - 02:02:09

Async Code

Scott explains the advantages of asynchronous code, which permits different operations to happen while waiting for an errand to finish. An exhibition of how to keep away from settled callbacks using guarantees is likewise shrouded in this portion.

02:02:10 - 02:14:40

FS Module

Scott exhibits how to utilize the inherent FS module, which gives a Programming interface to interacting with the record framework. Understudy questions regarding debugging mistakes involving nesting callbacks are additionally shrouded in this section.

02:14:41 - 02:24:18

Using a Record as a DB

Scott exhibits how to utilize the FS module and a JSON record as a data set to store made notes. The establishment for utility capabilities to peruse the db.json document, save a JavaScript item, and add another note are likewise shrouded in this section.

02:24:19 - 02:37:02

CRUD Techniques: Make

Scott explains CRUD operations, which involve make, read, update, and erase activities on the notes in the data set. Abstracting the recently made insert utility capability for creating new notes and an understudy's inquiry concerning destructuring are likewise canvassed in this fragment.

02:37:03 - 02:48:47

CRUD Techniques: Read and Erase

Scott fosters a capability to get all notes from the data set and channels them in view of the gave channel string. A show of the most common way of removing notes with explicit IDs and clearing all notes from the data set in this fragment is likewise given in this section.

02:48:48 - 03:03:57

Using the CRUD Strategies

Scott refreshes the commands to use the recently made CRUD strategies, allowing for better usefulness and interaction with the notes in the data set.

Testing

03:03:58 - 03:10:37

Kinds of Tests

Scott examines the various kinds of testing in a Node.js application, which include unit testing, integration testing, start to finish testing, and Programming interface testing.

03:10:38 - 03:21:28

Unit Testing with Jest

Scott shows writing and running tests using the Jest testing system. Jest automatically examines for test files in the tests directory and executes them.

03:21:29 - 03:34:18

Testing with Derides

Scott talks about testing with mock capabilities and information to perform tests without modifying the genuine information in the data set. Mock capabilities, additionally alluded to as "spies," notice the way of behaving of indirectly called capabilities, allowing for careful testing of capability conduct and result.

03:34:19 - 03:37:18

Extra Test Models

Scott shows extra instances of tests for various functionalities and use cases.

Servers

03:37:19 - 03:50:28

Creating a Fundamental Server

Scott examines the idea of a Node.js server, which tunes in for incoming organization demands and answers by executing code or providing information. A stroll through the method involved with creating an essential Node.js server is likewise covered this portion.

03:50:29 - 03:57:50

Interpolating Information and Formatting Notes

Scott exhibits how to interpolate the notes information, inserting or embedding values into a string or layout to progressively make another string. The most effective method to define the organization of the returned notes is likewise shrouded in this section.

03:57:51 - 04:06:07

Sending Notes to the Client

Scott outlines the usage of the createServer capability to take the variety of notes and produce a Node.js HTTP server that serves the organized HTML to the client.

Wrapping Up

04:06:08 - 04:12:52

Wrapping Up

Scott wraps up the course by summarizing the CLI application worked all through the illustrations. Assets and ideas for additional learning valuable open doors are likewise given in this fragment.

Useful Links:

1. Instructor: Scott Moss
2. Workshop Schedule and Details