React useEffect Cleanup To Clean Previous Request Of Rest API Application Programming Interface

React useEffect Cleanup To Clean Previous Request Of Rest API Application Programming InterfaceIn this video, We will learn, how to use useeffect cleanup function or react hook in the frontend application programming interface of react js javascript library.

Here we also get how to reduct the rest API requests on the SQL server to Minecraft download like apps to install. The useEffect cleanup is a powerful concept to show data after some time or only when something happened with removing old requests in development lifecycle testing.

The clean up function will help us to reduce the backend process which may slow our hosting or server Cpanel at any state changes. Subscribe to CODEMETA for more videos on react js tutorial beginners as well as more coding story in hindi.



#codeMeta
#reactjs
#tutorial
#reacttutorial
#useeffectcleanup
#cleanup
#useeffect


1. What is React.js?
2. Why React Instead Of "JavaScript"?
3. Understanding "let" and "const"
4. Arrow Functions
5. Exports and Imports
6. Understanding Classes
7. Classes, Properties and Methods
8. The Spread & Rest Operator
9. Destructuring
10. Array Functions
11. JS Array Functions
13. React Installation
14. react folder structure
17. Analyzing a Standard React Project
19. How React Works
21. Adding Basic CSS Styling
23. Passing Data via "props"
24. Adding "normal" JavaScript Logic to Components
25. Splitting Components Into Multiple Components
26. The Concept of "Composition" ("children props")
27. Organizing Component Files
28. Listening to Events & Working with Event Handlers
30. Working with "State"
31. Adding Form Inputs
32. Listening to User Input
33. Working with Multiple States
36. Handling Form Submission
37. Adding Two-Way Binding
40. Rendering Lists of Data
41. Using Stateful Lists
42. Understanding "Keys"
43. Outputting Conditional Content
44. Adding Conditional Return Statements / filter method
45. add inline style
47. Setting Dynamic Inline Styles
48. Setting CSS Classes Dynamically
50. Styled Components & Dynamic Props
51. Styled Components & Media Queries
52. Using CSS Modules
53. Dynamic Styles with CSS Modules
54. Understanding React Error Messages
55. Analyzing Code Flow & Warnings
56. Using the React DevTools
58. Adding a re-usable "Card" Component
59. Adding a re-usable "Button" Component
61. Adding Validation & Resetting Logic
62. Adding a Users List Component
64. Adding The "ErrorModal" Component
65. Managing the Error State
67. Creating a Wrapper Component
68. React Fragments
69. Introducing React Portals
71. Working with "ref"s
72. What are "Side Effects" & Introducing useEffect
73. Using the useEffect() Hook
75. Using the useEffect Cleanup Function
78. Using the useReducer() Hook
80. Introducing React Context (Context API)
81. Using the React Context API
83. Making Context Dynamic
84. Building & Using a Custom Context Provider Component
86. Diving into "Forward Refs"
87. Adding a Form
89. Working on the "Shopping Cart" Component
90. Adding a Modal via a React Portal
92. Adding a Cart Context
94. Adding a Cart Reducer
95. Working with Refs & Forward Refs
97. Making Items Removable
100. Component Updates In Action
101. Preventing Unnecessary Re-Evaluations with React.memo()
102. Preventing Function Re-Creation with useCallback()
107. Sending a GET Request
108. Using async / await
109. Handling Loading & Data States
110. Handling Http Errors
111. Using useEffect() For Requests
112. Sending a POST Request
115. Using Custom Hooks
116. Configuring Custom Hooks
117. Building a Custom Http Hook
119. Dealing With Form Submission & Getting User Input Values
120. Adding Basic Validation
121. Providing Validation Feedback
122. Handling the "was touched" State
123. Managing The Overall Form Validity
126. Submitting & Sending Cart Data
129. Creating a Redux Store for React
131. Using Redux Data in React Components
136. Redux Challenges & Introducing Redux Toolkit
137. Adding State Slices
138. Connecting Redux Toolkit State
139. Working with Multiple Slices
140. Reading & Dispatching From A New Slice
141. Redux & Async Code
142. Using useEffect with Redux
143. Installing React Router
144. Defining & Using Routes
145. Working with Links
146. Using NavLinks
147. Adding Dynamic Routes with Params
148. Extracting Route Params
149. Working with Nested Routes
150. Redirecting The User
151. Working with Query Parameters
152. Getting Creative With Nested Routes
153. Writing More Flexible Routing Code
154. Sending & Getting Quote Data via Http
156. Adding Lazy Loading
157. Building The Code For Production
160. Adding User Signup
162. Adding User Login
163. Managing The Auth State With Context
164. Using The Token For Requests To Protected Resources
165. Redirecting The User
166. Adding Logout
168. Persisting The User Authentication Status
169. Adding Auto-Logout
170. Using CSS Transitions
171. Using CSS Animations
172. CSS Transition & Animations Limitations
174. Using the Transition Component
175. Animation Timings
176. Transition Events