Where should you ideally store your static files like images, CSS, and JavaScript in an Express.js project?

  • In the project root directory
  • In a dedicated static directory
  • Inside the node_modules directory
  • In a separate database
In an Express.js project, it's a best practice to store your static files like images, CSS, and JavaScript in a dedicated static directory. This helps organize your project and makes it clear which files are intended to be served statically. Storing them in the project root, node_modules, or a database is not a recommended practice for serving static files.

The 'highWaterMark' option in Node.js streams denotes the ______ of the internal buffer.

  • size
  • rate
  • capacity
  • length
In Node.js streams, the 'highWaterMark' option denotes the capacity of the internal buffer. This value determines how much data the stream can buffer before it starts to pause the data source.

You are managing a project with multiple dependencies, and you want to ensure that upgrading a dependency doesn't break the project due to API changes. How would you specify the version numbers of the dependencies in the package.json file?

  • ^1.0.0
  • ~1.0.0
  • 1.0.0
  • 1.x.x
To ensure that only patch-level changes are allowed for your dependencies, you should use the ~ (tilde) prefix. This will allow for bug fixes (patch versions) but prevent breaking changes (minor or major versions).

To handle uncaught exceptions in a Node.js application, you can use process.on('______', callback).

  • unhandledRejection
  • process.error
  • exception
In Node.js, you can handle uncaught exceptions by using the process.on('unhandledRejection', callback) event. This allows you to capture unhandled promise rejections and take appropriate actions.

You are building a game where a player must answer a series of questions. How would you structure the control flow to handle the player’s responses and determine the next action or question based on the response?

  • if...else if...else statements
  • switch statement
  • try...catch statements
  • while loop
To handle the player's responses and determine the next action or question based on the response in a game, you would typically use a series of if...else if...else statements. These conditional statements allow you to evaluate multiple conditions and execute corresponding code blocks based on the player's response. The switch statement can also be used, but it's better suited for cases where you need to match a single value to multiple possible cases. try...catch is used for error handling, and a while loop is generally not suitable for handling player responses in this context.

What is the role of the extends property in an ESLint configuration file?

  • It specifies the file extensions to be linted.
  • It extends the code editor with ESLint features.
  • It defines the list of plugins to use.
  • It inherits configurations from other configurations.
The extends property in an ESLint configuration file allows you to inherit configurations from other configurations. It's a way to reuse or build upon existing ESLint configurations, making it easier to enforce consistent coding standards across projects.

When an error occurs in Node.js, the error object is typically an instance of __________.

  • Error
  • Exception
  • ErrorObject
  • Err
In Node.js, when an error occurs, the error object is typically an instance of the built-in Error object. This object contains valuable information about the error, such as a message and a stack trace.

Which data type in JavaScript can be used to store a sequence of characters?

  • char
  • sequence
  • string
  • text
In JavaScript, the string data type is used to store a sequence of characters. The char data type doesn't exist in JavaScript, and neither sequence nor text are valid data types for this purpose.

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.

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.

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.

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."