Apis & Network Integration Interview Questions

API calls in React Native can be made using the Fetch API or Axios library. The Fetch API is built into React Native and supports promises, while Axios provides additional features like request/response interceptors, automatic JSON transformation, and better error handling.

useEffect is commonly used for making API calls when a component mounts or when dependencies change. It helps manage side effects, cleanup functions for canceling requests, and proper data fetching lifecycle. The dependency array controls when the effect reruns.

API errors should be caught using try/catch blocks or .catch() for promises. Error states should be stored in component state, displayed to users appropriately, and logged for debugging. Consider implementing retry logic and proper error boundaries.

GET requests retrieve data and include parameters in the URL query string. POST requests send data in the request body and are used for creating/updating resources. GET requests should be idempotent, while POST requests can modify server state.

Loading states should be managed in component state (e.g., isLoading boolean). Show loading indicators while data is being fetched, handle errors appropriately, and ensure good UX during loading. Consider skeleton screens or placeholder content.

JSON (JavaScript Object Notation) is a data format used for API requests/responses. React Native can parse JSON using JSON.parse() and stringify using JSON.stringify(). Most modern APIs use JSON for data exchange.

Headers can be set using the headers object in fetch options or Axios config. Common headers include Authorization for authentication tokens, Content-Type for specifying data format, and Accept for specifying expected response format.

REST (Representational State Transfer) is an architectural style for APIs using HTTP methods (GET, POST, PUT, DELETE). It provides standardized ways to interact with resources, making APIs predictable and easier to understand.

API authentication typically involves sending tokens in request headers, often using JWT (JSON Web Tokens). Tokens should be stored securely (e.g., AsyncStorage), refreshed when needed, and included in requests via interceptors.

Query parameters are key-value pairs added to URLs for filtering, sorting, or pagination. They're commonly used in GET requests to modify the response. Parameters should be properly encoded using encodeURIComponent() when necessary.

API caching can be implemented using in-memory caching, AsyncStorage, or specialized caching libraries. Consider cache invalidation strategies, TTL (Time To Live), and proper cache updates when data changes.

Offline sync requires local storage of data, queue management for offline actions, conflict resolution strategies, and proper sync when online. Consider using libraries like WatermelonDB or implementing custom sync logic.

File uploads require proper multipart/form-data handling, progress tracking, chunked uploads for large files, and proper error handling. Consider platform-specific file access APIs and compression before upload.

Request cancellation can be implemented using AbortController with fetch, or cancelToken with Axios. Important for preventing memory leaks and unnecessary updates when components unmount or dependencies change.

Rate limiting requires implementing request queuing, proper error handling for rate limit responses, exponential backoff for retries, and tracking request counts. Consider using libraries for request throttling.

WebSockets provide real-time bidirectional communication. Implementation involves socket connection management, proper event handling, reconnection strategies, and state management for real-time data.

API versioning strategies include URL versioning, header versioning, or content negotiation. Apps should handle different API versions gracefully, possibly supporting multiple versions during transition periods.

Security considerations include SSL/TLS, token management, certificate pinning, request/response encryption, and proper error handling. Avoid storing sensitive data in plain text and implement proper authentication flows.

Response compression involves proper handling of Content-Encoding headers, decompression of gzipped responses, and optimization of data transfer. Consider implementing compression for requests when appropriate.

Request batching involves combining multiple requests into single requests, implementing proper request queuing, and handling responses efficiently. Consider trade-offs between reduced network calls and increased complexity.

GraphQL implementation involves setting up Apollo Client or similar libraries, implementing proper cache management, handling queries/mutations, and managing local state. Consider code generation and type safety.

Real-time sync involves WebSockets, server-sent events, or polling strategies. Consider optimistic updates, conflict resolution, proper error handling, and state management for real-time data.

Complex transformations require proper data normalization, efficient algorithms, consideration of performance impact, and possibly using web workers. Consider implementing caching for expensive transformations.

Large-scale architectures require proper service organization, API gateway implementation, microservices integration, and efficient data flow management. Consider implementing proper error boundaries and fallback strategies.

Efficient pagination involves cursor-based or offset-based strategies, proper cache management, infinite scroll implementation, and optimized data fetching. Consider implementing virtual scrolling for large datasets.

API middleware implementation involves request/response interceptors, logging, analytics tracking, error handling, and authentication management. Consider implementing proper middleware composition and order.

Advanced caching involves implementing stale-while-revalidate, cache-then-network, and proper cache invalidation strategies. Consider implementing proper cache hierarchies and optimization techniques.

Complex authentication involves OAuth flows, token refresh mechanisms, biometric authentication integration, and proper security measures. Consider implementing proper state management and error handling.

API monitoring involves implementing proper logging, performance tracking, error reporting, and usage analytics. Consider implementing proper monitoring infrastructure and alerting systems.

API testing involves implementing proper test coverage, mocking strategies, integration tests, and automated testing pipelines. Consider implementing proper test data management and CI/CD integration.