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

# What is a module?
Let’s explore what a module is in the context of Node.js.

Each separate file is treated as a **module** in Node.js. The most common use of modules is to use code or functions across different modules. This allows us to keep our code organized, as each module can serve a specific purpose. This may seem like a circular argument; let's see what we mean by this in the code widget below. Be sure to go through all three files.

exports.area = (lenghtOfSide) => lenghtOfSide * lenghtOfSide
exports.perimeter = (lenghtOfSide) => 4 * lenghtOfSide

module.exports  = class Shape {
  constructor(name, sides) {
    this.name = name;
    this.sides = sides
  }

  info() {
    console.log("The name of the shape is", this.name)
    console.log("It has", this.sides, "sides")
  }
};


const square = require('./square.js')
const shape = require('./shape.js')

console.log("Area of the square is" , square.area(5))
console.log("Perimter of the square is" , square.perimeter(5))

const myShape = new shape("Hexagon", 6)
myShape.info()

# `require`
`require` is used to import modules, JSON files, and local files. It is passed a relative path as a string. In our case, we have imported both of our modules on **line 1** and **line 2** of the **index.js** file. 

# The module wrapper
Before a module is exported, Node.js wraps the module in a wrapper function. This is how that looks:
```
(function(exports, require, module, __filename, __dirname) {
// Module code actually lives in here
});
```
This wrapper allows us to:
- keep variables, defined in the module, scoped to the module rather than the global object
- use variables, such as `__dirname` and `__filename`, for accessing the directory path and the filename of the module

While we may not be able to use this wrapper directly, it is important to know what Node.js is doing behind the screen, so that we can better understand the process.

# `exports` or `module.exports`
All the variables or functions that we want to be accessible in other modules have to be exported. There are two ways of exporting them: using `exports` or `module.exports`. Let's see how they differ from each other.

- The `exports` variable is available within a module's file-level scope. It is assigned the value of `module.exports` before the module is evaluated. We can think of `exports` as a shorthand way of writing code. Instead of writing `module.exports.Something`, we can write `exports.Something`. We are using this in our **square.js** file.
- The `module.exports` object is created by the `Module` system. We can usually use the `exports` shorthand without ever needing to use `module.exports`. However, if we override `exports` by assigning it to something, else such as `exports = function(){}`, then `exports` would no longer point to `module.exports`. This is because the reassignment breaks the reference between `module.exports` and `exports`. Since `module.exports `is what really gets exported, `exports` will no longer work as expected. In our **shape.js** file, since we are only exporting one class, we can get away with assigning the class directly to  `module.exports`.


Introduction

Fundamentals

Advanced Topics

Packages

Project

Appendix

Modules

What is a module?