What is the initial state of a JavaScript Promise when it is created?
- Pending
- Resolved
- Rejected
- Settled
When a Promise is created, it starts in the "Pending" state. This means that the Promise is neither fulfilled nor rejected. It's essentially in a pending state until the asynchronous operation it represents is completed.
In an async function, what happens to unhandled exceptions?
- They are automatically caught by the global error handler
- They cause the program to crash immediately
- They propagate to the nearest catch block
- They result in an unhandled promise rejection
Unhandled exceptions in an async function result in unhandled promise rejections. This can lead to unexpected behavior or crashes if not properly addressed. It's crucial to handle errors appropriately in async functions to ensure robust and error-resistant code.
In a project where a class needs to incorporate event-handling, logging, and validation behaviors, how would mixins and composition be used?
- By using inheritance and overriding methods in the class.
- By applying mixins through multiple inheritance.
- By using composition and creating separate classes for each behavior, then combining them.
- By using mixins and composing them into the class.
Mixins in ES6 can be applied by creating separate modules for each behavior (event-handling, logging, validation) and then composing these mixins into the class. This promotes code reusability and maintainability.
The __________ is responsible for executing the code, collecting and processing events, and executing queued sub-tasks.
- Callback Queue
- Event Loop
- Promise
- Closure
The Event Loop is a crucial part of JavaScript's concurrency model. It continuously checks the Call Stack and Callback Queue, ensuring the non-blocking execution of code.
When the call stack is busy, new requests get queued in the __________ for their turn to be processed.
- Callback Queue
- Microtask Queue
- Event Loop
- Task Queue
The correct option is Task Queue. When the call stack is occupied, new tasks are placed in the task queue to await their turn. The Event Loop manages the process of moving tasks from the task queue to the call stack. Understanding this mechanism is crucial for handling asynchronous operations effectively.
To re-export all named exports from a module, use export * from _________.
- export * from 'moduleName';
- export all from 'moduleName';
- export {all} from 'moduleName';
- export named from 'moduleName';
To re-export all named exports from a module in ES6, you use the export * from 'moduleName'; syntax. This allows you to export all the named exports from one module to another without listing them individually.
Q1: Imagine you are creating a caching mechanism for a web application. Would you choose a WeakMap or a Map for storing cached data and why?
- WeakMap
- Map
- Both WeakMap and Map
- Neither WeakMap nor Map
In a caching mechanism, using a WeakMap is preferred over a Map. This is because a WeakMap allows the keys to be garbage collected if there are no other references to them, which is beneficial for caching scenarios where you want the cached data to be automatically cleared when the corresponding objects are no longer in use. A Map, on the other hand, would retain the keys even if they are not needed anymore, leading to potential memory leaks in a caching context.
How does the call stack in JavaScript relate to the concept of 'blocking'?
- It represents the order of function calls
- It handles asynchronous tasks
- It causes delays in code execution
- It manages the memory allocation
The call stack in JavaScript tracks the execution of functions. When a function is called, it's added to the stack, and when it returns, it's removed. Blocking occurs when a function takes a long time to execute, causing subsequent code to wait. Understanding this helps optimize code for performance.
Is it possible to create a shared Symbol that is accessible across different parts of your code?
- No, Symbols are always local to the scope they are created
- Yes, Symbols can be shared globally
- Only if Symbols are declared as constants
- Symbols can only be shared within the same function
Symbols can be shared globally by using the Symbol.for() method, which creates a shared Symbol registry accessible across different parts of your code. This promotes consistency and reusability.
In ES6 Modules, imports and exports must be ________, unlike in CommonJS where they can be dynamic.
- Explicit
- Implicit
- Dynamic
- Conditional
In ES6 modules, imports and exports must be explicit, meaning they are statically determined at compile-time. This allows for better tooling support and optimizations. CommonJS, on the other hand, allows dynamic imports and exports.