chyingp/nodejs-learning-guide

Features

• Node.js - Serves as a comprehensive learning guide and study note collection for Node.js backend development.
• Node.js Backend Services - Offers a comprehensive guide to building server-side applications, including HTTP servers and session management.
• Core API Guides - Provides a comprehensive instructional reference for native Node.js modules like fs, http, and crypto.
• Binary Data Buffers - Implements binary data buffers for creating fixed-length memory allocations to store raw binary data.
• Local File Writing - Provides local file writing capabilities with options for overwriting content or using incremental streams.
• Streaming Data Transformers - Implements streaming data transformers for real-time operations like Gzip compression and encryption within Node.js I/O pipelines.
• Memory-Efficient Data Streaming - Processes large datasets incrementally in small chunks to maintain low memory overhead.
• Incremental Data Streaming - Provides techniques for incremental data streaming to process large files and network requests while maintaining low memory usage.
• Incremental Writes - Provides functionality to write data to files or network sockets in chunks until the stream closes.
• Binary Buffer Management - Implements raw byte handling using binary buffers for memory-efficient data manipulation.
• Filesystem Directory Operations - Provides low-level filesystem directory operations including creating, renaming, and deleting folders on local disks.
• Node.js Development Tutorials - Offers practical tutorials for implementing server-side logic and authentication in Node.js.
• Bidirectional Socket Communication - Establishes persistent TCP/UDP connections for simultaneous bidirectional data exchange between clients and servers.
• Network Service Implementations - Implements servers and clients for various network protocols including HTTP, HTTPS, TCP, and UDP.
• TCP Server Management - Implements raw TCP servers to facilitate bidirectional data exchange on a specific port.
• Node.js Network Programming - Teaches the implementation of TCP, UDP, and HTTPS services for network communication in Node.js.
• File System Manipulations - Provides core capabilities for reading, writing, and manipulating files and directories via the Node.js fs module.
• Node.js File System Management - Provides instructional content on reading, writing, and manipulating local files and directories via the fs module.
• Node.js Buffer Encodings - Implements Node.js buffer encodings to decode binary data into human-readable strings using various character sets.
• Network Programming Guides - Includes instructional material on building bidirectional TCP, UDP, and HTTP services.
• Stream Processing - Implements incremental reading and writing of data from network or file sources to optimize memory usage.
• Node.js Process Managers - Provides guidance on controlling child processes, clusters, and inter-process communication to scale applications.
• Process Management Guides - Provides technical documentation on scaling Node.js applications using clusters and child processes.
• Event Emitters - Implements the event emitter pattern to trigger named events and execute associated listener functions.
• Node.js Security Implementation - Covers the implementation of cryptographic hashing, symmetric/asymmetric encryption, and secure cookie signing.
• Recursive Directory Traversers - Implements recursive directory traversers to list files and subdirectories within hierarchical file system paths.
• File Reading - Provides asynchronous and streaming reading of file contents into memory.
• HTTP Server Implementations - Implements core logic for listening on network ports and handling HTTP request-response cycles.
• HTTPS Servers - Implements secure web servers using TLS encryption to protect network traffic.
• Upload Metadata Extraction - Extracts technical attributes such as MIME types, filenames, and sizes from uploaded files.
• Cipher Block Modes - Provides utilities to process long plaintext by dividing it into blocks and encrypting them using patterns.
• Runtime Variable Inspection - Covers evaluating variable values and tracking expressions via watch lists during debugging.
• Remote Debugging - Demonstrates connecting a local debugger to a remote process via a network port.
• Application Logging Utilities - Provides utilities for writing formatted messages to the console to track program flow.
• Runtime Call-Stack Capturers - Includes utilities to print the current execution stack to identify function call sequences.
• Immediate Process Exits - Provides the ability to terminate the running process immediately with a specific exit code.
• Data Appending - Implements functionality to add new data to the end of an existing file without modifying current content.
• Shell Command Execution - Implements capabilities for triggering and controlling operating system shell commands.
• Inter-Process Communication - Demonstrates mechanisms for exchanging data and coordinating actions between a primary process and worker instances.
• Middleware-Based Request Pipelines - Implements modular chains of pluggable components that intercept and process incoming network requests.
• Connection Metadata Tracking - Provides utilities to access local and remote network addresses and ports for active connections.
• HTTP Clients - Implements HTTP client logic to execute network requests and process data from remote servers.
• Request Metadata Parsers - Provides utilities to extract HTTP version, request method, URL, and headers from client requests.
• HTTP Request Dispatchers - Implements capabilities to perform outbound GET and POST requests to remote servers.
• Network Address Resolution - Implements the translation of hostnames into IP addresses using DNS queries or local host files.
• Network Data Streaming - Provides mechanisms to manage information flow between clients and servers using Node.js stream interfaces.
• Request Distribution Strategies - Implements strategies for distributing network requests across multiple worker processes.
• TCP Client Connections - Implements the capability to initiate TCP connections to remote servers for data transmission.
• UDP Communication - Provides functionality to transmit UDP data packets via unicast and broadcast traffic.
• Execution Flow Control - Covers debugging capabilities for stepping into or out of functions during execution.
• Native Binary Execution - Explains how to run executable files directly without spawning a shell to improve efficiency.
• Process Signal Management - Implements utilities for sending OS-level signals to manage and terminate system processes.
• Standard I/O Bridges - Provides interfaces that connect the runtime's input and output streams to the system's standard I/O.
• Process Detachment - Demonstrates how to run a child process independently so it continues executing after the parent exits.
• Process Forking - Provides guidance on creating new processes with built-in channels for exchanging JSON messages.
• Asymmetric Encryption - Implements encryption and decryption using pairs of public and private keys.
• Session State Management - Provides utilities to track and verify active user session states during network requests.
• Process-Based Scaling - Implements request throughput scaling by creating multiple process instances to handle client requests in parallel.
• Cookie Signing Utilities - Implements cryptographic signature appending to cookies to prevent client-side tampering and ensure integrity.
• Cryptographic Hash Generation - Implements the generation of secure hashes and HMACs using standard cryptographic algorithms to verify data integrity.
• Symmetric - Implements both symmetric shared-key encryption and asymmetric public-private key pairs for data security.
• Security & HTTPS - Implements secure HTTPS request execution using CA certificates and encryption protocols.
• Session Authentication - Manages secure user sessions and credential persistence using cookie-based identifiers for login and logout flows.
• Function Execution Timing - Provides utilities to calculate elapsed time between markers in milliseconds to identify performance bottlenecks.
• Child Process Execution - Implements capabilities for spawning and managing external system processes from a primary application.
• Inter-Process Message Passing - Provides capabilities for exchanging JSON data between parent and child processes via internal communication channels.
• Request Interception Middleware - Implements request interception patterns via middleware to record traffic and execution details in the request pipeline.
• Runtime Execution Debugging - Demonstrates how to pause execution and step through logic to inspect program state.
• Application Logging - Implements mechanisms to capture timestamps and severity levels for system event logging.
• HTTP Response Monitors - Implements capability to track the HTTP response lifecycle by listening for completion or closure events.
• Filesystem Change Monitors - Implements the ability to watch for modifications to files or directories using polling or system events.
• Connection Lifecycle Management - Provides utilities to check connection status and disconnect internal communication channels between parent and child processes.
• System Usage Monitoring - Includes tools to track process uptime, memory, and CPU usage for performance benchmarking.
• Network Connectivity Monitoring - Provides event listeners on requests and sockets to detect when client connections are aborted or closed.
• Application State Inspection - Provides techniques for inspecting live application behavior on servers using formatted logs.
• Request Logging - Implements middleware to capture and record details of incoming HTTP traffic for real-time monitoring.
• Request Lifecycle Tracking - Implements tracking of network events, such as responses and socket assignments, to manage communication state.
• Parameter Extraction - Provides utilities to retrieve user input from both URL query strings and HTTP request bodies.
• HTTP Response Handling - Implements functionality to set and manage HTTP response headers, status codes, and content types.
• Response Streaming - Implements incremental delivery of large HTTP response bodies to optimize memory usage.
• Custom File Storage Logic - Defines custom naming rules and destination paths for storing uploaded files on the server.
• Event Emitters - Implements a publish-subscribe pattern where named events trigger registered callback functions using the event emitter pattern.
• Local File Uploads - Handles the reception of files from HTTP multipart requests and stores them on the local filesystem.
• Process-Based Scaling - Demonstrates scaling application throughput by spawning multiple worker processes to utilize all available CPU cores.
• Request Body Parsing - Provides functionality to convert incoming HTTP request bodies from JSON or URL-encoded strings into structured data.

Star history