Facebook's React vs AngularJS: A Closer Look

When we launched React | A JavaScript library for building user interfaces two weeks ago there were a few comparisons to AngularJS (Facebook’s New React JavaScript Library Tutorial Rewritten in AngularJS). We already talked about how React works and its philosophy (React | Why did we build React?), but let's get a little more concrete and look at React and Angular code side-by-side.

To set the record straight: React components are far more powerful than Angular templates; they should be compared with Angular's directives instead. So I took the first Google hit for "AngularJS directive tutorial" (AngularJS Directives Tutorial - Fundoo Solutions), rewrote it in React and compared them.

All of the code in this post is on GitHub at https://github.com/petehunt/angu....

The app


The tutorial creates an "n star" rating widget. Here's what the widget looks like:

You can play with it here: http://jsfiddle.net/abhiroop/G3U...

 

The HTML page


First let's look at Angular's HTML:

  1. <!DOCTYPE html>
  2. <html ng-app="FundooDirectiveTutorial">
  3. <head>
  4. <title>Rating Directive Demo</title>
  5. <link rel="stylesheet" href="rating.css"/>
  6. </head>
  7. <body ng-controller="FundooCtrl">
  8. Rating is {{rating}} <br/>
  9. Clickable Rating <br/>
  10. <div fundoo-rating rating-value="rating" max="10" on-rating-selected="saveRatingToServer(rating)"></div>
  11. <br/>
  12. Readonly rating <br/>
  13. <div fundoo-rating rating-value="rating" max="10" readonly="true"></div>
  15. <script type="text/javascript" src="Page on Googleapis"></script>
  16. <script type="text/javascript" src="rating.js"></script>
  17. </body>
  18. </html>



It's a pretty straightforward document, except it includes magical HTML attributes. With React you simply mount a component into a plain HTML page via JavaScript. Here's what it looks like:

  1. <!DOCTYPE html>
  2. <html>
  3. <head>
  4. <title>Rating Directive Demo</title>
  5. <link rel="stylesheet" href="rating.css"/>
  6. <script type="text/javascript" src="http://dragon.ak.fbcdn.net/hphotos-ak-ash3/851560_459383004151757_22266_n.js"></script>
  7. <script type="text/javascript" src="http://dragon.ak.fbcdn.net/hphotos-ak-prn1/851582_580035725361422_42012_n.js"></script>
  8. <script type="text/jsx" src="rating.js"></script>
  9. </head>
  10. <body>
  11. </body>
  12. </html>



Nothing interesting here (except we're using an in-browser transformer for development; see React | Getting Started for more info). Some JavaScript will mount our component in document.body.

The CSS is shared between the Angular and React versions so I've omitted it.

The JavaScript


Let's look at Angular's JavaScript. It defines a module, a controller and a directive:

  1. angular.module('FundooDirectiveTutorial', [])
  2. .controller('FundooCtrl', function($scope, $window) {
  3. $scope.rating = 5;
  4. $scope.saveRatingToServer = function(rating) {
  5. $window.alert('Rating selected - ' + rating);
  6. };
  7. })
  8. .directive('fundooRating', function () {
  9. return {
  10. restrict: 'A',
  11. template: '<ul class="rating">' +
  12. '<li ng-repeat="star in stars" ng-class="star" ng-click="toggle($index)">' +
  13. '\u2605' +
  14. '</li>' +
  15. '</ul>',
  16. scope: {
  17. ratingValue: '=',
  18. max: '=',
  19. readonly: '@',
  20. onRatingSelected: '&'
  21. },
  22. link: function (scope, elem, attrs) {
  24. var updateStars = function() {
  25. scope.stars = [];
  26. for (var i = 0; i < scope.max; i++) {
  27. scope.stars.push({filled: i < scope.ratingValue});
  28. }
  29. };
  31. scope.toggle = function(index) {
  32. if (scope.readonly && scope.readonly === 'true') {
  33. return;
  34. }
  35. scope.ratingValue = index + 1;
  36. scope.onRatingSelected({rating: index + 1});
  37. };
  39. scope.$watch('ratingValue', function(oldVal, newVal) {
  40. if (newVal) {
  41. updateStars();
  42. }
  43. });
  44. }
  45. }
  46. });



Notice the HTML template defined in a string. The provided linking function tells Angular how to imperatively update the DOM when the rating changes via an explicit callback. There is also a scope which is similar to, but behaves differently than, a JavaScript environment.

Let's look at the React version.

  1. /** @jsx React.DOM */
  3. var FundooRating = React.createClass({
  4. render: function() {
  5. var items = [];
  6. for (var i = 1; i <= this.props.max; i++) {
  7. var clickHandler = this.props.onRatingSelected && this.props.onRatingSelected.bind(null, i);
  8. items.push(<li class={i <= this.props.value && 'filled'} onClick={clickHandler}>{'\u2605'}</li>);
  9. }
  10. return <ul class="rating">{items}</ul>;
  11. }
  12. });
  14. var FundooDirectiveTutorial = React.createClass({
  15. getInitialState: function() {
  16. return {rating: 5};
  17. },
  18. handleRatingSelected: React.autoBind(function(rating) {
  19. this.setState({rating: rating});
  20. alert('Rating selected - ' + rating);
  21. }),
  22. render: function() {
  23. return (
  24. <div>
  25. Rating is {this.state.rating}<br/>
  26. Clickable Rating <br/>
  27. <FundooRating value={this.state.rating} max="10" onRatingSelected={this.handleRatingSelected} />
  28. <br />
  29. Readonly rating <br/>
  30. <FundooRating value={this.state.rating} max="10" />
  31. </div>
  32. );
  33. }
  34. });
  36. React.renderComponent(<FundooDirectiveTutorial />, document.body);



The markup syntax you see is JSX and we've discussed it at length in React | JSX Syntax. We prefer it, but it's not required to use React.

React doesn't have templates since we use JavaScript to generate the markup (via JSX or function calls).

There's no linking function because React figures out how to most efficiently update the DOM for you when your data changes. Just write your render() function and React will keep the UI up-to-date for you.

There are no scopes or other nonstandard concepts besides components (which are just objects) since you're just using plain, familiar JavaScript to express your display logic.

We have plenty of documentation starting with React | Tutorial to explain how all of this works. The important takeaway is that you provide a render() method that declaratively specifies how you want your UI to look. When the data changes, React calls your render() method again, diffs the old return value with the new one and figures out how to update the DOM for you.

React vs AngularJS by the (highly unscientific) numbers


Number of concepts to learn

  • React: 2 (everything is a component, some components have state). As your app grows, there's nothing more to learn; just build more modular components.
  • AngularJS: 6 (modules, controllers, directives, scopes, templates, linking functions). As your app grows, you'll need to learn more concepts.

Lines of code

  • React: 47 (12 HTML, 35 JS)
  • AngularJS: 64 (18 HTML, 46 JS)


Comparing technology is hard.


It's hard to compare two technologies in an objective way in a single blog post. I'm sure it's possible to code golf the Angular example to be smaller than React, so certainly don't take these numbers too seriously.

Using React and AngularJS together


We've designed React from the beginning to work well with other libraries. Angular is no exception. Let's take the original Angular example and use React to implement the fundoo-rating directive.

First, let's bring back the original AngularJS HTML page and add the React dependencies:

  1. <!DOCTYPE html>
  2. <html ng-app="FundooDirectiveTutorial">
  3. <head>
  4. <title>Rating Directive Demo</title>
  5. <link rel="stylesheet" href="rating.css"/>
  6. </head>
  7. <body ng-controller="FundooCtrl">
  8. Rating is {{rating}} <br/>
  9. Clickable Rating <br/>
  10. <div fundoo-rating rating-value="rating" max="10" on-rating-selected="saveRatingToServer(rating)"></div>
  11. <br/>
  12. Readonly rating <br/>
  13. <div fundoo-rating rating-value="rating" max="10" readonly="true"></div>
  15. <script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/angularjs/1.0.6/angular.min.js"></script>
  16. <script type="text/javascript" src="http://dragon.ak.fbcdn.net/hphotos-ak-ash3/851560_459383004151757_22266_n.js"></script>
  17. <script type="text/javascript" src="rating-react.build.js"></script>
  18. <script type="text/javascript" src="rating-angular.js"></script>
  19. </body>
  20. </html>




Note: for this example we're precompiling a rating-react.js file using JSX syntax to rating-react.build.js using react-tools.

Next let's strip down the React version to the bare minimum we need to support the directive:

  1. /** @jsx React.DOM */
  3. window.FundooRating = React.createClass({
  4. render: function() {
  5. var items = [];
  6. for (var i = 0; i < this.props.scope.max; i++) {
  7. var clickHandler = this.props.scope.$apply.bind(this.props.scope, this.props.scope.toggle.bind(null, i));
  8. items.push(<li class={i < this.props.scope.ratingValue && 'filled'} onClick={clickHandler}>{'\u2605'}</li>);
  9. }
  10. return <ul class="rating">{items}</ul>;
  11. }
  12. });



And finally, here's what remains of the Angular JavaScript code:

  1. angular.module('FundooDirectiveTutorial', [])
  2. .controller('FundooCtrl', function($scope, $window) {
  3. $scope.rating = 5;
  4. $scope.saveRatingToServer = function(rating) {
  5. $window.alert('Rating selected - ' + rating);
  6. };
  7. })
  8. .directive('fundooRating', function () {
  9. return {
  10. restrict: 'A',
  11. scope: {
  12. ratingValue: '=',
  13. max: '=',
  14. readonly: '@',
  15. onRatingSelected: '&'
  16. },
  17. link: function (scope, elem, attrs) {
  18. scope.toggle = function(index) {
  19. if (scope.readonly && scope.readonly === 'true') {
  20. return;
  21. }
  22. scope.ratingValue = index + 1;
  23. scope.onRatingSelected({rating: index + 1});
  24. };
  25. scope.$watch('ratingValue', function(oldVal, newVal) {
  26. React.renderComponent(window.FundooRating({scope: scope}), elem[0]);
  27. });
  28. }
  29. }
  30. });



We've changed the watch expression to simply call React.renderComponent() whenever the data changes. React is smart enough to do this efficiently. You don't have to write any code to update your UI.

This version clocks in at 62 loc, which is between the pure-React and pure-Angular version.

The conclusion


AngularJS is a great tool for building web apps.

If you like Angular, we think you'll love React because reactive updates are so easy and composable components are a simple and powerful abstraction for large and small applications.

Head on over to React | A JavaScript library for building user interfaces

write by Pete Hunt 

posted @ 2017-08-04 10:58  小y  阅读(310)  评论(0)  编辑  收藏  举报