Asynchronous JavaScript

  1. Async/Await Syntax
    1. Introduction to async and await
      1. Syntactic Sugar over Promises
        1. Improving Readability
          1. Historical Context and Adoption
          2. The async Keyword
            1. Defining an Asynchronous Function
              1. Syntax and Examples
                1. Function Declarations vs. Expressions
                2. Implicit Return of a Promise
                  1. Behavior of Return Values
                    1. Automatic Promise Wrapping
                    2. async Arrow Functions
                      1. Syntax Variations
                    3. The await Keyword
                      1. Pausing Function Execution
                        1. Suspending Until Promise Settles
                          1. Non-Blocking Nature
                          2. Unwrapping the Fulfilled Value of a Promise
                            1. Value Extraction
                              1. Type Conversion
                              2. Usage Restrictions
                                1. Within async Functions
                                  1. Top-Level await Exceptions
                                  2. await with Non-Promise Values
                                    1. Immediate Resolution
                                  3. Error Handling with try...catch
                                    1. Synchronous-style Error Handling
                                      1. Using try...catch with await
                                        1. Block-Level Error Handling
                                        2. Handling Rejected Promises
                                          1. Catching Errors from Awaited Promises
                                            1. Error Object Properties
                                            2. Best Practices for Error Handling
                                              1. Granular vs. Centralized Error Handling
                                                1. Error Recovery Strategies
                                              2. async/await vs. Promise Chains
                                                1. Code Structure Comparison
                                                  1. Readability and Maintainability
                                                    1. Linear vs. Chained Flow
                                                    2. Readability and Debugging Benefits
                                                      1. Stack Traces and Error Locations
                                                        1. Debugging Tools Support
                                                        2. Performance Considerations
                                                          1. Memory Usage
                                                            1. Execution Speed
                                                          2. Top-Level await
                                                            1. Using await in Modules
                                                              1. Module Scope Usage
                                                                1. ES2022 Feature
                                                                2. Module Loading Implications
                                                                  1. Blocking Module Execution
                                                                    1. Dependency Resolution
                                                                    2. Limitations and Use Cases
                                                                      1. Browser Support
                                                                        1. Build Tool Considerations

                                                                    Previous

                                                                    3. The Promise API

                                                                    Go to top

                                                                    Next

                                                                    5. Common Asynchronous Web APIs