In a scenario where a function calculates the total price of items in a cart, how would making this function pure affect its implementation?
- It would introduce side effects
- It would improve testability and predictability
- It would slow down the function execution
- It would require additional dependencies
Making the function pure in this scenario would involve removing external dependencies and ensuring that the function's output depends only on its input. This enhances testability and predictability, making the function easier to reason about and test in isolation. It also helps in avoiding side effects, which is a key characteristic of pure functions.
Can you reassign a new array or object to a variable declared with const?
- Yes, always
- Yes, but with restrictions
- No, it will result in an error
- Only if the variable is declared as a global constant
Variables declared with const cannot be reassigned to a new reference, whether it's an array, object, or any other data type. However, it's crucial to understand that this rule applies only to the reference itself, not the content of the variable. The content, if mutable (e.g., an object's properties), can still be modified.
How are imports and exports handled differently in ES6 Modules compared to CommonJS?
- Explicit import and export statements
- Automatic global binding
- Using require and module.exports
- Implicit import and export statements
In ES6 Modules, imports and exports are explicit, and you use import and export statements to define dependencies. This is different from CommonJS, where dependencies are managed using require and module.exports.
How do you import a specific function from a module in ES6?
- import myFunction from 'module';
- import { myFunction } from 'module';
- import * as myFunction from 'module';
- import myFunction as 'module';
To import a specific function from a module in ES6, you use the syntax import { myFunction } from 'module';. This allows you to bring in only the functions or variables you need rather than the entire module.
How does recursion differ from iteration in JavaScript?
- Recursion is more memory-efficient
- Recursion uses a stack, while iteration uses a loop
- Recursion is slower than iteration
- Recursion is not supported in JavaScript
Recursion involves a function calling itself, creating a stack of function calls. In contrast, iteration uses loops for repetitive tasks. Understanding these differences is essential in choosing the right approach.
A common use case for currying is to create more _________ versions of existing functions.
- Specialized, Generalized, Efficient, Complex
- Efficient, Complex, Generalized, Specialized
- Complex, Generalized, Specialized, Efficient
- Specialized, Efficient, Generalized, Complex
Currying allows the creation of more generalized versions of functions. By partially applying arguments, you can reuse and specialize functions for various scenarios.
Is it possible to declare a variable with let or const in a for-loop and access it outside of the loop?
- Yes, you can access it outside the loop
- No, it's not accessible outside the loop
- Only let variables are accessible
- Only const variables are accessible
Variables declared with let or const in a for-loop are accessible outside of the loop in which they are declared. They have block scope, which means they are confined to the nearest enclosing curly braces, allowing them to be accessed outside the loop.
Given a large project that requires conditional loading of modules based on runtime conditions, which module system would you prefer, ES6 Modules or CommonJS, and why?
- ES6 Modules
- CommonJS
- Both are equally suitable
- Depends on the project requirements
In a large project with conditional module loading, ES6 Modules offer advantages such as static analysis during the build process, enabling more efficient tree shaking and minimizing unused code. CommonJS, being synchronous, might introduce delays in loading modules, making it less suitable for dynamic scenarios.
What is the main difference between higher-order functions and callbacks?
- Higher-order functions take functions as arguments, while callbacks are functions passed as arguments.
- Callbacks are used only in asynchronous operations.
- Higher-order functions always return a value.
- Callbacks can only be anonymous functions.
Higher-order functions are functions that take other functions as arguments, offering flexibility, while callbacks are simply functions passed as arguments to other functions.
The _________ method executes a provided function once for each array element.
- forEach
- map
- filter
- reduce
The correct answer is forEach. This method iterates over each element in an array and executes a provided function once for each element. It is commonly used for tasks like logging, updating values, or performing side effects.