By Sophie Alpert·
We’re happy to announce our first release candidate for React 0.14! We gave you a sneak peek in July at the upcoming changes but we’ve now stabilized the release more and we’d love for you to try it out before we release the final version.
Let us know if you run into any problems by filing issues on our GitHub repo.
We recommend using React from npm
and using a tool like browserify or webpack to build your code into a single package:
npm install --save react@0.14.0-rc1
npm install --save react-dom@0.14.0-rc1
Remember that by default, React runs extra checks and provides helpful warnings in development mode. When deploying your app, set the NODE_ENV
environment variable to production
to use the production build of React which does not include the development warnings and runs significantly faster.
If you can’t use npm
yet, we also provide pre-built browser builds for your convenience:
These builds are also available in the react
package on bower.
As we look at packages like react-native, react-art, react-canvas, and react-three, it has become clear that the beauty and essence of React has nothing to do with browsers or the DOM.
To make this more clear and to make it easier to build more environments that React can render to, we’re splitting the main react
package into two: react
and react-dom
. This paves the way to writing components that can be shared between the web version of React and React Native. We don’t expect all the code in an app to be shared, but we want to be able to share the components that do behave the same across platforms.
The react
package contains React.createElement
, .createClass
, .Component
, .PropTypes
, .Children
, and the other helpers related to elements and component classes. We think of these as the isomorphic or universal helpers that you need to build components.
The react-dom
package has ReactDOM.render
, .unmountComponentAtNode
, and .findDOMNode
. In react-dom/server
we have server-side rendering support with ReactDOMServer.renderToString
and .renderToStaticMarkup
.
var React = require('react');var ReactDOM = require('react-dom');var MyComponent = React.createClass({render: function () {return <div>Hello World</div>;},});ReactDOM.render(<MyComponent />, node);
We’ve published the automated codemod script we used at Facebook to help you with this transition.
The add-ons have moved to separate packages as well: react-addons-clone-with-props
, react-addons-create-fragment
, react-addons-css-transition-group
, react-addons-linked-state-mixin
, react-addons-perf
, react-addons-pure-render-mixin
, react-addons-shallow-compare
, react-addons-test-utils
, react-addons-transition-group
, and react-addons-update
, plus ReactDOM.unstable_batchedUpdates
in react-dom
.
For now, please use matching versions of react
and react-dom
in your apps to avoid versioning problems.
The other big change we’re making in this release is exposing refs to DOM components as the DOM node itself. That means: we looked at what you can do with a ref
to a React DOM component and realized that the only useful thing you can do with it is call this.refs.giraffe.getDOMNode()
to get the underlying DOM node. In this release, this.refs.giraffe
is the actual DOM node. Note that refs to custom (user-defined) components work exactly as before; only the built-in DOM components are affected by this change.
var Zoo = React.createClass({render: function () {return (<div>Giraffe name: <input ref="giraffe" /></div>);},showName: function () {// Previously: var input = this.refs.giraffe.getDOMNode();var input = this.refs.giraffe;alert(input.value);},});
This change also applies to the return result of ReactDOM.render
when passing a DOM node as the top component. As with refs, this change does not affect custom components. With these changes, we’re deprecating .getDOMNode()
and replacing it with ReactDOM.findDOMNode
(see below).
In idiomatic React code, most of the components you write will be stateless, simply composing other components. We’re introducing a new, simpler syntax for these components where you can take props
as an argument and return the element you want to render:
// Using an ES2015 (ES6) arrow function:var Aquarium = (props) => {var fish = getFish(props.species);return <Tank>{fish}</Tank>;};// Or with destructuring and an implicit return, simply:var Aquarium = ({species}) => <Tank>{getFish(species)}</Tank>;// Then use: <Aquarium species="rainbowfish" />
This pattern is designed to encourage the creation of these simple components that should comprise large portions of your apps. In the future, we’ll also be able to make performance optimizations specific to these components by avoiding unnecessary checks and memory allocations.
The react-tools
package and JSXTransformer.js
browser file have been deprecated. You can continue using version 0.13.3
of both, but we no longer support them and recommend migrating to Babel, which has built-in support for React and JSX.
React now supports two compiler optimizations that can be enabled in Babel 5.8.23 and newer. Both of these transforms should be enabled only in production (e.g., just before minifying your code) because although they improve runtime performance, they make warning messages more cryptic and skip important checks that happen in development mode, including propTypes.
Inlining React elements: The optimisation.react.inlineElements
transform converts JSX elements to object literals like {type: 'div', props: ...}
instead of calls to React.createElement
.
Constant hoisting for React elements: The optimisation.react.constantElements
transform hoists element creation to the top level for subtrees that are fully static, which reduces calls to React.createElement
and the resulting allocations. More importantly, it tells React that the subtree hasn’t changed so React can completely skip it when reconciling.
As always, we have a few breaking changes in this release. Whenever we make large changes, we warn for at least one release so you have time to update your code. The Facebook codebase has over 15,000 React components, so on the React team, we always try to minimize the pain of breaking changes.
These three breaking changes had a warning in 0.13, so you shouldn’t have to do anything if your code is already free of warnings:
props
object is now frozen, so mutating props after creating a component element is no longer supported. In most cases, React.cloneElement
should be used instead. This change makes your components easier to reason about and enables the compiler optimizations mentioned above.createFragment
helper to migrate, which now returns an array.classSet
has been removed. Use classnames instead.And these two changes did not warn in 0.13 but should be easy to find and clean up:
React.initializeTouchEvents
is no longer necessary and has been removed completely. Touch events now work automatically.TestUtils.findAllInRenderedTree
and related helpers are no longer able to take a DOM component, only a custom component.Due to the DOM node refs change mentioned above, this.getDOMNode()
is now deprecated and ReactDOM.findDOMNode(this)
can be used instead. Note that in most cases, calling findDOMNode
is now unnecessary – see the example above in the “DOM node refs” section.
If you have a large codebase, you can use our automated codemod script to change your code automatically.
setProps
and replaceProps
are now deprecated. Instead, call ReactDOM.render again at the top level with the new props.
ES6 component classes must now extend React.Component
in order to enable stateless function components. The ES3 module pattern will continue to work.
Reusing and mutating a style
object between renders has been deprecated. This mirrors our change to freeze the props
object.
Add-Ons: cloneWithProps
is now deprecated. Use React.cloneElement
instead (unlike cloneWithProps
, cloneElement
does not merge className
or style
automatically; you can merge them manually if needed).
Add-Ons: To improve reliability, CSSTransitionGroup
will no longer listen to transition events. Instead, you should specify transition durations manually using props such as transitionEnterTimeout={500}
.
React.Children.toArray
which takes a nested children object and returns a flat array with keys assigned to each child. This helper makes it easier to manipulate collections of children in your render
methods, especially if you want to reorder or slice this.props.children
before passing it down. In addition, React.Children.map
now returns plain arrays too.console.error
instead of console.warn
for warnings so that browsers show a full stack trace in the console. (Our warnings appear when you use patterns that will break in future releases and for code that is likely to behave unexpectedly, so we do consider our warnings to be “must-fix” errors.)Symbol
in browsers that support it, in order to ensure that React never considers untrusted JSON to be a valid element. If this extra security protection is important to you, you should add a Symbol
polyfill for older browsers, such as the one included by Babel’s polyfill.capture
, challenge
, inputMode
, is
, keyParams
, keyType
, minLength
, summary
, wrap
. It also now supports these non-standard attributes: autoSave
, results
, security
.xlinkActuate
, xlinkArcrole
, xlinkHref
, xlinkRole
, xlinkShow
, xlinkTitle
, xlinkType
, xmlBase
, xmlLang
, xmlSpace
.image
SVG tag is now supported by React DOM.is="..."
attribute).audio
and video
tags: onAbort
, onCanPlay
, onCanPlayThrough
, onDurationChange
, onEmptied
, onEncrypted
, onEnded
, onError
, onLoadedData
, onLoadedMetadata
, onLoadStart
, onPause
, onPlay
, onPlaying
, onProgress
, onRateChange
, onSeeked
, onSeeking
, onStalled
, onSuspend
, onTimeUpdate
, onVolumeChange
, onWaiting
.shallowCompare
add-on has been added as a migration path for PureRenderMixin
in ES6 classes.CSSTransitionGroup
can now use custom class names instead of appending -enter-active
or similar to the transition name.document.body
directly as the container to ReactDOM.render
now gives a warning as doing so can cause problems with browser extensions that modify the DOM.<option>
elements with multiple text children properly and renders <select>
elements on the server with the correct option selected.React.createElement('DIV')
) no longer causes problems, though we continue to recommend lowercase for consistency with the JSX tag name convention (lowercase names refer to built-in components, capitalized names refer to custom components).animationIterationCount
, boxOrdinalGroup
, flexOrder
, tabSize
, stopOpacity
.Simulate.mouseEnter
and Simulate.mouseLeave
now work.