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).
In Node.js, the process.cwd() method returns the ________.
- current working directory
- home directory
- root directory
- parent directory
In Node.js, the process.cwd() method returns the current working directory of the Node.js process. This directory is the base directory from which the Node.js process was started.
You are building a real-time data processing system where tasks are dependent on the completion of previous tasks. How would you structure your Promises/async functions to ensure the sequence is maintained?
- Using async/await
- Using Promise.then()
- Using Promise.race()
- Using setTimeout()
To ensure the sequence of tasks is maintained in a real-time data processing system, you should structure your code using async/await. This allows you to write asynchronous code in a more synchronous style, ensuring that each task awaits the completion of the previous one. The other options are not typically used for sequential task execution.
Which method is used to attach a listener to an event in the Events module of Node.js?
- addListener()
- bindEvent()
- attachEvent()
- on()
To attach a listener to an event in the Events module of Node.js, you typically use the on() method. It's a common and standard way to register event handlers. Options A, B, and C are not commonly used for attaching listeners in Node.js.
How does npm handle version conflicts between dependencies and devDependencies?
- It prioritizes devDependencies over dependencies
- It prioritizes dependencies over devDependencies
- It raises a version conflict error
- It automatically resolves conflicts
npm prioritizes dependencies over devDependencies. If there's a version conflict between a package listed in dependencies and the same package listed in devDependencies, the version specified in dependencies takes precedence. This ensures that the application uses the expected versions during production deployment.
To implement an authorization mechanism in Express.js effectively, developers often use ______ to manage user roles and permissions.
- Passport.js
- Express Passport
- Sequelize
- Mongoose
To implement an authorization mechanism in Express.js effectively, developers often use Passport.js. Passport.js is a popular authentication middleware for Node.js that supports various authentication strategies and can be used to manage user roles and permissions effectively. Sequelize and Mongoose are libraries for working with databases and are not directly related to authorization in Express.js.
Which of the following is true about the prototype chain in JavaScript?
- The prototype chain allows access to properties and methods of an object's prototype and its prototype's prototype, forming a chain.
- The prototype chain only includes direct parent objects.
- The prototype chain is static and cannot be modified dynamically.
- The prototype chain is not used in JavaScript.
The prototype chain in JavaScript allows access to properties and methods of an object's prototype, its prototype's prototype, and so on, forming a chain. It is a fundamental concept in JavaScript's object-oriented programming.
In the context of closures, what is meant by the term 'lexical scoping' in JavaScript?
- Lexical scoping, also known as static scoping, means that the scope of a variable is determined by its position within the source code, and it is fixed at the time of the variable's definition. In JavaScript, closures have lexical scoping, which means they capture variables from the outer function based on where they are defined in the code, not where they are executed.
- Lexical scoping, also called static scoping, refers to the way variables are resolved in a program. In JavaScript closures, lexical scoping means that the scope of a variable is determined by its location in the source code, and it remains fixed once the function is defined.
- Lexical scoping, often referred to as static scoping, is a feature of closures in JavaScript. It means that a closure captures variables from its surrounding context based on their lexical location, not their runtime values. This allows closures to access variables even after the outer function has completed execution.
- In JavaScript closures, lexical scoping means that the scope of a variable is determined by its position in the code when the closure is defined, not when it is executed. This ensures that closures capture the correct variables from their enclosing scope.
Closures and Lexical Scoping
How can you create a deep copy of an object in JavaScript?
- JSON.parse(JSON.stringify(object))
- object.copy()
- deepCopy(object)
- Object.clone(object)
To create a deep copy of an object in JavaScript, you can use JSON.parse(JSON.stringify(object)). This method serializes the object to a JSON string and then parses it back into a new object, effectively creating a deep copy. The other options are not valid for deep copying objects.