Tree shaking is most effective when modules use _______ exports rather than wildcard exports.
- Named
- Default
- All
- Individual
Tree shaking is a technique in JavaScript used to eliminate unused code during the build process. When modules use named exports, it allows the bundler to selectively include only the functions or variables that are actually used, making tree shaking more effective. Default exports and wildcard exports can complicate this process, leading to less efficient tree shaking.
If an arrow function is written with a single expression, the return value is the result of the expression without using the ________ keyword.
- Break
- Return
- Yield
- Exit
In arrow functions, if the function body consists of a single expression, you can omit the curly braces {} and the return keyword. The return value will be the result of the expression automatically.
To access a parent class's method in a child class, the __________ keyword is used inside the method.
- super
- this
- parent
- extends
In JavaScript, the super keyword is used to refer to the parent class. When used inside a method in a child class, it allows you to call the corresponding method in the parent class. This is particularly useful for accessing and invoking the parent class's method from within the child class.
In terms of scope, how do variables and functions behave differently in ES6 Modules compared to CommonJS modules?
- Variables and functions have block scope
- Variables have block scope, functions have global scope
- Variables and functions have global scope
- Variables have global scope, functions have block scope
ES6 Modules introduce block scope for both variables and functions, offering better encapsulation. In contrast, CommonJS has function-level scope for variables and global scope for functions, leading to potential issues with variable leakage.
In a custom iterable, the next() method should return an object with two properties: value and ________.
- done
- index
- result
- previous
In a custom iterable, the next() method should return an object with two properties: value, representing the current value in the iteration, and done, a boolean indicating whether the iteration is complete.
How does the Fetch API handle HTTP error statuses (like 404 or 500) in Promises?
- It doesn't reject the Promise for any HTTP error status
- It rejects the Promise only for network errors
- It rejects the Promise for any non-2xx HTTP status
- It triggers a catch block for network errors and HTTP errors
The Fetch API rejects the Promise for any non-2xx HTTP status, allowing developers to handle errors more effectively. Network errors, however, are still caught separately, providing detailed error handling in both scenarios.
In a scenario where you need to process each character of a string for a text analysis function, which loop would you choose and why?
- for loop
- for...in loop
- forEach loop
- for...of loop
The correct option is the for...of loop. This loop is specifically designed for iterating over iterable objects, such as strings, arrays, and collections. It provides direct access to the values, making it suitable for processing each character of a string. Unlike the for loop, it abstracts away the index and simplifies the code for tasks like text analysis.
How does hoisting behavior differ between variables declared with let/const and those declared with var?
- Variables declared with var are hoisted to the top of their scope, while let/const variables are hoisted but not initialized.
- Variables declared with let/const are hoisted to the top of their scope, while var variables are hoisted but not initialized.
- Variables declared with let/const are not hoisted, while var variables are hoisted and initialized with undefined.
- Variables declared with var are not hoisted, while let/const variables are hoisted and initialized with undefined.
In JavaScript, variables declared with var are hoisted and initialized with undefined at the top of their scope, while let and const are hoisted but not initialized. Accessing a let/const variable before its declaration results in a ReferenceError.
What does the await keyword do inside an async function?
- Pauses the execution of the function until the Promise is resolved
- Executes the asynchronous code in parallel with the synchronous code
- Skips the asynchronous code and proceeds with the synchronous execution
- Forces the function to return immediately
The await keyword is used to pause the execution of an async function until the Promise being awaited is resolved, allowing asynchronous code to be written in a synchronous-like manner.
What are the implications of using await in top-level code (outside of any function)?
- Causes a syntax error
- Works as expected
- Results in unhandled promise rejection
- Has no effect
Using await outside of any function (at the top level) is not allowed and results in an unhandled promise rejection. The top-level code doesn't have the necessary structure to handle asynchronous operations using await. To use await, it should be inside an async function. Otherwise, it leads to unexpected behavior and unhandled promise rejections.