Interview Questions
Props (properties) are read-only data passed from parent to child components. They enable unidirectional data flow, making the application's data flow predictable and easier to debug. Props can include any JavaScript value including functions.
Prop drilling occurs when props are passed through multiple intermediate components that don't need them. Solutions include using Context API, state management libraries like Redux, component composition, or custom hooks to avoid excessive prop passing.
In functional components, use default parameters: function Component({prop = defaultValue}). In class components, use static defaultProps property. Default props ensure components work even when optional props aren't provided.
PropTypes provide runtime type checking for props. They help catch bugs by validating the types and presence of props. Example: Component.propTypes = { name: PropTypes.string.isRequired }. In TypeScript, use interfaces or types instead.
React uses one-way data flow, but two-way binding can be simulated by passing both a value prop and an onChange handler. Common in form inputs: <input value={value} onChange={e => setValue(e.target.value)} />.
Render props are functions passed as props that return React elements. They enable sharing behavior between components: <DataProvider render={data => <Display data={data} />}. This pattern allows for flexible component composition.
In class components, use componentDidUpdate to compare prevProps with current props. In functional components, use useEffect with prop dependencies to react to changes: useEffect(() => { /* handle prop change */ }, [prop]).
children is a special prop that contains the content between component tags. It enables component composition: <Container>{content}</Container>. Can be manipulated using React.Children utilities and supports any valid JSX.
Use PropTypes.shape() for objects, PropTypes.arrayOf() for arrays, and custom validators for complex validation. Example: PropTypes.shape({ id: PropTypes.number, items: PropTypes.arrayOf(PropTypes.object) }).
HOCs are functions that take a component and return an enhanced component. They can manipulate props, add new props, or handle prop-related logic. Important to properly forward props: {...props} to avoid prop isolation.
Use React.memo for functional components or PureComponent for class components to prevent unnecessary re-renders. Implement shouldComponentUpdate for custom comparison. Consider prop structure and reference equality.
Pass event handlers as props using arrow functions or bound methods. Consider performance implications of inline functions. Use callback refs for DOM element access. Maintain proper binding context.
Define interfaces or types for props: interface Props { name: string; age?: number; }. Use them in component definitions: const Component: React.FC<Props> = ({name, age}) => {}. TypeScript provides compile-time type safety.
Context provides a way to pass data through the component tree without explicit prop passing. Useful for global data like themes, user data, or locale. Components can consume context using useContext hook.
Pass loading states and error states as props along with data. Use promises or async/await in parent components. Consider implementing loading skeletons or error boundaries. Handle race conditions in updates.
Use descriptive names, follow consistent conventions, group related props, document prop types and requirements. Consider prop grouping for complex components. Use spread operator judiciously.
Controlled components receive values and handlers as props, while uncontrolled components manage internal state with refs. Choose based on need for form data access and validation requirements.
Compound components are related components that work together sharing implicit state. They often use Context internally while exposing a declarative API through props. Example: <Select><Option value='1'>One</Option></Select>.
Use useEffect to watch for prop changes and trigger animations. Consider using libraries like Framer Motion. Handle cleanup of animation timeouts. Manage transition states properly.
Pass callbacks as props for child-to-parent communication. Use useCallback for memoization. Consider timing of callback execution and cleanup. Handle error cases and loading states.
Prefer computing values during render instead of storing in state. Use useMemo for expensive calculations. If state is needed, update it in useEffect. Consider getDerivedStateFromProps in class components.
Test prop type validation, default props, component rendering with different props, event handlers, and edge cases. Use Jest and React Testing Library. Mock complex props and test error conditions.
Use props in conditional statements, ternary operators, or logical && operator. Handle loading/error states. Consider extract complex conditions to separate functions. Use proper TypeScript types.
Never modify props directly. Create new objects/arrays when updating. Use immutable update patterns or libraries like Immer. Consider performance implications of deep cloning.
Remove PropTypes in production builds for performance. Implement error boundaries for runtime errors. Consider logging prop validation errors. Use TypeScript for compile-time validation.
Transform props in render method or custom hooks. Consider memoization for expensive transformations. Handle edge cases and invalid data. Document transformation logic.
Avoid circular prop passing. Restructure component hierarchy. Consider using Context or state management. Break circular dependencies through component composition.
Use JSDoc comments, PropTypes, or TypeScript interfaces. Document required vs optional props, default values, and examples. Consider using Storybook for interactive documentation.
Use dynamic imports based on props. Implement proper loading states. Handle errors during chunk loading. Consider performance implications and bundle size.
Never expose sensitive data in client-side props. Use proper authentication and authorization. Consider encryption for necessary client-side data. Implement proper cleanup.