TrustRadius Insights for React are summaries of user sentiment data from TrustRadius reviews and, when necessary, third party data sources.
Pros
Versatile State Management: Users have praised React for its highly versatile state management capabilities, allowing developers to tailor their solutions based on specific requirements. This flexibility has been appreciated by many reviewers and has enabled them to effectively manage state in their applications.
Efficient Code Organization: Many users have highlighted React's ability to effectively organize code, resulting in a streamlined development process. This feature has allowed developers to maintain a structured and maintainable codebase, facilitating collaboration among team members and making it easier to understand and maintain the code over time.
Improved Performance with Virtual DOM: Reviewers have appreciated React's speed and efficiency, particularly with its virtual DOM implementation. The optimization of re-rendering and display updates has resulted in faster and smoother user interfaces. This improved performance contributes to a better overall user experience when using React-based applications.
Loading Reviews List....
React Reviews
4 Reviews
Enterprises (1,001+ employees)
Search is temporarily unavailable. Filters are still applied.
React is used to build a wide range of applications including websites and content management systems, to name a few. It is also used with .NET Core for building a full stack project with the use of front-end, backend and API technologies.
React addresses several business problems for our clients who need better scalability and appearance for their websites. It enables employees to write clean and maintainable code that can be refactored with ease.
Features and uses:
Dynamic data handling: React can render changes to the user interface and manage updates to dynamic data without slowing down the application.
Scaling: As the application grows and gets more complicated, scalability is made simple by React's component-based architecture.
Maintainability: The modular nature of React's code makes it simple to update and maintain the codebase over time.
Cross-platform compatibility: React enables the development of online and mobile applications, saving time and resources.
Fast performance: Fast rendering and updating of components is made possible by React's usage of a virtual DOM, which gives users of the application the impression that it is responding quickly.
Large community: React has a large and active community of developers, which provides resources, tutorials and tools for eveyones' usage.
Pros
React is excellent at handling dynamic updates to user interfaces. React, for instance, can effectively refresh the user interface (UI) in real-time as the user interacts with the application or as fresh data is obtained from an API.
Developers can simply design reusable UI components with React, which can then be combined to create complex user interfaces. As a result, development time is cut down and the codebase is simpler to manage.
With the help of React, developers may implement server-side rendering, which can speed up the application's loading time and make it simpler for search engines to scan and index the information.
Cons
For developers who are new to the library or to front-end programming in general, React has a relatively steep learning curve. Because of this, it could be challenging for developers to use React to its full potential.
It can be difficult to manage the state and interactions between components as React applications grow increasingly complicated. As a result, the code could be challenging to read and maintain.
Due to React's restricted collection of built-in functionality, some tasks may be challenging to complete without the use of extra libraries or custom code. For instance, handling routing, which is a frequent requirement for many applications, is not supported natively by React.
Likelihood to Recommend
React is a JavaScript user interface construction library that works well for:
Developing web apps with dynamic and complicated user interfaces.
creating reusable UI elements that may be used in other applications.
creating single-page applications with dynamic content updates that don't require a page reload.
The Virtual DOM's effective updating mechanism allows it to handle large volumes of data updates.
React, on the other hand, might be less suitable for:
Websites that are simple, stagnant, and have no interaction. Other libraries or simple HTML, CSS, and JavaScript may be a better fit in such circumstances.
Web sockets may be a better choice for applications that need real-time updates, such as chat or gaming apps.
When creating mobile apps, React Native is a better option.
Server side rendering only, as React is designed to run on the client side.
React is an excellent library for development of single-page applications using Javascript. We are currently using it to develop SPAs for all of our web applications in our department. React has excellent community support for various UI development components like bootstrap. Also a lot of components available in React are extremely easy to use and can be used straight out of the box.
Pros
Fast and Responsive
Excellent state management for components
Wide community support for extensibility
Wide range of UI components available on npm for React
Mobile browsers also support React
Easy component creation process
Cons
Understanding re-renders of pages can be improved
Learning curve is a bit steep if you never worked on declarative programming before
Likelihood to Recommend
If you wish to build fast, snappy single-page apps where you need wide support from the community for additional components, then go for React. The learning curve can be a bit steep if you have never worked on any declarative programming before, but once you get used to it, it becomes pretty straightforward.
Many teams in our organization are using React for both our web properties and several mobile apps (using React Native). It is the default client-side framework and mobile app stack for any new work as well. This lets engineers easily collaborate between different projects and also share components.
Pros
Lots of compatible libraries and tools
Fantastic developer experience and mental model
Easy to layer abstractions and compose large pages from small components
Cons
Without using tools like Gatsby or Next, React encourages large client-side bundles with no content available immediately.
Usually, you need to put together your own "framework" from other tools since React is just the view layer.
React Native is still maturing, though there is a lot of activity on that project latey.
Likelihood to Recommend
React is great for very interactive experiences like search filters, dynamic forms, graphs and charts, and anything else where immediate interaction vastly improves the user experience. For very simple content that could be server-rendered and there are existing rails (or similar) backend in place, that can often be a better choice. But the advantages of a static React frontend are easy cachability on a CDN, pre-rendered content with tools like Gatsby, and easy deployment to platforms like Netlify or Amazon S3. React Native is also a fantastic tool for creating cross-platform applications that need to run on both iOS and Android.
VU
Verified User
Contributor in Information Technology (10,001+ employees)
React is one of the more popular frameworks being used across our organization for developing web interfaces. React is a library that allows for efficient compartmentalization of the code that allows managing code bases on large user interfaces a breeze. It also does several optimizations on the expensive re-rendering process to make the the user interfaces with large data responsive.
Pros
Solid backing by large organization (Facebook) thats committed to keeping the development on the project. In my mind, this is the number one priority for any library because without this: time is wasted on getting up-to speed on a library that you will never use, have a codebase with a library thats hard to maintain because few years down the lane, hiring devs to maintain an unsupported library is very difficult.
As with any libraries, open source community's support is critical for success of any framework because this allows for more pre-built components that could be used right out-of-box => makes Development using React a breeze.
React's Stateful and Stateless components make organizing your code a breeze. These components would also allow for writing clean Unit Tests on the logic.
React's component lifecycle. It offers a variety of lifecycle methods, that allows for handling different scenarios of loading and manipulating data in the UI.
I found React's documentation very well maintained with plenty of examples explaining each feature.
Responsiveness is a very important criteria in selecting a UI and React is very responsive. It does some neat optimizations on re-rendering using virtual DOM and would only re-render parts of the DOM that changed. These optimizations makes React Applications feel really fast.
React Native would allow for building applications that span across web and mobile interfaces (iOS and Android). This makes learning React even more enticing, because using a single library, you could build applications that span across Web, iOS and Android.
create-react-app is an effort by Facebook (creators of React) that makes getting started with React really easy. It does all the heavy lifting of configurations for you and allow you to focus on just development.
Small footprint, minified React + React DOM is under 150Kb, that makes loading UI's with react really fast.
React + Enzyme (backed by Airbnb) + Sinon + Mocha + Chai makes unit testing the UI components fun and improves the overall maintainability of the project.
Cons
React could get very frustrating unless you start thinking in React. React enforces a top down hierarchy of data flow and offers no way for the data to communicate backwards. This is a big shift in mindset coming from Angular 1.x. This constraint is really a big factor that determines how to organize your code and how you might want to write your own Components.
Because of the self imposed top down hierarchy, you end up having a heavy parents with dumb children. Because parents would need to the bulk of the work, they usually manage the state, while passing callbacks to the child components. If not properly designed, this could lead to the callback hell, where you could have callbacks passing through like multiple children.
As with any library, you will have to iterate through multiple designs to come up with a ways to avoid "heavy parent components" in React. One obvious solution is using some open source tools like Redux, but we opted for a variation of it to suit our needs.
Likelihood to Recommend
Well suited for: - Building performance intensive web interfaces. - Making responsive user interfaces that deal with large data. - Asynchronously retrieving data and partial DOM updates. - Clean organized code. - Building interfaces in multiple platforms (thanks to React Native)
Its less suited if: - You are unwilling to think in React.
