Gain insights into Node.js fundamentals, event loops, and multithreading. Delve into file systems, global objects, and advanced modules. Discover how to create a food delivery web application.

final.tar.gz

TCP_job

HTTP_test

Project_3

Project_1

Project_2

Project_0

timer_demo

UDP_job

Project_demo

sayMyName

logger

nodemon app

npm terminal

UDP_chat_nodemon

TCP_chat_nodemon

run-app.js

terminal-app.js

Node.js is an open-source, cross-platform, JavaScript runtime environment that executes JavaScript code outside of a web browser. This course is your guide for learning the fundamentals of Node.js.

In this course, you'll start by understanding the inner workings of Node.js. More specifically, you’ll explore its features, how event loops work, and how multithreading works. You’ll then move on to the fundamentals of Node.js like file systems, global objects, and the Buffer class.

In the latter half of the course, you’ll explore more advanced concepts like modules,  events,  and packages. At the end of this course, you will get hands-on with Node.js and create your own food delivery web application.

By the end of this course, you will have a new, in-demand skill to put on your resume and a cool project to add to your portfolio.

Learn Node.js: The Complete Course for Beginners

# The `process` object
The `process` object is a global that allows us to control the current process. It also has methods that can provide useful information about the process. Being an instance of the `EventEmitter` class, it has a few important events that we should know about. Let's take a look at them.

console.log('This is the first message');

process.on('beforeExit', (code) => {
  console.log('Process beforeExit event with code:', code);
});

process.on('exit', (code) => {
  setTimeout(() => { console.log('This will not work.') }, 0);
  console.log('Process exit event with code:', code);
});

console.log('This is the second message');

// process.exit()

# `exit` and `beforeExit`
These two events can be very useful at times. Consider the scenario:
- You wish to save your program progress to the cloud once it is done processing. The `beforeExit` event is perfect for this job. It is #key# fired: emitted #key# when the event loop is empty, which means that Node.js has done all its work and is about to exit. You can register the `beforeExit` event to make a network call to your cloud drive and upload your data.
- Once your data has been uploaded, you want the program to notify you with an output on the console. The `exit` event is fired when `process.exit()` is called, or the event loop has no additional work to perform. The `exit` event executes synchronously, and asynchronous calls may not return properly. This is why the `console.log()` on **line 8** does not work.

An important thing to note is that if we explicitly call `process.exit()`, the `beforeExit` event is not fired. Uncomment the code on **line 14** to see what happens.

# `uncaughtException`
Another important event to know about is the `uncaughtException`. As the name suggests, this event is fired when an exception occurs that has not been handled or dealt with in the program. By default, Node.js exits and prints the stack trace in case an `uncaughtException` arises. Using the `process` object, we can cater to these exceptions and deal with them as we wish. Let's see how it works.

Understand how the process object works in Node.js.

Introduction

Fundamentals

Advanced Topics

Packages

Project

Appendix

Process

The `process` object

`exit` and `beforeExit`

Process

The process object

exit and beforeExit

The `process` object

`exit` and `beforeExit`