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 web
Websites, much like this one, don’t use a command-line terminal to serve all those beautiful web pages. Simple servers and clients that work using the terminal exist on the transport layer, whereas HTTP resides on the application layer of the internet protocol suite.
. This is the layer users interact with using a website’s front-end. Node.js allows us to serve web pages using the `http` module. Let's see how a simple server can be made in just a few lines of code:

import React from 'react';
import { shallow, configure } from 'enzyme';
import Adapter from 'enzyme-adapter-react-16';

configure({ adapter: new Adapter() });

import HelloWorld from './app';

var TestResult = function() {
    this.succeeded = false;
    this.reason = "";
    this.input = "";
    this.expected_output = "";
    this.actual_output = "";
}

export const executeTests = function() {

  var results = [];

  result = new TestResult();
  result.input = 'HelloWorld Component';
  result.expected_output = "span containing text 'Hello World'"

  let wrapper = shallow(<HelloWorld />);

  // Call your Challenge function here.

  let type = wrapper.type();
  let testSuccessful = true;
  let failureReason;

  if (type !== 'span') {
    testSuccessful = false;
    failureReason = "You need to render exactly one span HTML element";
  } else if (wrapper.props().children != "Hello World") {
     testSuccessful = false;
     failureReason = "You have rendered wrong message in your span element";
  }

  result.actual_output = wrapper.html();

  if (testSuccessful) {
    result.succeeded = true;
    result.reason = "Succeeded"
  } else {
    result.succeeded = false;
    result.reason = failureReason;
  }

  results.push(result);

  return results;
}


React

Dart

GoJS React

Typescript React

Vue.js

# The server-side
- We import the `http` module on **line 1**.
- We declare our `hostname` and `port` on **line 3** and **line 4**.
- The `createServer` method on **line 6**  creates an `http.Server` instance. A `requestListener` function is also added as a callback here. The `requestListener` is automatically #key# added: will be fired when a request event is raised #key# to the `request` event. The `request` event returns two objects: a `request` and a `response`. The `request` event is automatically fired when a client requests something from the server. In our case, the client simply requests for the web page to load.
- We use `req` and `res` as the names for the *request* and *response* returned by the `request` event. The *request* is an instance of the `http.IncomingMessage` class, and the *response* is an instance of the  `http.ServerResponse` class. We do not use the `req` for this simple demo; instead, we focus on the `res`.
- The `statusCode` method on **line 7** sets the HTTP status code. We set it to 200. If you are not familiar with HTTP status codes, **200** translates to **OK**. You might be familiar with **404**, which translates to **Not Found**.
- HTTP headers let the client and the server pass additional information with an HTTP request or response. There is a standard for these headers; we will use the `Content-Type` header and set it to `text/html` on **line 8**.
- The `end` method tells the server that all of the response headers and body have been sent. The server now knows that the message is complete. This method **must** be called on each response. We pass it our data, **Hello World** as the only parameter; however, we can also pass it a callback function that will run after the response ends. We will see how that works in a later lesson.
- The `listen()` method is identical to the `server.listen()` method which is used in the `net` module. Now, the server can start accepting requests from clients. We are also using a callback function to output the `hostname` and the `port` on the console.

Learn how to make a web server with the HTTP module in Node.js.

Introduction

Fundamentals

Advanced Topics

Packages

Project

Appendix

HTTP

The web

The server-side