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

# UDP
Alongside TCP, #key# UDP: User Datagram Protocol #key# is the other most common communication protocol. It provides a simple and lightweight *connectionless* communication model. Being connectionless, a very minimal amount of protocol mechanisms come into play when sending packets. While checksums are still used for data integrity, UDP is favored in real-time applications, as it avoids the overhead of setting up a connection, error-checking, and retransmission delays.

# The `dgram` module
The `dgram` module provides an implementation of UDP Datagram sockets. These sockets are required for UDP communication.

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 `dgram` module on **line 1**.
- The `createSocket` method on **line 3**  creates a UDP socket. A `type` must be passed; we are using `udp4` in our case. The socket returned is an object of the `EventEmitter` class. This allows us to use the `on` method to handle different events.
- Declaring our `port` early in the code and using the variable name will make changing it later on easier. We have set the `port` to 3500 on **line 4**.
- The `message` event is fired when we receive a message from another socket. It returns the `data` and an `rinfo` object. We are outputting the data on **line 7**. `rinfo` has a lot of useful attributes; we use `rinfo.port` to send a message back to our client.
- We *send* data on the socket by using the `send` method. We pass it a string of our choice, the port, and the #key# IP address: localhost in our case #key# of the recipient. This is done on **line 8**.
- The `listening` event is fired when the `socket` object starts to listen for incoming connections. We are using this event to output a string to let us know that the server is up. This is done on **line 11**.
- The `close` event is fired when the socket is fully closed. If the socket closes due to an error, an `Error` object is returned. We are handling this event on **line 15**.
- Finally, to start the server, we use the `bind()` method.  This fires the *listening* event we wrote earlier. It is passed a **port number**. Now our server is live and waiting for new connections.

# The client-side
- Our client-side looks very similar to the server-side since we are using the `dgram.createSocket` method again to make our socket.
- As you can see, once our `socket` object is created, we can start sending data to our server right away. We do not need to *connect* to the server as we did in our TCP example. We are using the `send` method as we did in our server; however, here we are also checking for errors.
- The only way to know for sure that the datagram has been sent is by using a callback. In case of an error, it will be passed as the first argument to the callback. If a callback is not given, the error is emitted as an `error` event on the socket object.
- The `data` and `end` methods are used in a similar manner as we have used on the server-side. The `end` method is similar to the `close` method in terms of functionality.

# Let’s make them talk
Using the `readline` module, once again, we can achieve the same functionality as we did with our TCP system. Let's see how that might look with UDP.

Learn how the UDP module works in Node.js.

Introduction

Fundamentals

Advanced Topics

Packages

Project

Appendix

UDP

UDP

The `dgram` module

UDP

UDP

The dgram module

The `dgram` module