📖 About this Domain
This domain focuses on identifying and resolving errors in client-side JavaScript within the Lightning Experience. It covers the use of browser developer tools and JavaScript language constructs to debug Lightning Web Components and Aura components effectively.
🎓 What You Will Learn
- Use browser developer tools to set breakpoints, inspect the DOM, and analyze network traffic for component debugging.
- Leverage the `console` object methods like `console.log()` and `console.error()` for runtime diagnostics in your code.
- Implement `try...catch` blocks for synchronous error handling and `.catch()` for asynchronous Promise rejections.
- Apply debugging strategies specific to the LWC and Aura component frameworks, including their lifecycle hooks.
🛠️ Skills You Will Build
- Troubleshoot JavaScript code to methodically isolate and fix bugs within Lightning components.
- Write defensive code by implementing structured error handling mechanisms to prevent component failures.
- Utilize browser profilers to diagnose and resolve client-side performance bottlenecks.
- Implement effective logging strategies to trace code execution and state changes for easier debugging.
💡 Top Tips to Prepare
- Master Chrome DevTools; practice stepping through code execution and inspecting component properties.
- Understand the difference between handling synchronous errors with `try...catch` and asynchronous errors with Promise `.catch()`.
- Enable Lightning Component Debug Mode in your Salesforce org to access unminified code and more descriptive error stacks.
- Practice handling and displaying errors returned from Apex controllers within your LWC JavaScript module.
📖 About this Domain
This domain covers the fundamentals of data storage and structure in JavaScript. You will demonstrate knowledge of variable declaration, scope, and hoisting. It also assesses your understanding of JavaScript's primitive and reference data types, and collections like Arrays and Maps.
🎓 What You Will Learn
- How to declare variables using let, const, and var, and describe their scope and hoisting behavior.
- The characteristics of primitive types versus reference types and how they are stored in memory.
- Methods to create, access, and iterate over collections like Array, Map, and Set.
- The process of serializing and deserializing data using JSON.stringify() and JSON.parse().
🛠️ Skills You Will Build
- Choosing the appropriate variable declaration to manage scope and prevent unintended side effects.
- Manipulating data collections efficiently using built-in methods like map(), filter(), and forEach().
- Structuring complex data using objects and arrays for component properties and attributes.
- Debugging issues related to type coercion and understanding the strict equality operator (===).
💡 Top Tips to Prepare
- Focus on the differences between let, const, and var, especially regarding block scope and hoisting.
- Practice common Array methods as they are critical for data manipulation in Lightning Web Components.
- Understand how pass-by-value for primitives and pass-by-reference for objects impacts function behavior.
- Memorize JavaScript's truthy and falsy values to accurately predict the flow of conditional statements.
📖 About this Domain
This domain covers JavaScript's single-threaded, non-blocking concurrency model. You will learn how the event loop, callback queue, and microtask queue manage asynchronous operations. Understanding this is critical for building responsive Lightning Web Components that perform server-side calls.
🎓 What You Will Learn
- Understand the JavaScript event loop and its role in handling asynchronous code execution.
- Learn to use Promises to manage operations that complete at a future time, including resolve and reject states.
- Master the async/await syntax for writing cleaner, more readable asynchronous logic.
- Differentiate between using the wire service and calling Apex imperatively for asynchronous data retrieval in LWC.
🛠️ Skills You Will Build
- Ability to write non-blocking code that fetches data from Salesforce without freezing the user interface.
- Skill in chaining multiple asynchronous operations together using Promises and async/await.
- Competency in implementing robust error handling for asynchronous calls using .catch() and try...catch blocks.
- Proficiency in managing multiple concurrent asynchronous requests efficiently with methods like Promise.all().
💡 Top Tips to Prepare
- Practice creating and consuming Promises to fully grasp their lifecycle and chaining with .then().
- Always wrap await calls within a try...catch block to handle potential promise rejections gracefully.
- Understand the difference between the microtask queue for Promises and the callback queue to predict execution order.
- Review how Lightning Data Service and imperative Apex calls return Promises in Lightning Web Components.
📖 About this Domain
This domain covers JavaScript execution outside the browser, focusing on the Node.js runtime environment. It assesses your knowledge of server-side concepts, modules, and asynchronous programming patterns. You will be tested on core Node.js APIs and the npm ecosystem.
🎓 What You Will Learn
- Understand the Node.js runtime, including the V8 engine, event loop, and its single-threaded, non-blocking I/O model.
- Utilize the CommonJS module system with `require()` and `module.exports` to structure server-side applications.
- Implement asynchronous JavaScript using callbacks, Promises, and async/await for handling operations like file I/O and HTTP requests.
- Manage project dependencies and run scripts using npm and the `package.json` manifest file.
🛠️ Skills You Will Build
- Ability to write and debug server-side scripts using core Node.js APIs.
- Proficiency in managing external packages and project dependencies via the npm CLI.
- Competency in handling asynchronous control flow for building scalable, non-blocking applications.
- Skill in creating and consuming modules to build modular and maintainable backend code.
💡 Top Tips to Prepare
- Focus on the event loop's phases and how it processes the callback queue for asynchronous operations.
- Practice using core Node.js modules like `fs`, `path`, and `http` to understand their asynchronous nature.
- Memorize the key properties and scripts within a `package.json` file, such as `dependencies` and `devDependencies`.
- Distinguish clearly between the CommonJS (`require`) and ES Module (`import`) syntax and their behavior in a Node.js context.
📖 About this Domain
This domain covers the core building blocks for structuring data and logic in JavaScript. It focuses on creating and manipulating objects, defining reusable logic with functions, and implementing object-oriented patterns using classes. These concepts are fundamental for developing Lightning Web Components.
🎓 What You Will Learn
- How to create objects using object literals, constructor functions, and the class syntax.
- The differences between function declarations, function expressions, and arrow functions, including the behavior of the 'this' keyword.
- How to use ES6 classes to define object blueprints with constructors, methods, getters, and setters.
- The principles of prototypal inheritance and how objects inherit properties and methods from a prototype chain.
🛠️ Skills You Will Build
- Ability to model complex data structures using JavaScript objects and their properties.
- Writing modular, reusable code by encapsulating logic within functions and classes.
- Implementing object-oriented programming (OOP) concepts like inheritance and encapsulation in a JavaScript context.
- Debugging scope and context issues related to the 'this' keyword within different function types.
💡 Top Tips to Prepare
- Master the four binding rules for the 'this' keyword, especially its lexical scoping in arrow functions.
- Practice creating objects using all three methods (literal, constructor, class) to understand their distinct use cases.
- Understand how the 'extends' keyword and 'super()' function work for class inheritance, as this mirrors LWC development.
- Review how to add methods and properties to an object's prototype directly versus within a constructor.
📖 About this Domain
This domain details JavaScript's role within the browser environment, focusing on the Document Object Model (DOM) and event handling. It covers how to programmatically interact with and manipulate web page content. Core topics include the DOM tree, browser events, and the event loop mechanism.
🎓 What You Will Learn
- You will learn to use the DOM API to query and manipulate HTML elements on a page.
- You will learn to register event listeners to handle user interactions like clicks and keyboard input.
- You will learn the mechanics of event propagation, including the capturing and bubbling phases.
- You will learn about the global Window object and its role in the browser's JavaScript runtime.
🛠️ Skills You Will Build
- You will build the skill to dynamically modify the DOM by creating, appending, and removing nodes.
- You will build the skill to implement event listeners and manage the event object to create interactive UIs.
- You will build the skill to control event flow using methods like `stopPropagation()` and `preventDefault()`.
- You will build the skill to work with browser APIs and understand the asynchronous nature of the event loop.
💡 Top Tips to Prepare
- Focus on DOM traversal methods like `querySelector` and properties like `children` and `parentElement`.
- Master the differences between `event.target` and `event.currentTarget` for precise event handling.
- Practice the event delegation pattern to efficiently manage events on multiple elements.
- Study diagrams of the event loop to understand how the call stack and callback queue interact.
📖 About this Domain
This domain covers unit testing for Lightning Web Components using the Jest framework. It emphasizes verifying component rendering, behavior, and event handling in an isolated, off-platform environment. The focus is on ensuring code quality and component reliability through automated tests.
🎓 What You Will Learn
- You will learn to write Jest test suites to validate the rendered DOM output of a Lightning Web Component.
- You will learn to test a component's public API, including its properties and methods, by manipulating its state.
- You will learn how to simulate user interactions, dispatch events, and verify the component's response.
- You will learn to mock Apex calls and module dependencies to isolate component logic for focused unit tests.
🛠️ Skills You Will Build
- You will build the skill to configure and run the sfdx-lwc-jest test runner from the command line.
- You will build the ability to write specific assertions to validate component output and behavior against expected results.
- You will build proficiency in debugging failed tests by analyzing error messages and component state.
- You will build the capability to test asynchronous operations and server-side interactions using Jest's mocking features.
💡 Top Tips to Prepare
- Master the Jest test structure, including describe(), it(), and lifecycle hooks like beforeEach().
- Practice creating component instances in tests using createElement and appending them to the test's DOM.
- Understand how to use jest.mock() to handle dependencies on Apex methods wired with @wire or called imperatively.
- Review the lwc-recipes sample repository for practical examples of Jest tests covering various component scenarios.
