You're reading from Mastering Node.js Web Development Go on a comprehensive journey from the fundamentals to advanced web development with Node.js

Product type Paperback

Published in Jun 2024

Publisher Packt

ISBN-13 9781804615072

Length 778 pages

Edition 1st Edition

Languages

Tools

Node.js

Concepts

Server Side Web Development

Author (1):

Adam Freeman

View More author details

Table of Contents (26) Chapters

1. Putting Node.js in Context FREE CHAPTER

2. Getting Ready

3. Working with the Node.js Tools

4. JavaScript and TypeScript Primer

5. Understanding Node.js Concurrency

6. Handling HTTP Requests

7. Using Node.js Streams

8. Using Bundles and Content Security

9. Unit Testing and Debugging

10. Node.js in Detail

11. Creating the Example Project

12. Using HTML Templates

13. Handling Form Data

14. Using Databases

15. Using Sessions

16. Creating RESTful Web Services

17. Authenticating and Authorizing Requests

18. SportsStore

19. SportsStore: A Real Application

20. SportsStore: Navigation and Cart

21. SportsStore: Orders and Validation

22. SportsStore: Authentication

23. SportsStore: Administration

24. SportsStore: Deployment

25. Other Books You May Enjoy

26. Index

Join our book community on Discord

https://packt.link/EarlyAccess

The foundation of server-side web development is the ability to receive HTTP requests from clients and generate responses. In this chapter, I introduce the Node.js API for creating HTTP servers and explain how it can be used to receive and respond to requests. Table 5.1 puts the Node.js HTTP API in context.

Table 5.1. Putting the Node.js API in context

Question	Answer
What is it?	The `http` and `https` modules contain the functions and classes required to create HTTP and HTTPS servers, receive requests, and generate responses.
Why is it useful?	Receiving and responding to HTTP requests is the core feature of server-side web application development.
How is it used?	Servers are created with the `createServer` function, which emits events when requests are received. Callback functions are invoked to handle the request and generate a response.
Are there any pitfalls or limitations?	Handler functions can become complex...