When performing CRUD operations on a database, which operation can be the most expensive in terms of performance?
- Create
- Read
- Update
- Delete
Among CRUD operations, "Update" can often be the most expensive in terms of performance. This is because updating records may require the database to search for the existing record, make changes, and write the updated data back to disk, which can be resource-intensive. Read operations are typically less expensive.
When a Promise is pending and neither fulfilled nor rejected, it is in the ________ state.
- awaiting
- undefined
- completed
- idle
When a Promise is pending and hasn't been resolved or rejected, it is in the "awaiting" state. This is the initial state of a Promise before it is settled.
What are the best practices for error handling in a large-scale Node.js application?
- Avoiding error handling altogether for performance reasons.
- Using global error handlers for unhandled errors.
- Handling errors at the lowest level of code execution.
- Logging errors but not taking any action.
In large-scale Node.js applications, best practices for error handling include handling errors at the lowest level of code execution, close to where they occur. This improves code maintainability and makes it easier to trace the source of errors. Avoiding error handling for performance reasons is a bad practice. Using global error handlers is suitable for unhandled errors, but it's essential to handle errors at the source first. Simply logging errors without taking corrective action is incomplete error handling.
You are building a RESTful API with Express to serve a mobile application. The mobile development team has asked for the ability to retrieve condensed responses to minimize data usage. How would you accommodate this request while maintaining the integrity of your API?
- Create separate endpoints for condensed and full responses.
- Use query parameters to allow clients to specify the response format.
- Disable compression to send smaller payloads.
- Use WebSocket instead of REST for real-time updates.
Using query parameters to allow clients to specify the response format is a common and RESTful approach to accommodating different client needs. Creating separate endpoints for each format can lead to redundancy and maintenance challenges. Disabling compression would likely increase, not decrease, data usage. Using WebSockets is for real-time communication and doesn't directly address response format concerns.
In what scenario would using Domain API be beneficial for error handling in Node.js?
- When handling HTTP requests in Express.js.
- When handling file I/O operations.
- When creating a RESTful API.
- When dealing with database connections.
The Domain API was deprecated in Node.js and is no longer recommended for use. It was originally designed to handle errors in scenarios like file I/O operations. However, it has been deprecated because it didn't provide a robust solution for error handling, and other mechanisms like try...catch and event listeners have become more standard for handling errors in modern Node.js applications. Using it is not advisable in any scenario.
When designing systems with Non-Blocking I/O, careful consideration must be given to avoid ________, where multiple asynchronous operations are competing for resources.
- Callback Hell
- Deadlock
- Blocking I/O
- Synchronous Execution
When designing systems with Non-Blocking I/O, careful consideration must be given to avoid "Callback Hell," also known as "Callback Pyramid" or "Callback Spaghetti." This occurs when multiple asynchronous operations are nested deeply, making code difficult to read and maintain.
How can you implement template inheritance in Pug?
- extend layout.pug
- include layout.pug
- inherit layout.pug
- template layout.pug
In Pug, template inheritance is implemented using the extend keyword followed by the name of the layout file. This allows child templates to inherit the structure and content of the specified layout file. The other options (include, inherit, and template) are not used for template inheritance in Pug.
How can you optimize the performance of a SQL query that reads a large amount of data?
- Use indexes on columns frequently queried.
- Avoid joins and subqueries.
- Increase the page size of the database.
- Fetch all data at once to minimize network latency.
To optimize the performance of a SQL query reading large data, you should use indexes on columns frequently queried. Indexes improve data retrieval speed. The other options may not necessarily lead to performance improvements and can even degrade performance.
You are developing a Node.js application that should gracefully shut down when it receives a termination signal. How would you accomplish this using the process object?
- process.on('terminate', () => { /* Graceful shutdown code */ });
- process.kill('SIGTERM', process.pid);
- process.exit(0);
- process.handleTermination(() => { /* Graceful shutdown code */ });
To gracefully shut down a Node.js application upon receiving a termination signal, you should use process.on('terminate', () => { /* Graceful shutdown code */ });. This registers an event handler for the 'terminate' event. The other options either do not handle termination signals gracefully or are incorrect syntax.
You are tasked with implementing a secure authentication system for a web application. What considerations should you make to ensure the security of user credentials and session information?
- Store passwords in plain text
- Use a secure hashing algorithm for password storage
- Use HTTP for transmitting sensitive data
- Keep session tokens in local storage
To ensure the security of user credentials and session information, you should use a secure hashing algorithm (like bcrypt) to store passwords, not store them in plain text. Additionally, sensitive data should not be transmitted over HTTP, and session tokens should be stored securely (not in local storage, which is vulnerable to cross-site scripting attacks).