Interview Questions
Array.map() creates a new array with transformed elements, returning the result of applying a function to each element. In contrast, forEach() executes a function for each element but returns undefined, primarily used for side effects. Map preserves array length and maintains a one-to-one relationship with elements, making it ideal for data transformation. Consider performance implications for large arrays and memory usage when choosing between them.
reduce() processes array elements from left to right, while reduceRight() processes from right to left. Both methods take an accumulator and current value, combining elements into a single result. They're useful for sum calculations, object transformations, and array flattening. Consider initial value provision to avoid type errors and unexpected results with empty arrays. The direction matters particularly when order affects the result, such as string concatenation or mathematical operations.
slice() creates a shallow copy of array portion without modifying the original array, taking start and end indices. splice() modifies the original array by removing, replacing, or adding elements, returning removed elements. slice() is used for array copying and extraction, while splice() is for array mutation. Consider immutability requirements when choosing between them. splice() changes array length and indices, requiring careful handling in iterations.
Array.find() returns first matching element, while filter() returns all matching elements. For sorted arrays, consider binary search implementation for better performance. indexOf() and includes() check element existence. For complex objects, use custom comparison functions. Consider performance implications with large arrays and implement proper indexing strategies for frequent searches.
Use immutable methods (map, filter, reduce) for data transformation. Implement proper error handling for array operations. Consider performance with large arrays. Use appropriate array methods instead of loops when possible. Handle sparse arrays and holes appropriately. Maintain type consistency within arrays. Document array structure and element requirements.
Array.sort() accepts comparison function returning negative, zero, or positive values. Implement stable sorting for consistent results. Handle special values (null, undefined) appropriately. Consider case sensitivity and locale-specific sorting. Document comparison logic and requirements. Implement proper error handling for invalid comparisons.
Typed arrays provide fixed-length arrays of specific numeric types. Used for binary data manipulation, WebGL, and performance-critical operations. Consider memory usage and numeric precision requirements. Handle endianness appropriately. Implement proper bounds checking and type conversion. Document data format requirements.
Use Set object for simple value deduplication. Implement custom comparison for objects. Consider memory usage with large arrays. Handle reference equality vs value equality appropriately. Implement efficient algorithms for complex objects. Document deduplication criteria and requirements.
WeakMap and WeakSet hold weak references to objects, allowing garbage collection of keys. Used for private data storage, caching, and memory-sensitive operations. Consider garbage collection implications. Handle key object lifecycle properly. Implement proper cleanup strategies. Document memory management requirements.
Use Array.flat() or reduce() for nested array flattening. Consider depth of nesting and performance implications. Handle circular references appropriately. Implement custom flattening for complex structures. Document flattening depth requirements. Handle special cases and error conditions.
Pre-allocate array size when possible. Use appropriate array methods for operations. Consider memory usage and garbage collection. Implement proper caching strategies. Handle large array operations efficiently. Document performance requirements and constraints. Monitor array operation performance.
Check array bounds before access. Handle undefined and null values appropriately. Implement type checking for array operations. Consider error recovery strategies. Document error conditions and handling. Implement proper validation for array modifications.
Array-like objects have length property and indexed elements but lack array methods. Convert to arrays using Array.from() or spread operator. Consider performance implications of conversion. Handle proper method delegation. Document array-like object requirements. Implement proper type checking.
Choose appropriate iteration method (for...of, forEach, map). Consider performance requirements and use case. Handle early termination properly. Implement proper error handling during traversal. Document traversal requirements. Monitor traversal performance.
Consider holes in array iteration. Use appropriate methods for sparse array operations. Handle undefined values properly. Implement proper array compaction when needed. Document sparse array handling requirements. Consider performance implications.
Use spread operator or slice() for shallow copy. Implement deep cloning for nested structures. Handle circular references appropriately. Consider performance implications of deep cloning. Document cloning requirements. Implement proper validation.
Release references to unused arrays. Handle large array cleanup properly. Consider garbage collection implications. Implement proper array reuse strategies. Document memory management requirements. Monitor memory usage patterns.
Use appropriate comparison methods for element types. Handle object comparison properly. Implement custom comparison functions when needed. Consider performance implications. Document comparison requirements. Handle special values appropriately.
Implement efficient chunking algorithms. Handle remainder elements properly. Consider memory usage with large arrays. Implement proper validation. Document chunking requirements. Handle edge cases appropriately.
Use appropriate locking mechanisms. Handle race conditions properly. Implement proper synchronization. Consider performance implications. Document concurrency requirements. Handle error conditions appropriately.
Use appropriate serialization format. Handle circular references. Implement proper type conversion. Consider performance implications. Document serialization requirements. Handle error conditions appropriately.
Use reduce() for grouping operations. Implement proper key generation. Handle edge cases appropriately. Consider performance implications. Document grouping requirements. Implement proper validation.
Use Set for unique values. Implement efficient algorithms. Handle object comparison properly. Consider performance implications. Document set operation requirements. Handle edge cases appropriately.
Use destructuring assignment for simple swaps. Handle index validation properly. Implement efficient algorithms. Consider performance implications. Document swapping requirements. Handle error conditions appropriately.
Use stable sorting algorithms when needed. Handle special values properly. Consider performance implications. Implement proper comparison functions. Document stability requirements. Handle edge cases appropriately.
Use Fisher-Yates algorithm for unbiased shuffling. Implement proper randomization. Consider performance implications. Document shuffling requirements. Handle edge cases appropriately. Implement validation.
Implement efficient rotation algorithms. Handle different rotation directions. Consider performance implications. Document rotation requirements. Handle edge cases appropriately. Implement proper validation.
Implement proper index validation. Handle negative indices appropriately. Consider performance implications. Document boundary requirements. Handle error conditions appropriately. Implement proper error messages.
Use Set for primitive values. Implement custom comparison for objects. Consider performance implications. Document uniqueness requirements. Handle edge cases appropriately. Implement proper validation.