Which keyword is used to export multiple things from a module in JavaScript?
- import
- export
- require
- module
In JavaScript, the export keyword is used to export multiple things from a module. It allows you to specify which functions, objects, or variables should be accessible from outside the module. The import keyword is used for importing from modules, not exporting. The require and module keywords are used in CommonJS, a different module system.
How does JavaScript handle circular dependencies between modules?
- JavaScript throws an error and does not allow circular dependencies.
- JavaScript allows circular dependencies, and they are resolved at runtime.
- JavaScript handles circular dependencies by allowing them but ensuring that each module loads only once.
- Circular dependencies are not supported in JavaScript.
JavaScript allows circular dependencies, but it ensures that each module is only executed once. This is achieved through a mechanism called "module caching."
When handling errors in an async function, if an error is not caught within the function, it will cause the returned Promise to be in a ________ state.
- Pending
- Fulfilled
- Rejected
- Completed
When an uncaught error occurs in an async function, the returned Promise will be in a "Rejected" state. In the Promise lifecycle, it can start as "Pending," move to "Fulfilled" upon success, or "Rejected" upon an error.
Why would you use the global object to store data in a Node.js application?
- To share data between different Node.js modules.
- To encapsulate data and prevent it from being accessed globally.
- To improve application performance by reducing memory usage.
- To ensure data persistence across application runs.
The global object in Node.js can be used to store data that needs to be shared between different Node.js modules. It acts as a global namespace for variables and allows you to share data across different parts of your application. The other options do not accurately describe the common use case for the global object.
How does semantic versioning handle pre-release versions and build metadata?
- Pre-release versions are denoted with a hyphen and can include additional labels and numbers. Build metadata is indicated with a plus sign.
- Pre-release versions use square brackets to specify additional labels, and build metadata uses parentheses.
- Pre-release versions are marked with a plus sign, and build metadata is indicated with a hyphen.
- Pre-release versions are not supported in semantic versioning.
Semantic versioning allows pre-release versions to be denoted with a hyphen, followed by additional labels and numbers, and build metadata is indicated with a plus sign. This is essential for managing versions during development and testing phases.
When implementing JWT, where is the token commonly stored for subsequent requests?
- In a cookie
- In a URL query parameter
- In a request header
- In a hidden form field
In JWT (JSON Web Tokens), the token is commonly stored in a request header, specifically in the Authorization header using the Bearer scheme. This method is considered secure and widely adopted. Storing the token in a cookie or URL query parameter can have security risks.
What is the significance of a returned inner function having access to the outer function's variables even after the outer function has executed?
- It's a programming error and should be avoided.
- It has no significance; it's just a quirk of JavaScript.
- It allows data encapsulation and creates private variables, aiding in maintaining state and data privacy.
- It has no practical use in JavaScript.
The significance of a returned inner function having access to the outer function's variables after the outer function has executed is that it enables data encapsulation and the creation of private variables. This is crucial for maintaining state and data privacy in JavaScript applications.
When are CORS preflight requests sent by the browser?
- Before making certain types of requests
- After a successful request
- Randomly to check server compatibility
- Only when cookies are involved
CORS preflight requests are sent by the browser before making certain types of requests, specifically those that could have an impact on server security or state. These preflight requests are used to check with the server if the actual request (e.g., a cross-origin POST request with custom headers) is allowed, ensuring server compatibility and security.
You are working on a Node.js project with a team, and you notice that the package-lock.json file is frequently causing merge conflicts. How would you resolve or minimize such conflicts while ensuring consistent dependency resolution?
- Remove the package-lock.json file entirely
- Use Yarn instead of npm
- Use a tool like npm ci and enforce it in your team's workflow
- Manually edit the package-lock.json file in case of conflicts
To minimize package-lock.json merge conflicts, you should use a tool like npm ci in your team's workflow. npm ci installs dependencies based on the package-lock.json and ensures consistent dependency resolution. Options 1 and 2 are not recommended, and option 4 is not a practical solution.
What is the difference between chaining multiple .then() methods and using multiple await expressions?
- Chaining .then() is more efficient for error handling
- Chaining .then() is better for readability
- Using multiple await expressions allows better error propagation
- Using multiple await expressions guarantees faster execution
When using await expressions, errors can be propagated using standard try/catch blocks, which allows for more granular and flexible error handling. Chaining multiple .then() methods can lead to less readable and maintainable code when dealing with multiple asynchronous operations. It's not a question of efficiency or speed but rather about readability and error handling.