Interview Questions
React.memo is a higher-order component that memoizes functional components to prevent unnecessary re-renders. It performs a shallow comparison of props and only re-renders if props have changed, improving performance by reducing render cycles for components with stable props.
FlatList is optimized for long lists by implementing windowing, which only renders items currently visible on screen. It provides better performance than ScrollView for long lists by recycling DOM elements and managing memory efficiently.
The bridge serializes data between JavaScript and native code, which can impact performance when sending large amounts of data. Minimizing bridge traffic by batching updates and reducing unnecessary communication improves app performance.
Hermes is a JavaScript engine optimized for React Native that improves start-up time, reduces memory usage, and decreases app size. It provides better performance than traditional JavaScript engines through ahead-of-time compilation and optimized bytecode.
Image optimization includes using proper image sizes, implementing lazy loading, caching images, using FastImage component for better performance, and implementing progressive loading for large images. Also consider using image compression and proper formats.
useCallback memoizes functions to prevent unnecessary recreation between renders. It's particularly useful when passing callbacks to optimized child components that rely on reference equality to prevent unnecessary renders.
console.log statements can significantly impact performance in production by creating unnecessary bridge traffic. They should be removed or disabled in production builds using babel plugins or proper configuration.
useMemo memoizes computed values to prevent expensive recalculations on every render. It's useful for optimizing performance when dealing with complex calculations or data transformations that don't need to be recomputed unless dependencies change.
Bundle size can be reduced by removing unused dependencies, implementing code splitting, using ProGuard/R8 for Android, enabling Hermes, implementing tree shaking, and properly configuring the Metro bundler.
PureComponent implements shouldComponentUpdate with a shallow prop and state comparison, preventing unnecessary renders. It's useful for optimizing class components when you know that shallow comparison is sufficient for determining updates.
FlatList optimization includes: 1) Using getItemLayout to avoid measurement, 2) Implementing proper key extraction, 3) Using removeClippedSubviews, 4) Optimizing renderItem with memo, 5) Adjusting windowSize and maxToRenderPerBatch, 6) Implementing proper item height calculations.
Bridge traffic can be reduced by: 1) Batching updates, 2) Minimizing state updates, 3) Using native modules for heavy computations, 4) Implementing proper data serialization, 5) Using Hermes engine, 6) Optimizing image loading and processing.
Efficient animations involve: 1) Using native driver when possible, 2) Implementing proper interpolation, 3) Using layoutAnimation for simple layouts, 4) Optimizing gesture handling, 5) Managing animation memory usage, 6) Using proper timing functions.
Memory management includes: 1) Proper cleanup in useEffect, 2) Removing event listeners, 3) Clearing timeouts and intervals, 4) Implementing proper image caching, 5) Managing large data structures, 6) Monitoring memory leaks.
Network optimization includes: 1) Implementing proper caching, 2) Using request batching, 3) Implementing retry logic, 4) Optimizing payload size, 5) Using proper compression, 6) Implementing offline support, 7) Managing concurrent requests.
Dependencies impact includes: 1) Bundle size increase, 2) Startup time effects, 3) Runtime performance overhead, 4) Memory usage implications, 5) Bridge traffic increase. Proper dependency management and auditing is crucial.
Efficient state management involves: 1) Proper state structure, 2) Minimizing state updates, 3) Using appropriate state management tools, 4) Implementing proper memoization, 5) Managing state persistence efficiently.
Startup optimization includes: 1) Using Hermes engine, 2) Implementing proper code splitting, 3) Optimizing native module initialization, 4) Managing asset loading, 5) Implementing proper splash screen, 6) Reducing initial bundle size.
Layout optimization includes: 1) Using LayoutAnimation properly, 2) Minimizing layout depth, 3) Implementing proper flex layouts, 4) Managing dynamic layouts efficiently, 5) Using proper measurement techniques.
Profiling techniques include: 1) Using React DevTools, 2) Implementing performance monitoring, 3) Using native profiling tools, 4) Analyzing bridge traffic, 5) Monitoring memory usage, 6) Implementing proper logging.
Large-scale optimization involves: 1) Implementing proper architecture, 2) Code splitting strategies, 3) Performance monitoring systems, 4) Efficient state management, 5) Proper resource management, 6) Optimization automation.
Native module optimization includes: 1) Proper thread management, 2) Efficient data serialization, 3) Batch processing implementation, 4) Memory management strategies, 5) Proper error handling, 6) Performance benchmarking.
Data virtualization involves: 1) Implementing windowing techniques, 2) Managing data chunks, 3) Implementing efficient scrolling, 4) Memory management strategies, 5) Optimizing render performance, 6) Handling large datasets.
Offline optimization includes: 1) Efficient data synchronization, 2) State persistence strategies, 3) Conflict resolution handling, 4) Resource management, 5) Background processing optimization, 6) Storage optimization.
Performance monitoring includes: 1) Metric collection implementation, 2) Analysis system setup, 3) Alert mechanism creation, 4) Performance tracking automation, 5) Reporting system implementation, 6) Optimization feedback loops.
AR/VR optimization includes: 1) Efficient render pipeline, 2) Asset management strategies, 3) Frame rate optimization, 4) Memory usage management, 5) Thread management, 6) Native integration optimization.
Testing automation includes: 1) Performance benchmark setup, 2) Continuous monitoring implementation, 3) Regression testing strategies, 4) Automated optimization verification, 5) Performance metric tracking, 6) Test environment management.
Multi-window optimization includes: 1) Resource sharing strategies, 2) State synchronization optimization, 3) Memory management approaches, 4) Process communication efficiency, 5) UI thread management, 6) Context switching optimization.