React’s simplicity lies in that it makes it easy to declare user-interfaces in self-contained independent components. It hides its complex rendering engine implementation and exposes a simple component API. There are only a few public methods to override inside the component such as component Will Mount, component Did Mount, etc.
In React, every UI is composed of components, so there is no mismatch of multiple types to worry about. Since there is only one common object, it makes it easy to nest components inside components and encourages the principle of single responsibility for each component.
The React UI is declared inside components. A component is a function that accepts props as inputs and outputs the declared interface. The UI should be composed of as many components as possible to maximize reusability.
If a widget is composed of multiple components, the state should be the parent component. Any asynchronous I/O requests shouldn’t be inside the pure component. Doing so would make it less usable as it couples the I/O requests to the component. If you tried to use the component in a large list, it would create a lot of requests on rendering the components.
Try to avoid using inheritance, and use composition from components. For example, if you need more functionality from a component, make a wrapper component. There are different kinds of components besides just UI components and container components. It is useful to think of these as pages or screens that contain all the components, handle actions to request the data, and also handle local inner component communications.
One-Way Data Flow
React uses one-way data flow, so only changes to the data result in changes to the UI. If you use Redux, you change data in a global app store, and the components listen for changes there. The benefits of having all the app state in one place is having one source of truth. Another benefit is it makes it easier to inspect changes in the app and captures the different states of the app. This helps when trying to reproduce errors.
The Virtual DOM allows the UI to be efficient in diffing UI changes. This in-between process between what the component should render and what the actual rendering is that it allows React to work on different platforms. React Native runs on mobile devices and there are also native OS platforms that run on Ubuntu, Mac, and Windows.
The in-between step is where React actually does most of its work. It does this using the difference between the last declared render and the updated render in a virtual model of the interface, applying to it the real interface implementation. The reason for the virtual DOM is that in browsers, certain changes to the DOM cause browser engines to recalculate the CSS layout, reimplement the layout, and redraw the page. React batches the minimum amount of changes needed in each UI cycle, reducing the redraw frequency.
React isn’t just the UI, it’s a framework/ecosystem. You can manage the state using a state manager such as Redux. This is abstracted away from the component tree. It makes debugging easier to not have state hidden in multiple places. There are good tools following this stack such as Redux DevTools, which allows you to see the app state as a collapsible tree widget.
The advantage of using React
- Simple to know how a part is rendered, you simply take a render at the rendering work.
- JSX makes it simple to peruse the code of your segments. It is likewise truly simple to see the design, or how parts are stopped/joined with each other.
- you can render React on the server-side.
- It is anything but difficult to test, and you can likewise coordinate a few instruments like a joke.
- It guarantees comprehensibility and makes practicality less demanding.
- You can utilize React with any structure (Backbone.js, Angular.js) as it is just a view layer.
What is not all that great about React?
- It is just a view layer, you have still to plug your code for Ajax solicitations, occasions et cetera. A few people get amazed by that.
- The library itself is really huge.
- The expectation to absorb information can be steep.
- In the event that responds locally is truly how it was portrayed, respond will turn out to be much greater.
- Execution savvy, it is better than average as it depends on a virtual-dom to comprehend what is truly changing
- in your UI and will re-render just what has truly changed. It has an issue with substantial, somewhat changing, arrangements of kids (2000 test), yet can be streamlined essentially.
- If you are not sure, just think about the big projects using React: Instagram, hip chat, facebook chat and so on.