React

Original author(s)	Jordan Walke
Developer(s)	Facebook, Instagram and community
Initial release	March 2013; 5 years ago (2013-03)
Stable release	16.3.2 / April 16, 2018; 22 days ago (2018-04-16)[1]
Repository	https://github.com/facebook/react
Development status	Active
Written in	JavaScript
Platform	Cross-platform
Size	109 KiB production 710 KiB development
Type	JavaScript library
License	MIT
Website	reactjs.org

In computing, React (sometimes React.js or ReactJS) is a JavaScript library^[2] for building user interfaces.

It is maintained by Facebook, Instagram and a community of individual developers and corporations.^[3][4][5]

React can be used in the development of single-page applications and mobile applications. It aims primarily to provide speed, simplicity, and scalability. As a user interface library, React is often used in conjunction with other libraries such as Redux.

History

React was created by Jordan Walke, a software engineer at Facebook. He was influenced by XHP, an HTML component framework for PHP.^[6] It was first deployed on Facebook's newsfeed in 2011 and later on Instagram.com in 2012.^[7] It was open-sourced at JSConf US in May 2013.

React Native, which enables native Android, iOS, and UWP development with React, was announced at Facebook's React.js Conf in February 2015 and open-sourced in March 2015.

On April 18, 2017, Facebook announced React Fiber, a new core algorithm of React framework library for building user interfaces.^[8] React Fiber will become the foundation of any future improvements and feature development of the React framework.^[9]

Basic usage

The following is a rudimentary example of React usage in HTML with JSX and JavaScript.

<div id="myReactApp"></div>

<script type="text/babel">
  class Greeter extends React.Component { 
    render() { 
      return <h1>{this.props.greeting}</h1>
    } 
  } 

  ReactDOM.render(<Greeter greeting="Hello World!" />, document.getElementById('myReactApp'));
</script>

The Greeter class is a React component that accepts a property greeting. The ReactDOM.render method creates an instance of the Greeter component, sets the greeting property to 'Hello World' and inserts the rendered component as a child element to the DOM element with id myReactApp.

When displayed in a web browser the result will be

<div id="myReactApp">
  <h1>Hello World!</h1>
</div>

Notable features

One-way data flow with props

Properties (commonly, props) are passed to a component from the parent component. Components receive props as a single set of immutable values^[10] (a JavaScript object). Whenever any prop value changes, the component's render function is called allowing the component to display the change.

Two-way data flow with states

States hold values throughout the component and can be passed to child components through props:

this.state = {
    color:'red'
}

render() {
    return (
        <child_component childColor={this.state.color} />
        )
}

Virtual DOM

Another notable feature is the use of a "virtual Document Object Model", or "virtual DOM". React creates an in-memory data structure cache, computes the resulting differences, and then updates the browser's displayed DOM efficiently.^[11] This allows the programmer to write code as if the entire page is rendered on each change, while the React libraries only render sub components that actually change.

Lifecycle Methods

Lifecycle methods are various methods that come built in with ReactJS. They allow the developer to process data at various points in the lifecycle of a React app. For example

• shouldComponentUpdate is a lifecycle method that tells Javascript to update the component using a boolean variable.
• componentWillMount is a lifecycle method that tells Javascript to set up certain data before a component mounts (is inserted into the virtual DOM).
• componentDidMount is a lifecycle method which is similar to componentWillMount except that it runs after the render method and can be used to add JSON data and to define properties and states.
• render is the most important lifecycle method and the only required one in any component. The render method is what connects with the JSX and this method can display its own JSX.

JSX

JavaScript XML (JSX) is an extension to the JavaScript language syntax^[12]. Similar in appearance to HTML, JSX provides a way to structure component rendering using syntax familiar to many (if not all) developers. React components are typically written using JSX, although they do not have to be (components may also be written in pure JavaScript). JSX is similar to another extension syntax created by Facebook for PHP, XHP.

An example of JSX code:

class App extends React.Component {
  render() {
    return (
      <div>
        <p>Header</p>
        <p>Content</p>
        <p>Footer</p>
      </div>
    );
  }
}

Nested elements

Multiple elements on the same level need to be wrapped in a single container element such as the <div> element shown above, or returned as an array^[13].

Attributes

JSX provides a range of element attributes designed to mirror those provided by HTML. Custom attributes can also be passed to the component^[14]. All attributes will be received by the component as props.

JavaScript expressions

JavaScript expressions (but not statements) can be used inside JSX with curly brackets {}:

  <h1>{10+1}</h1>

The example above will render

  <h1>11</h1>

Conditional statements

If–else statements cannot be used inside JSX but conditional expressions can be used instead. The example below will render { i === 1 ? 'true' : 'false' } as the string 'true' because i is equal to 1.

class App extends React.Component {
  render() {
    const i = 1;
    return (
      <div>
        <h1>{ i === 1 ? 'true' : 'false' }</h1>
      </div>
    );
  }
}

Functions and JSX can be used in conditionals:

class App extends React.Component {
  render() {
    const sections = [1, 2, 3];
    return (
      <div>
        { 
          sections.length > 0
            ? sections.map(n => <div>Section {n}</div>)
            : null
        }
      </div>
    );
  }
}

The above will render:

<div>
  <div>Section 1</div>
  <div>Section 2</div>
  <div>Section 3</div>
</div>

This section needs expansion with: JSX syntax is very different from normal JavaScript, some examples should be provided, or a new article created with in-depth technical detail on how it works, how it compiles, etc.... You can help by adding to it. (May 2017)

Architecture beyond HTML

The basic architecture of React applies beyond rendering HTML in the browser. For example, Facebook has dynamic charts that render to <canvas> tags,^[15] and Netflix and PayPal use isomorphic loading to render identical HTML on both the server and client.^[16][17]

Common idioms

React does not attempt to provide a complete 'application framework'. It is aimed squarely at building user interfaces^[2], and therefore does not include many of the tools some developers consider necessary to build an application. This allows the choice of whichever libraries the developer prefers to accomplish tasks such as performing network access or local data storage. Common patterns of usage have emerged as the library matures.

Use of the Flux architecture

To support React's concept of unidirectional data flow (which might be contrasted with Angular's bidirectional flow), the Flux architecture represents an alternative to the popular Model-view-controller architecture. Flux features actions which are sent through a central dispatcher to a store, and changes to the store are propagated back to the view^[18]. When used with React, this propagation is accomplished through component properties.

Flux can be considered a variant of the observer pattern^[19].

A React component under the Flux architecture should not directly modify any props passed to it, but should be passed callback functions that create actions which are sent by the dispatcher to modify the store. The action is an object whose responsibility is to describe what has taken place: for example, an action describing one user 'following' another might contain a user id, a target user id, and the type USER_FOLLOWED_ANOTHER_USER^[20]. The stores (which can be thought of as models) can alter themselves in response to actions received from the dispatcher.

This pattern is sometimes expressed as "properties flow down, actions flow up". Many implementations of Flux have been created since its inception, perhaps the most well-known being Redux which features a single store, often called a single source of truth.^[21]

React Native

React Native was announced by Facebook in 2015^[22], applying the React architecture to native Android^[23], iOS, and UWP^[24] applications.

History

In 2012 Mark Zuckerberg commented, "The biggest mistake we made as a company was betting too much on HTML5 as opposed to native" ^[25]. He promised that Facebook would soon deliver a better mobile experience.

Inside Facebook, Jordan Walke found a way to generate iOS UI elements from a background JavaScript thread. They decided to organize an internal hackathon to perfect this prototype in order to be able to build native apps with this technology.^[26].

After few months of development, Facebook released the first version for the React.js Conf 2015. During a technical talk^[27], Christopher Chedeau explained that Facebook was already using React Native in production for their Group App and their Ads Manager App^[22].

Working principles

The working principles of React Native are basically the same as React except that it is not manipulating the DOM via the VirtualDom but some native views. It runs in a background process (which interprets the JavaScript written by the developers) directly on the end-device and communicates with the native platform via a serializable, asynchronous and batched Bridge^[28].

It can be seen that Facebook corrected the error that Mark Zuckerberg mentioned in 2012:^{[original research?]} React Native doesn't rely on HTML5 at all, everything is written in JavaScript, and relies on native SDKs.

Hello World

A Hello, World program in React Native looks like this:

 1 import React, { Component } from 'react';
 2 import { AppRegistry, Text } from 'react-native';
 3 
 4 export default class HelloWorldApp extends Component {
 5   render() {
 6     return (
 7       <Text>Hello world!</Text>
 8     );
 9   }
10 }
11 
12 // Skip this line if using Create React Native App
13 AppRegistry.registerComponent('HelloWorld', () => HelloWorldApp);
14 
15 // The ReactJS code can also be imported into another component with the following code:
16 
17 import HelloWorldApp from './HelloWorldApp';

Future development

Project status can be tracked via the core team discussion forum.^[29] However major changes to React go through the Future of React repo, Issues and PR.^[30][31] This enables the React community to provide feedback on new potential features, experimental APIs and JavaScript syntax improvements.

Sub projects

The status of the React sub-projects used to be available in the project wiki.^[32]

Facebook CLA

Facebook requires contributors to React to sign the Facebook CLA.^[33][34]

Criticism of ReactJS

A criticism of ReactJS is that it has high memory (RAM) requirements, since it uses the concept of a "Virtual DOM". This is where "a representation of a UI is kept in memory and synced with the 'real' DOM by a library such as ReactDOM."^[35]

Licensing controversy

The initial public release of React in May 2013 used a standard Apache License 2.0. In October 2014, React 0.12.0 replaced this with a 3-clause BSD license and added a separate PATENTS text file that permits usage of any Facebook patents related to the software:^[36]

"The license granted hereunder will terminate, automatically and without notice, for anyone that makes any claim (including by filing any lawsuit, assertion or other action) alleging (a) direct, indirect, or contributory infringement or inducement to infringe any patent: (i) by Facebook or any of its subsidiaries or affiliates, whether or not such claim is related to the Software, (ii) by any party if such claim arises in whole or in part from any software, product or service of Facebook or any of its subsidiaries or affiliates, whether or not such claim is related to the Software, or (iii) by any party relating to the Software; or (b) that any right in any patent claim of Facebook is invalid or unenforceable."

This unconventional clause caused some controversy and debate in the React user community, because it could be interpreted to empower Facebook to revoke the license in many scenarios, for example, if Facebook sues the licensee prompting them to take "other action" by publishing the action on a blog or elsewhere. Many expressed concerns that Facebook could unfairly exploit the termination clause or that integrating React into a product might complicate a startup company's future acquisition.^[37]

Based on community feedback, Facebook updated the patent grant in April 2015 to be less ambiguous and more permissive:^[38]

"The license granted hereunder will terminate, automatically and without notice, if you (or any of your subsidiaries, corporate affiliates or agents) initiate directly or indirectly, or take a direct financial interest in, any Patent Assertion: (i) against Facebook or any of its subsidiaries or corporate affiliates, (ii) against any party if such Patent Assertion arises in whole or in part from any software, technology, product or service of Facebook or any of its subsidiaries or corporate affiliates, or (iii) against any party relating to the Software. [...] A "Patent Assertion" is any lawsuit or other action alleging direct, indirect, or contributory infringement or inducement to infringe any patent, including a cross-claim or counterclaim."^[39]

The Apache Software Foundation considered this licensing arrangement to be incompatible with its licensing policies, as it "passes along risk to downstream consumers of our software imbalanced in favor of the licensor, not the licensee, thereby violating our Apache legal policy of being a universal donor", and "are not a subset of those found in the [Apache License 2.0], and they cannot be sublicensed as [Apache License 2.0]."^[40]. In August 2017, Facebook dismissed the Apache Foundation's downstream concerns and refused to reconsider their license^[41][42], and, the following month, WordPress decided to switch their Gutenberg and Calypso projects away from React.^[43]

License change

On September 23, 2017, Facebook announced that the following week, it would re-license Flow, Jest, React, and Immutable.js under a standard MIT License; the company stated that React was "the foundation of a broad ecosystem of open source software for the web", and that they did not want to "hold back forward progress for nontechnical reasons."^[44]

On September 26, 2017, React 16.0.0 was released with the MIT license.^[45] The MIT license change has also been backported to the 15.x release line with React 15.6.2.^[46]

References

External links

• Official website