Skip to main content
Mapagam

51 SECTIONS · 766 TOPICS

NODEJS Roadmap

  1. Installing and Configuring Node.js

    1. 1. Installing Node.js
    2. 2. Managing Node Versions
    3. 3. Checking Node Version
    4. 4. Checking npm Version
    5. 5. Using Node Version Manager
    6. Example: .nvmrc auto-switch
    7. 6. Configuring npm Registry
    8. 7. Setting Up Global Install Directory
    9. 8. Configuring Environment Variables
    10. 9. Understanding Node.js Runtime Architecture
    11. Architecture Stack
    12. 10. Configuring Node.js for Production

  2. Working with Node.js REPL

    1. 1. Starting REPL Session
    2. 2. Evaluating JavaScript Expressions
    3. 3. Using Multi-Line Input (.editor)
    4. Example: Editor mode
    5. 4. Navigating REPL History
    6. 5. Using Tab Completion
    7. 6. Using Underscore for Last Result (_)
    8. Example: Underscore variables
    9. 7. Inspecting Objects in REPL
    10. 8. Loading External Files (.load)
    11. Example: Load script into REPL
    12. 9. Saving REPL Session (.save)
    13. 10. Clearing REPL Context (.clear)
    14. 11. Using REPL Commands (.help, .exit, .break)

  3. Working with Globals

    1. 1. Using __dirname and __filename
    2. 2. Understanding global Object
    3. 3. Using globalThis
    4. 4. Using console Methods
    5. 5. Using Buffer Global
    6. 6. Using process Global
    7. 7. Using setTimeout/setInterval Globals
    8. 8. Understanding module Object
    9. 9. Using require Function
    10. 10. Using exports and module.exports
    11. Example: Two export patterns
    12. 11. Avoiding Global Variable Pollution

  4. Working with Module Systems

    1. 1. Using CommonJS Modules
    2. Example: CommonJS
    3. 2. Understanding module.exports vs exports
    4. Reference Model
    5. 3. Using Module Wrapper Function
    6. 4. Understanding Module Resolution
    7. 5. Using ES Modules
    8. Example: ESM
    9. 6. Configuring Module Type
    10. 7. Using Dynamic Imports (import())
    11. Example: Lazy load
    12. 8. Using Import Assertions
    13. Example: JSON import
    14. 9. Loading JSON Files
    15. 10. Creating Conditional Exports
    16. Example: package.json exports
    17. 11. Creating Dual Packages
    18. 12. Creating Module Aliases

  5. Managing npm Packages

    1. 1. Initializing Package
    2. 2. Installing Packages
    3. 3. Installing Dev Dependencies
    4. 4. Installing Global Packages
    5. 5. Updating Packages
    6. 6. Removing Packages
    7. 7. Using npx for Package Execution
    8. 8. Understanding Semantic Versioning (^, ~, exact)
    9. 9. Managing Lock Files
    10. 10. Auditing Security
    11. 11. Publishing Packages
    12. Publish Workflow
    13. 12. Using Workspaces
    14. Example: Monorepo workspaces

  6. Working with Package.json

    1. 1. Defining Scripts
    2. Example: Common scripts
    3. 2. Setting Entry Point
    4. 3. Specifying Dependencies
    5. 4. Using Peer Dependencies
    6. Example: Plugin requiring host
    7. 5. Using Optional Dependencies
    8. 6. Configuring Exports
    9. Example: Subpath + types
    10. 7. Setting Module Type (type: module)
    11. 8. Defining Engines
    12. Example: Pin engine
    13. 9. Using Pre and Post Scripts
    14. 10. Configuring bin for CLI Tools
    15. Example: CLI binary
    16. 11. Using Files Field
    17. 12. Setting Package Metadata

  7. Working with Process Object

    1. 1. Accessing Command-Line Arguments
    2. Example: process.argv
    3. 2. Reading Environment Variables
    4. 3. Getting Current Directory (process.cwd)
    5. 4. Changing Directory (process.chdir)
    6. Example
    7. 5. Getting Platform Info
    8. 6. Getting Process ID (process.pid)
    9. 7. Accessing Memory Usage (process.memoryUsage)
    10. 8. Getting CPU Usage (process.cpuUsage)
    11. Example
    12. 9. Measuring Performance (process.hrtime, process.hrtime.bigint)
    13. 10. Handling Process Events
    14. 11. Exiting Process (process.exit)
    15. 12. Sending Process Signals (process.kill)

  8. Working with Environment and Configuration

    1. 1. Loading .env Files
    2. Example: Built-in loader
    3. 2. Accessing process.env Variables
    4. 3. Setting Default Values (|| operator, ?? nullish coalescing)
    5. Example
    6. 4. Using NODE_ENV for Environment Detection
    7. 5. Managing Multiple Environments
    8. 6. Using config Libraries
    9. 7. Using Environment-Specific Configs
    10. Example: Switch by NODE_ENV
    11. 8. Validating Environment Variables
    12. Example: Zod schema
    13. 9. Using cross-env for Cross-Platform
    14. Example
    15. 10. Securing Sensitive Data

  9. Working with Command-Line Arguments

    1. 1. Accessing process.argv Array
    2. 2. Parsing Arguments Manually
    3. Example: Tiny parser
    4. 3. Using util.parseArgs for CLI
    5. Example: util.parseArgs
    6. 4. Using commander for CLI
    7. Example
    8. 5. Using yargs for Argument Parsing
    9. 6. Handling Flags and Options (--flag, -f)
    10. 7. Using Positional Arguments
    11. 8. Implementing Subcommands
    12. Example: commander subcommands
    13. 9. Adding Help and Usage Info
    14. 10. Validating User Input
    15. 11. Creating Interactive CLIs

  10. Working with stdin and stdout

    1. 1. Reading from stdin (process.stdin)
    2. Example: Async iterator
    3. 2. Writing to stdout (process.stdout)
    4. 3. Writing to stderr (process.stderr)
    5. Example
    6. 4. Handling Input Events
    7. 5. Piping Data Between Streams
    8. Example: Uppercase pipeline
    9. 6. Setting Raw Mode (setRawMode)
    10. 7. Using TTY Module (tty.isatty)
    11. 8. Detecting Terminal Size (process.stdout.columns)
    12. 9. Handling ANSI Colors
    13. 10. Creating Progress Bars
    14. Example: Manual bar

  11. Working with Readline Interface

    1. 1. Creating Readline Interface (readline.createInterface)
    2. Example: Basic interface
    3. 2. Reading Line by Line
    4. Example: Process file lines
    5. 3. Prompting for Input (rl.question)
    6. 4. Writing Prompts (rl.prompt)
    7. 5. Pausing Input (rl.pause)
    8. 6. Resuming Input (rl.resume)
    9. 7. Closing Interface (rl.close)
    10. 8. Handling SIGINT
    11. Example: Confirm exit
    12. 9. Using Async Iterators on Interface
    13. 10. Creating Command-Line Interfaces
    14. Example: REPL-style loop
    15. 11. Implementing Auto-Completion
    16. Example: Completer fn

  12. Understanding the Event Loop

    1. 1. Understanding Event Loop Phases
    2. libuv Phases (per tick)
    3. 2. Understanding the Call Stack
    4. 3. Understanding the Callback Queue
    5. 4. Using process.nextTick for Microtasks
    6. Example
    7. 5. Using setImmediate for Check Phase
    8. 6. Understanding Microtasks vs Macrotasks
    9. 7. Understanding Promise Resolution Timing
    10. Example: Order
    11. 8. Avoiding Event Loop Blocking
    12. 9. Monitoring Event Loop Lag
    13. Example: perf_hooks monitor
    14. 10. Using Event Loop Utilities

  13. Handling Asynchronous Operations

    1. 1. Using Callbacks
    2. Example: Node-style callback
    3. 2. Working with Promises
    4. Example
    5. 3. Using Async/Await Syntax
    6. Example
    7. 4. Converting Callbacks to Promises (util.promisify)
    8. Example
    9. 5. Handling Promise Rejection
    10. 6. Using Promise.all for Parallel Execution
    11. Example
    12. 7. Using Promise.race for First Resolution
    13. 8. Using Promise.allSettled for All Results
    14. Example
    15. 9. Using Promise.any for First Fulfillment
    16. 10. Understanding Async Error Handling (try-catch)
    17. 11. Using AbortController for Cancellation
    18. Example
    19. 12. Using AbortSignal for Timeouts

  14. Working with Timers

    1. 1. Using setTimeout for Delays
    2. 2. Using setInterval for Repetition
    3. Example
    4. 3. Using setImmediate for Next Cycle
    5. 4. Using process.nextTick for Microtasks
    6. 5. Clearing Timeouts (clearTimeout)
    7. Example
    8. 6. Clearing Intervals (clearInterval)
    9. 7. Clearing Immediate (clearImmediate)
    10. 8. Understanding Timer Order
    11. 9. Using Timers/Promises
    12. Example: Promise-based timers
    13. 10. Handling Timer Drift
    14. 11. Scheduling Delayed Tasks

  15. Working with Events

    1. 1. Creating Event Emitters
    2. Example
    3. 2. Registering Event Listeners
    4. 3. Using Once Listeners
    5. Example
    6. 4. Emitting Events
    7. 5. Removing Listeners
    8. 6. Prepending Listeners (prependListener)
    9. 7. Getting Listener Count (listenerCount)
    10. 8. Setting Max Listeners (setMaxListeners)
    11. 9. Handling Error Events
    12. Example
    13. 10. Using Async Iterators on Events
    14. Example
    15. 11. Creating Custom Event Emitters
    16. Example: Typed emitter (TS)

  16. Working with Buffers

    1. 1. Creating Buffers
    2. 2. Using Buffer.alloc vs Buffer.allocUnsafe
    3. 3. Writing to Buffers
    4. 4. Reading from Buffers
    5. 5. Converting Encodings
    6. Example: Convert
    7. 6. Checking Buffer Length
    8. 7. Comparing Buffers
    9. 8. Concatenating Buffers (Buffer.concat)
    10. Example
    11. 9. Copying Buffers
    12. 10. Slicing Buffers
    13. 11. Understanding Buffer Pooling

  17. Working with Streams

    1. 1. Creating Readable Streams (fs.createReadStream)
    2. Example
    3. 2. Creating Writable Streams (fs.createWriteStream)
    4. 3. Using Transform Streams (stream.Transform)
    5. Example: gzip on the fly
    6. 4. Using Duplex Streams
    7. 5. Handling Stream Events
    8. 6. Piping Streams
    9. Example: pipeline (preferred)
    10. 7. Controlling Stream Flow
    11. 8. Using Backpressure
    12. Backpressure
    13. 9. Working with Object Mode
    14. Example
    15. 10. Using stream.Readable.from() Method
    16. 11. Consuming Streams with Async Iterators
    17. Example
    18. 12. Understanding Highwater Mark

  18. Using Web Streams API

    1. 1. Creating ReadableStream
    2. Example
    3. 2. Creating WritableStream
    4. Example
    5. 3. Using TransformStream
    6. 4. Piping Web Streams
    7. Example
    8. 5. Converting Node.js Streams to Web Streams
    9. 6. Converting Web Streams to Node.js Streams
    10. 7. Using Streams with Fetch API
    11. Example: Stream response
    12. 8. Handling Backpressure in Web Streams
    13. 9. Understanding Web Streams vs Node Streams
    14. 10. Using Async Iteration with Web Streams

  19. Working with File System (fs)

    1. 1. Reading Files
    2. Example: Promise API
    3. 2. Writing Files
    4. 3. Appending to Files (fs.appendFile)
    5. Example
    6. 4. Checking File Existence
    7. 5. Getting File Stats
    8. 6. Creating Directories
    9. 7. Reading Directories
    10. 8. Deleting Files
    11. 9. Removing Directories
    12. 10. Watching Files
    13. Example
    14. 11. Using Promises API (fs/promises)
    15. 12. Working with File Descriptors
    16. Example: FileHandle
    17. 13. Copying Files (fs.copyFile)
    18. 14. Renaming Files (fs.rename)
    19. 15. Creating Symlinks

  20. Working with Path Module

    1. 1. Joining Paths (path.join)
    2. Example
    3. 2. Resolving Absolute Paths (path.resolve)
    4. 3. Getting Directory Name (path.dirname)
    5. 4. Getting Base Name (path.basename)
    6. 5. Getting File Extension (path.extname)
    7. 6. Normalizing Paths (path.normalize)
    8. 7. Checking Absolute Paths (path.isAbsolute)
    9. 8. Getting Relative Paths (path.relative)
    10. Example
    11. 9. Parsing Paths (path.parse)
    12. 10. Formatting Paths (path.format)
    13. 11. Using Platform-Specific Separators

  21. Working with OS Module

    1. 1. Getting OS Platform (os.platform)
    2. 2. Getting OS Architecture (os.arch)
    3. 3. Getting OS Type (os.type)
    4. 4. Getting Hostname (os.hostname)
    5. 5. Getting Home Directory (os.homedir)
    6. 6. Getting Temp Directory (os.tmpdir)
    7. 7. Getting User Info (os.userInfo)
    8. 8. Getting CPU Info (os.cpus)
    9. Example
    10. 9. Getting Total Memory (os.totalmem)
    11. 10. Getting Free Memory (os.freemem)
    12. 11. Getting System Uptime (os.uptime)
    13. 12. Getting Network Interfaces (os.networkInterfaces)
    14. 13. Getting EOL Character (os.EOL)

  22. Working with URL Module

    1. 1. Parsing URLs
    2. Example: WHATWG URL
    3. 2. Getting URL Components
    4. 3. Using URLSearchParams
    5. Example
    6. 4. Formatting URLs (url.format)
    7. 5. Resolving URLs (url.resolve)
    8. 6. Encoding URL Components (encodeURIComponent)
    9. 7. Decoding URL Components (decodeURIComponent)
    10. 8. Working with URL Hash
    11. Example
    12. 9. Building URLs Programmatically
    13. Example
    14. 10. Using WHATWG URL API vs Legacy

  23. Working with Query Strings

    1. 1. Parsing Query Strings (querystring.parse)
    2. Example
    3. 2. Stringifying Objects (querystring.stringify)
    4. 3. Encoding Values (querystring.escape)
    5. 4. Decoding Values (querystring.unescape)
    6. 5. Handling Arrays in Query Strings
    7. 6. Using Custom Separators (& vs ;)
    8. Example
    9. 7. URLSearchParams vs querystring
    10. 8. Building Query Strings from Objects
    11. Example
    12. 9. Handling Nested Objects
    13. 10. Using qs Package for Complex Queries
    14. Example

  24. Working with Util Module

    1. 1. Promisifying Callbacks (util.promisify)
    2. Example
    3. 2. Creating Callbackified Functions (util.callbackify)
    4. 3. Formatting Strings (util.format)
    5. 4. Inspecting Objects (util.inspect)
    6. Example
    7. 5. Checking Types
    8. 6. Using TextEncoder and TextDecoder
    9. Example
    10. 7. Using Debuglog (util.debuglog)
    11. Example: Conditional log
    12. 8. Deprecating Functions (util.deprecate)
    13. 9. Using parseArgs for CLI (util.parseArgs)
    14. 10. Using isDeepStrictEqual for Comparison
    15. Example
    16. 11. Using MIMEType for Content Types

  25. Working with Assert Module

    1. 1. Using assert() for Truthy Checks
    2. Example
    3. 2. Using assert.ok for Boolean Checks
    4. 3. Using assert.strictEqual (===)
    5. 4. Using assert.notStrictEqual (!==)
    6. 5. Using assert.deepStrictEqual
    7. Example
    8. 6. Using assert.notDeepStrictEqual
    9. 7. Using assert.throws (error testing)
    10. Example
    11. 8. Using assert.rejects
    12. Example
    13. 9. Using assert.doesNotThrow
    14. 10. Using assert.ifError
    15. 11. Using assert.match
    16. 12. Creating Custom Assertion Messages
    17. Example: AssertionError

  26. Working with HTTP Server

    1. 1. Creating HTTP Server (http.createServer)
    2. Example: Minimal server
    3. 2. Listening on Port (server.listen)
    4. 3. Handling Requests
    5. 4. Reading Request Data
    6. Example
    7. 5. Handling Request Body
    8. 6. Using URL Module for Parsing
    9. Example
    10. 7. Implementing Routing
    11. Example: Manual router
    12. 8. Sending Responses
    13. 9. Setting Response Headers
    14. 10. Setting Status Codes (res.statusCode)
    15. 11. Serving Static Files
    16. Example: Stream file
    17. 12. Closing Server (server.close)
    18. 13. Handling Server Errors

  27. Working with HTTPS Server

    1. 1. Creating HTTPS Server (https.createServer)
    2. Example
    3. 2. Loading SSL Certificates
    4. 3. Configuring TLS Options
    5. 4. Handling Secure Connections
    6. 5. Testing with Self-Signed Certificates
    7. Example
    8. 6. Using Let's Encrypt Certificates
    9. 7. Redirecting HTTP to HTTPS
    10. Example
    11. 8. Implementing Certificate Pinning
    12. 9. Handling TLS Errors
    13. 10. Renewing SSL Certificates
    14. Renewal Workflow

  28. Making HTTP Requests

    1. 1. Using http.get for GET Requests
    2. Example
    3. 2. Using http.request Method
    4. 3. Using https.request for Secure Requests
    5. 4. Using Native Fetch API (modern approach)
    6. Example: Modern fetch
    7. 5. Setting Request Headers
    8. 6. Sending Request Body
    9. 7. Working with Query Parameters
    10. Example
    11. 8. Handling Response Data
    12. 9. Following Redirects Manually
    13. 10. Setting Request Timeout
    14. Example
    15. 11. Using AbortController for Cancellation
    16. 12. Handling Request Errors

  29. Working with Networking (net)

    1. 1. Creating TCP Server (net.createServer)
    2. Example: Echo server
    3. 2. Creating TCP Client
    4. Example
    5. 3. Handling Connection Events
    6. 4. Writing Data to Socket (socket.write)
    7. 5. Ending Connections (socket.end)
    8. 6. Destroying Sockets (socket.destroy)
    9. 7. Getting Socket Address (socket.address)
    10. 8. Setting Socket Timeout (socket.setTimeout)
    11. Example
    12. 9. Implementing Keep-Alive (setKeepAlive)
    13. 10. Using Unix Sockets
    14. 11. Handling Socket Errors

  30. Working with UDP (dgram)

    1. 1. Creating UDP Socket (dgram.createSocket)
    2. Example
    3. 2. Binding to Port (socket.bind)
    4. 3. Sending Messages (socket.send)
    5. Example
    6. 4. Receiving Messages
    7. 5. Broadcasting Messages (setBroadcast)
    8. Example
    9. 6. Setting TTL (setTTL)
    10. 7. Joining Multicast Groups (addMembership)
    11. Example
    12. 8. Leaving Multicast Groups (dropMembership)
    13. 9. Closing UDP Socket (socket.close)
    14. 10. Handling UDP Errors

  31. Working with DNS Module

    1. 1. Resolving Domain Names (dns.lookup)
    2. Example
    3. 2. Resolving with dns.resolve
    4. 3. Resolving CNAME Records (dns.resolveCname)
    5. 4. Resolving TXT Records (dns.resolveTxt)
    6. 5. Resolving SRV Records (dns.resolveSrv)
    7. 6. Reverse DNS Lookup (dns.reverse)
    8. 7. Getting Name Servers (dns.getServers)
    9. 8. Setting Name Servers (dns.setServers)
    10. Example
    11. 9. Using Promises API (dns.promises)
    12. 10. Handling DNS Errors

  32. Working with WebSockets

    1. 1. Creating WebSocket Server
    2. Example: ws library
    3. 2. Handling WebSocket Connections
    4. 3. Sending Messages (ws.send)
    5. 4. Receiving Messages
    6. Example
    7. 5. Broadcasting to All Clients
    8. Example
    9. 6. Implementing Heartbeat/Ping-Pong
    10. Example: Detect dead clients
    11. 7. Handling Connection Close
    12. 8. Handling WebSocket Errors
    13. 9. Implementing WebSocket Authentication
    14. 10. Using Socket.io for Real-Time Communication

  33. Working with Zlib (Compression)

    1. 1. Compressing with gzip (zlib.gzip)
    2. Example
    3. 2. Decompressing with gunzip (zlib.gunzip)
    4. 3. Using Deflate Compression (zlib.deflate)
    5. 4. Using Inflate Decompression (zlib.inflate)
    6. Example
    7. 5. Using Brotli Compression (zlib.brotliCompress)
    8. 6. Creating Compression Streams (zlib.createGzip)
    9. Example
    10. 7. Setting Compression Level
    11. 8. Compressing HTTP Responses
    12. Example: Negotiate encoding
    13. 9. Using Promises API (zlib.promises)
    14. 10. Handling Compression Errors

  34. Working with Crypto Module

    1. 1. Creating Hashes (crypto.createHash)
    2. Example: SHA-256
    3. 2. Creating HMAC (crypto.createHmac)
    4. Example
    5. 3. Generating Random Bytes (crypto.randomBytes)
    6. 4. Generating Random UUIDs (crypto.randomUUID)
    7. Example
    8. 5. Creating Secure Random Strings
    9. Example: token
    10. 6. Encrypting Data (crypto.createCipheriv)
    11. Example: AES-256-GCM
    12. 7. Decrypting Data (crypto.createDecipheriv)
    13. Example
    14. 8. Creating Public/Private Keys (crypto.generateKeyPair)
    15. Example
    16. 9. Signing Data (crypto.sign)
    17. 10. Verifying Signatures (crypto.verify)
    18. Example
    19. 11. Using scrypt for Key Derivation
    20. Example
    21. 12. Using bcrypt for Password Hashing
    22. Example

  35. Working with Child Processes

    1. 1. Executing Commands (child_process.exec)
    2. Example
    3. 2. Executing Files (child_process.execFile)
    4. Example
    5. 3. Spawning Processes (child_process.spawn)
    6. Example: Stream stdout
    7. 4. Forking Processes (child_process.fork)
    8. 5. Handling Child Process Events
    9. 6. Piping Standard I/O
    10. 7. Communicating with IPC
    11. Example
    12. 8. Setting Working Directory
    13. 9. Configuring Environment Variables
    14. 10. Detaching Child Processes
    15. Example: Long-running daemon
    16. 11. Killing Child Processes
    17. 12. Using Promisified Exec (util.promisify)

  36. Working with Cluster Module

    1. 1. Creating Master Process
    2. Example
    3. 2. Forking Worker Processes (cluster.fork)
    4. 3. Handling Worker Events
    5. 4. Load Balancing Requests
    6. 5. Communicating Between Master and Workers
    7. Example
    8. 6. Getting Worker Count (Object.keys(cluster.workers))
    9. 7. Setting Scheduling Policy (cluster.schedulingPolicy)
    10. Example
    11. 8. Graceful Shutdown
    12. Shutdown Flow
    13. 9. Respawning Dead Workers
    14. Example
    15. 10. Using PM2 for Process Management

  37. Working with Worker Threads

    1. 1. Creating Worker Threads (new Worker)
    2. Example
    3. 2. Passing Data to Workers (workerData)
    4. 3. Communicating with postMessage
    5. Example
    6. 4. Handling Messages
    7. 5. Handling Worker Errors
    8. 6. Transferring ArrayBuffers
    9. Example: Zero-copy
    10. 7. Sharing Memory (SharedArrayBuffer)
    11. 8. Using Atomics for Synchronization
    12. 9. Terminating Workers (worker.terminate)
    13. 10. Using Worker Thread Pools
    14. 11. Understanding Worker vs Cluster

  38. Handling Errors and Exceptions

    1. 1. Using Try-Catch Blocks
    2. Example
    3. 2. Handling Async Errors
    4. 3. Creating Custom Errors
    5. Example
    6. 4. Using Error Stack Traces (error.stack)
    7. 5. Using Error Codes (error.code)
    8. 6. Using Error.captureStackTrace
    9. Example
    10. 7. Handling Uncaught Exceptions
    11. Example
    12. 8. Handling Unhandled Rejections
    13. 9. Implementing Error Middleware
    14. Example: Express style
    15. 10. Using Domain Module
    16. 11. Graceful Error Recovery
    17. 12. Logging Errors

  39. Implementing Logging

    1. 1. Using console for Basic Logging
    2. 2. Configuring Log Levels
    3. 3. Using winston for Advanced Logging
    4. Example
    5. 4. Using pino for High-Performance Logging
    6. Example
    7. 5. Structured Logging
    8. 6. Writing Logs to Files
    9. 7. Using Log Rotation (rotating-file-stream)
    10. Example
    11. 8. Adding Context to Logs
    12. Example: Per-request context
    13. 9. Sending Logs to External Services
    14. 10. Implementing Log Aggregation
    15. Aggregation Pipeline

  40. Debugging Node.js Applications

    1. 1. Using console.log for Debugging
    2. 2. Using debugger Statement
    3. 3. Using Node Inspector (--inspect flag)
    4. 4. Using node --inspect-brk
    5. 5. Using Chrome DevTools (chrome://inspect)
    6. Connect Workflow
    7. 6. Using VS Code Debugger (launch.json)
    8. Example: launch.json
    9. 7. Using Debug Module
    10. Example
    11. 8. Setting Breakpoints
    12. 9. Profiling CPU Usage (--prof flag)
    13. 10. Analyzing Profile Output (--prof-process)
    14. Example
    15. 11. Memory Leak Detection
    16. 12. Using Clinic.js for Diagnostics
    17. 13. Using llnode for Post-Mortem Debugging

  41. Testing Node.js Applications

    1. 1. Using Node Test Runner (node:test)
    2. Example: Built-in
    3. 2. Writing Test Suites
    4. 3. Using Test Hooks
    5. 4. Creating Test Assertions
    6. 5. Testing Async Code
    7. Example
    8. 6. Running Tests (node --test flag)
    9. 7. Using Test Coverage (--experimental-coverage)
    10. 8. Mocking Dependencies
    11. Example: Built-in mock
    12. 9. Using Jest for Testing
    13. 10. Using Mocha and Chai
    14. Example
    15. 11. Testing HTTP Endpoints
    16. Example: supertest
    17. 12. Integration vs Unit Testing

  42. Working with Performance Hooks

    1. 1. Measuring Performance (performance.now)
    2. Example
    3. 2. Creating Performance Marks (performance.mark)
    4. 3. Measuring Between Marks (performance.measure)
    5. Example
    6. 4. Using Performance Observer (PerformanceObserver)
    7. Example
    8. 5. Tracking HTTP Timing
    9. 6. Monitoring Event Loop Lag
    10. 7. Using perf_hooks for Profiling
    11. Example: timerify
    12. 8. Measuring Function Execution Time
    13. 9. Creating Custom Metrics
    14. 10. Analyzing Performance Data

  43. Working with V8 Module

    1. 1. Getting Heap Statistics (v8.getHeapStatistics)
    2. 2. Getting Heap Space Statistics
    3. 3. Creating Heap Snapshots (v8.writeHeapSnapshot)
    4. Example
    5. 4. Using Serialization
    6. 5. Using Cached Data
    7. 6. Setting Heap Limit (--max-old-space-size)
    8. 7. Profiling Memory Usage
    9. 8. Understanding Garbage Collection
    10. 9. Using Weak References
    11. 10. Monitoring Memory Leaks
    12. Leak Hunt Workflow

  44. Working with Inspector Module

    1. 1. Opening Inspector (inspector.open)
    2. Example
    3. 2. Creating Inspector Session (new inspector.Session)
    4. 3. Connecting to Chrome DevTools
    5. 4. Posting Protocol Messages
    6. Example: Enable profiler
    7. 5. Enabling Profiler (Profiler.enable)
    8. 6. Taking CPU Profiles
    9. Example
    10. 7. Taking Heap Snapshots (HeapProfiler)
    11. 8. Using Coverage (Profiler.startPreciseCoverage)
    12. Example
    13. 9. Debugging Remotely
    14. 10. Analyzing Runtime Performance

  45. Working with Async Hooks

    1. 1. Creating Async Hooks (async_hooks.createHook)
    2. Example
    3. 2. Using init Callback
    4. 3. Using before and after Callbacks
    5. 4. Using destroy Callback
    6. 5. Getting Current Execution ID (executionAsyncId)
    7. 6. Getting Trigger Async ID (triggerAsyncId)
    8. 7. Using AsyncLocalStorage
    9. Example: Per-request store
    10. 8. Tracking Request Context
    11. 9. Debugging Async Operations
    12. 10. Understanding Performance Implications

  46. Optimizing Performance

    1. 1. Using Streams Over Buffers
    2. 2. Avoiding Synchronous Operations
    3. 3. Using Worker Threads for CPU-Bound Tasks
    4. 4. Implementing Caching
    5. 5. Using Connection Pooling
    6. 6. Optimizing Garbage Collection
    7. 7. Reducing Memory Footprint
    8. 8. Using HTTP/2 and HTTP/3
    9. 9. Compressing Responses (gzip, brotli)
    10. Example: Express
    11. 10. Optimizing JSON Operations
    12. 11. Using Native Modules When Beneficial
    13. 12. Profiling and Benchmarking

  47. Implementing Security Best Practices

    1. 1. Validating User Input
    2. 2. Sanitizing Input (preventing XSS)
    3. 3. Preventing SQL Injection
    4. Example: Parameterized query
    5. 4. Using Prepared Statements
    6. 5. Implementing Authentication
    7. 6. Implementing Authorization
    8. 7. Using HTTPS
    9. 8. Implementing Rate Limiting
    10. 9. Using Helmet for Security Headers
    11. Example
    12. 10. Preventing CSRF
    13. 11. Securing Dependencies (npm audit)
    14. 12. Using Permission Model (--permission flag)

  48. Working with Native Addons

    1. 1. Understanding N-API (Node-API)
    2. 2. Creating C++ Addons
    3. Example: hello.cc
    4. 3. Using node-gyp
    5. 4. Building Native Modules
    6. 5. Loading Native Modules
    7. Example
    8. 6. Using node-addon-api
    9. 7. Cross-Platform Compilation
    10. 8. Debugging Native Code
    11. 9. Performance Considerations
    12. 10. Alternatives (WebAssembly)

  49. Working with Internationalization (Intl)

    1. 1. Formatting Numbers (Intl.NumberFormat)
    2. Example
    3. 2. Formatting Dates (Intl.DateTimeFormat)
    4. Example
    5. 3. Formatting Currencies
    6. 4. Comparing Strings (Intl.Collator)
    7. Example
    8. 5. Pluralization (Intl.PluralRules)
    9. Example
    10. 6. Relative Time (Intl.RelativeTimeFormat)
    11. Example
    12. 7. List Formatting (Intl.ListFormat)
    13. Example
    14. 8. Display Names (Intl.DisplayNames)
    15. Example
    16. 9. Locale Negotiation
    17. 10. Loading ICU Data (--with-intl)

  50. Using TypeScript with Node.js

    1. 1. Setting Up TypeScript
    2. 2. Configuring tsconfig.json
    3. Example
    4. 3. Using ts-node
    5. 4. Using tsx for Fast Execution
    6. 5. Type Definitions (@types/node)
    7. 6. Compiling TypeScript
    8. 7. Using TypeScript with ESM
    9. 8. Type Checking Without Compilation
    10. 9. Using TypeScript Decorators
    11. 10. Debugging TypeScript

  51. Using Modern Node.js Features

    1. 1. Native Fetch API
    2. Example
    3. 2. Top-Level Await
    4. Example: only in ESM
    5. 3. Import Assertions / Attributes
    6. Example: Import Attributes
    7. 4. Web Streams API
    8. Example: ReadableStream → fetch upload
    9. 5. AbortController and AbortSignal
    10. Example
    11. 6. structuredClone
    12. Example
    13. 7. Test Runner (node:test)
    14. Example
    15. 8. Watch Mode (--watch)
    16. 9. Built-In WebSocket Client
    17. Example
    18. 10. REPL Enhancements
    19. Bonus: Single Executable Apps (node:sea)
    20. Build Workflow