mirror of
https://github.com/facebook/react.git
synced 2025-11-01 09:12:30 +00:00
Paul O’Shannessy
608 lines
60 KiB
XML
608 lines
60 KiB
XML
<?xml version="1.0" encoding="UTF-8"?>
|
|
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
|
|
<channel>
|
|
<title>React</title>
|
|
<description>A JavaScript library for building user interfaces</description>
|
|
<link>http://facebook.github.io/react</link>
|
|
<atom:link href="http://facebook.github.io/react/feed.xml" rel="self" type="application/rss+xml" />
|
|
|
|
<item>
|
|
<title>React v0.4.0</title>
|
|
<description><p>Over the past 2 months we&#39;ve been taking feedback and working hard to make React even better. We&#39;ve also added several features that awe didn&#39;t finish in time for the v0.3 launch, and are proud to announce the availability of React v0.4 today!</p>
|
|
|
|
<p>This release could not have happened without the support of our growing community. Since launch day, the community has contributed blog posts, questions to the <a href="http://groups.google.com/group/reactjs">Google Group</a>, and issues and pull requests on GitHub. We&#39;ve had contributions ranging from documentation improvements to major changes to React&#39;s rendering. We&#39;ve seen people integrate React into the tools they&#39;re using and the products they&#39;re building, and we&#39;re all very excited to see what our budding community builds next!</p>
|
|
|
|
<p>React v0.4 has some big changes. We&#39;ve also restructured the documentation to better communicate how to use React. We&#39;ve summarized the changes below and linked to documentation where we think it will be especially useful.</p>
|
|
|
|
<p>When you&#39;re ready, <a href="/react/downloads.html">go download it</a>!</p>
|
|
|
|
<h3>React</h3>
|
|
|
|
<ul>
|
|
<li>Switch from using <code>id</code> attribute to <code>data-reactid</code> to track DOM nodes. This allows you to integrate with other JS and CSS libraries more easily.</li>
|
|
<li>Support for more DOM elements and attributes (e.g., <code>&lt;canvas&gt;</code>)</li>
|
|
<li>Improved server-side rendering APIs. <code>React.renderComponentToString(&lt;component&gt;, callback)</code> allows you to use React on the server and generate markup which can be sent down to the browser.</li>
|
|
<li><code>prop</code> improvements: validation and default values. <a href="http://facebook.github.io/react/blog/2013/07/11/react-v0-4-prop-validation-and-default-values.html">Read our blog post for details...</a></li>
|
|
<li>Support for the <code>key</code> prop, which allows for finer control over reconciliation. <a href="http://facebook.github.io/react/docs/multiple-components.html">Read the docs for details...</a></li>
|
|
<li>Removed <code>React.autoBind</code>. <a href="http://facebook.github.io/react/blog/2013/07/02/react-v0-4-autobind-by-default.html">Read our blog post for details...</a></li>
|
|
<li>Improvements to forms. We&#39;ve written wrappers around <code>&lt;input&gt;</code>, <code>&lt;textarea&gt;</code>, <code>&lt;option&gt;</code>, and <code>&lt;select&gt;</code> in order to standardize many inconsistencies in browser implementations. This includes support for <code>defaultValue</code>, and improved implementation of the <code>onChange</code> event, and circuit completion. <a href="http://facebook.github.io/react/docs/forms.html">Read the docs for details...</a></li>
|
|
<li>We&#39;ve implemented an improved synthetic event system that conforms to the W3C spec.</li>
|
|
<li>Updates to your component are batched now, which may result in a significantly faster re-render of components. <code>this.setState</code> now takes an optional callback as it&#39;s second parameter. If you were using <code>onClick={this.setState.bind(this, state)}</code> previously, you&#39;ll want to make sure you add a third parameter so that the event is not treated as the callback.</li>
|
|
</ul>
|
|
|
|
<h3>JSX</h3>
|
|
|
|
<ul>
|
|
<li>Support for comment nodes <code>&lt;div&gt;{/* this is a comment and won&#39;t be rendered */}&lt;/div&gt;</code></li>
|
|
<li>Children are now transformed directly into arguments instead of being wrapped in an array
|
|
E.g. <code>&lt;div&gt;&lt;Component1/&gt;&lt;Component2&gt;&lt;/div&gt;</code> is transformed into <code>React.DOM.div(null, Component1(null), Component2(null))</code>.
|
|
Previously this would be transformed into <code>React.DOM.div(null, [Component1(null), Component2(null)])</code>.
|
|
If you were using React without JSX previously, your code should still work.</li>
|
|
</ul>
|
|
|
|
<h3>react-tools</h3>
|
|
|
|
<ul>
|
|
<li>Fixed a number of bugs when transforming directories</li>
|
|
<li>No longer re-write <code>require()</code>s to be relative unless specified</li>
|
|
</ul>
|
|
</description>
|
|
<pubDate>2013-07-17T00:00:00-07:00</pubDate>
|
|
<link>http://facebook.github.io/react/blog/2013/07/17/react-v0-4-0.html</link>
|
|
<guid isPermaLink="true">http://facebook.github.io/react/blog/2013/07/17/react-v0-4-0.html</guid>
|
|
</item>
|
|
|
|
<item>
|
|
<title>New in React v0.4: Prop Validation and Default Values</title>
|
|
<description><p>Many of the questions we got following the public launch of React revolved around <code>props</code>, specifically that people wanted to do validation and to make sure their components had sensible defaults.</p>
|
|
|
|
<h2>Validation</h2>
|
|
|
|
<p>Oftentimes you want to validate your <code>props</code> before you use them. Perhaps you want to ensure they are a specific type. Or maybe you want to restrict your prop to specific values. Or maybe you want to make a specific prop required. This was always possible — you could have written validations in your <code>render</code> or <code>componentWillReceiveProps</code> functions, but that gets clunky fast.</p>
|
|
|
|
<p>React v0.4 will provide a nice easy way for you to use built-in validators, or to even write your own.</p>
|
|
<div class="highlight"><pre><code class="js language-js" data-lang="js"><span class="nx">React</span><span class="p">.</span><span class="nx">createClass</span><span class="p">({</span>
|
|
<span class="nx">propTypes</span><span class="o">:</span> <span class="p">{</span>
|
|
<span class="c1">// An optional string prop named &quot;description&quot;.</span>
|
|
<span class="nx">description</span><span class="o">:</span> <span class="nx">React</span><span class="p">.</span><span class="nx">PropTypes</span><span class="p">.</span><span class="nx">string</span><span class="p">,</span>
|
|
|
|
<span class="c1">// A required enum prop named &quot;category&quot;.</span>
|
|
<span class="nx">category</span><span class="o">:</span> <span class="nx">React</span><span class="p">.</span><span class="nx">PropTypes</span><span class="p">.</span><span class="nx">oneOf</span><span class="p">([</span><span class="s1">&#39;News&#39;</span><span class="p">,</span><span class="s1">&#39;Photos&#39;</span><span class="p">]).</span><span class="nx">isRequired</span><span class="p">,</span>
|
|
|
|
<span class="c1">// A prop named &quot;dialog&quot; that requires an instance of Dialog.</span>
|
|
<span class="nx">dialog</span><span class="o">:</span> <span class="nx">React</span><span class="p">.</span><span class="nx">PropTypes</span><span class="p">.</span><span class="nx">instanceOf</span><span class="p">(</span><span class="nx">Dialog</span><span class="p">).</span><span class="nx">isRequired</span>
|
|
<span class="p">},</span>
|
|
<span class="p">...</span>
|
|
<span class="p">});</span>
|
|
</code></pre></div>
|
|
<h2>Default Values</h2>
|
|
|
|
<p>One common pattern we&#39;ve seen with our React code is to do something like this:</p>
|
|
<div class="highlight"><pre><code class="js language-js" data-lang="js"><span class="nx">React</span><span class="p">.</span><span class="nx">createClass</span><span class="p">({</span>
|
|
<span class="nx">render</span><span class="o">:</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
|
|
<span class="kd">var</span> <span class="nx">value</span> <span class="o">=</span> <span class="k">this</span><span class="p">.</span><span class="nx">props</span><span class="p">.</span><span class="nx">value</span> <span class="o">||</span> <span class="s1">&#39;default value&#39;</span><span class="p">;</span>
|
|
<span class="k">return</span> <span class="o">&lt;</span><span class="nx">div</span><span class="o">&gt;</span><span class="p">{</span><span class="nx">value</span><span class="p">}</span><span class="o">&lt;</span><span class="err">/div&gt;;</span>
|
|
<span class="p">}</span>
|
|
<span class="p">});</span>
|
|
</code></pre></div>
|
|
<p>Do this for a few <code>props</code> across a few components and now you have a lot of redundant code. Starting with React v0.4, you can provide default values in a declarative way:</p>
|
|
<div class="highlight"><pre><code class="js language-js" data-lang="js"><span class="nx">React</span><span class="p">.</span><span class="nx">createClass</span><span class="p">({</span>
|
|
<span class="nx">getDefaultProps</span><span class="o">:</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
|
|
<span class="k">return</span> <span class="p">{</span>
|
|
<span class="nx">value</span><span class="o">:</span> <span class="s1">&#39;default value&#39;</span>
|
|
<span class="p">};</span>
|
|
<span class="p">}</span>
|
|
<span class="p">...</span>
|
|
<span class="p">});</span>
|
|
</code></pre></div>
|
|
<p>We will use the cached result of this function before each <code>render</code>. We also perform all validations before each <code>render</code> to ensure that you have all of the data you need in the right form before you try to use it.</p>
|
|
|
|
<hr>
|
|
|
|
<p>Both of these features are entirely optional. We&#39;ve found them to be increasingly valuable at Facebook as our applications grow and evolve, and we hope others find them useful as well.</p>
|
|
</description>
|
|
<pubDate>2013-07-11T00:00:00-07:00</pubDate>
|
|
<link>http://facebook.github.io/react/blog/2013/07/11/react-v0-4-prop-validation-and-default-values.html</link>
|
|
<guid isPermaLink="true">http://facebook.github.io/react/blog/2013/07/11/react-v0-4-prop-validation-and-default-values.html</guid>
|
|
</item>
|
|
|
|
<item>
|
|
<title>Community Round-up #4</title>
|
|
<description><p>React reconciliation process appears to be very well suited to implement a text editor with a live preview as people at Khan Academy show us.</p>
|
|
|
|
<h2>Khan Academy</h2>
|
|
|
|
<p><a href="http://bjk5.com/">Ben Kamens</a> explains how <a href="http://benalpert.com/">Ben Alpert</a> and <a href="http://joelburget.com/">Joel Burget</a> are promoting React inside of <a href="https://www.khanacademy.org/">Khan Academy</a>. They now have three projects in the works using React.</p>
|
|
|
|
<blockquote>
|
|
<p>Recently two Khan Academy devs dropped into our team chat and said they were gonna use React to write a new feature. They even hinted that we may want to adopt it product-wide.</p>
|
|
|
|
<p>&quot;The library is only a week old. It&#39;s a brand new way of thinking about things. We&#39;re the first to use it outside of Facebook. Heck, even the React devs were surprised to hear we&#39;re using this in production!!!&quot;</p>
|
|
|
|
<p><a href="http://bjk5.com/post/53742233351/getting-your-team-to-adopt-new-technology">Read the full post...</a></p>
|
|
</blockquote>
|
|
|
|
<p>The best part is the demo of how React reconciliation process makes live editing more user-friendly.</p>
|
|
|
|
<blockquote>
|
|
<p>Our renderer, post-React, is on the left. A typical math editor&#39;s preview is on the right.
|
|
<figure><a href="http://bjk5.com/post/53742233351/getting-your-team-to-adopt-new-technology"><img src="/react/img/blog/monkeys.gif" width="70%" /></a></figure></p>
|
|
</blockquote>
|
|
|
|
<h2>React Snippets</h2>
|
|
|
|
<p>Over the past several weeks, members of our team, <a href="http://www.petehunt.net/">Pete Hunt</a> and <a href="http://zpao.com/">Paul O&#39;Shannessy</a>, answered many questions that were asked in the <a href="https://groups.google.com/forum/#!forum/reactjs">React group</a>. They give a good overview of how to integrate React with other libraries and APIs through the use of <a href="/react/docs/mixins.html">Mixins</a> and <a href="/react/docs/advanced-components.html">Lifecycle Methods</a>.</p>
|
|
|
|
<blockquote>
|
|
<p><a href="https://groups.google.com/forum/#!topic/reactjs/l6PnP8qbofk">Listening Scroll Event</a></p>
|
|
|
|
<ul>
|
|
<li><a href="http://jsfiddle.net/aabeL/1/">JSFiddle</a>: Basically I&#39;ve given you two mixins. The first lets you react to global scroll events. The second is, IMO, much more useful: it gives you scroll start and scroll end events, which you can use with setState() to create components that react based on whether the user is scrolling or not.</li>
|
|
</ul>
|
|
|
|
<p><a href="https://groups.google.com/forum/#!topic/reactjs/RVAY_eQmdpo">Fade-in Transition</a></p>
|
|
|
|
<ul>
|
|
<li><a href="http://jsfiddle.net/ufe8k/1/">JSFiddle</a>: Creating a new <code>&lt;FadeInWhenAdded&gt;</code> component and using jQuery <code>.fadeIn()</code> function on the DOM node.</li>
|
|
<li><a href="http://jsfiddle.net/R8f5L/5/">JSFiddle</a>: Using CSS transition instead.</li>
|
|
</ul>
|
|
|
|
<p><a href="https://groups.google.com/forum/#!topic/reactjs/pyUZBRWcHB4">Socket.IO Integration</a></p>
|
|
|
|
<ul>
|
|
<li><a href="https://gist.github.com/zpao/5686416">Gist</a>: The big thing to notice is that my component is pretty dumb (it doesn&#39;t have to be but that&#39;s how I chose to model it). All it does is render itself based on the props that are passed in. renderOrUpdate is where the &quot;magic&quot; happens.</li>
|
|
<li><a href="https://gist.github.com/petehunt/5687230">Gist</a>: This example is doing everything -- including the IO -- inside of a single React component.</li>
|
|
<li><a href="https://gist.github.com/petehunt/5687276">Gist</a>: One pattern that we use at Instagram a lot is to employ separation of concerns and consolidate I/O and state into components higher in the hierarchy to keep the rest of the components mostly stateless and purely display.</li>
|
|
</ul>
|
|
|
|
<p><a href="https://groups.google.com/forum/#!topic/reactjs/mHfBGI3Qwz4">Sortable jQuery Plugin Integration</a></p>
|
|
|
|
<ul>
|
|
<li><a href="http://jsfiddle.net/LQxy7/">JSFiddle</a>: Your React component simply render empty divs, and then in componentDidMount() you call React.renderComponent() on each of those divs to set up a new root React tree. Be sure to explicitly unmountAndReleaseReactRootNode() for each component in componentWillUnmount().</li>
|
|
</ul>
|
|
</blockquote>
|
|
|
|
<h2>Introduction to React Screencast</h2>
|
|
|
|
<p><a href="http://www.petehunt.net/">Pete Hunt</a> recorded himself implementing a simple <code>&lt;Blink&gt;</code> tag in React.</p>
|
|
|
|
<figure><iframe src="http://player.vimeo.com/video/67248575" width="500" height="340" frameborder="0" webkitAllowFullScreen mozallowfullscreen allowFullScreen></iframe></figure>
|
|
|
|
<h2>Snake in React</h2>
|
|
|
|
<p><a href="http://tomocchino.com/">Tom Occhino</a> implemented Snake in 150 lines with React.</p>
|
|
|
|
<blockquote>
|
|
<p><a href="https://github.com/tomocchino/react-snake/blob/master/src/snake.js">Check the source on Github</a>
|
|
<figure><a href="http://tomocchino.github.io/react-snake/"><img src="/react/img/blog/snake.png" alt=""></a></figure></p>
|
|
</blockquote>
|
|
</description>
|
|
<pubDate>2013-07-03T00:00:00-07:00</pubDate>
|
|
<link>http://facebook.github.io/react/blog/2013/07/03/community-roundup-4.html</link>
|
|
<guid isPermaLink="true">http://facebook.github.io/react/blog/2013/07/03/community-roundup-4.html</guid>
|
|
</item>
|
|
|
|
<item>
|
|
<title>New in React v0.4: Autobind by Default</title>
|
|
<description><p>React v0.4 is very close to completion. As we finish it off, we&#39;d like to share with you some of the major changes we&#39;ve made since v0.3. This is the first of several posts we&#39;ll be making over the next week.</p>
|
|
|
|
<h2>What is React.autoBind?</h2>
|
|
|
|
<p>If you take a look at most of our current examples, you&#39;ll see us using <code>React.autoBind</code> for event handlers. This is used in place of <code>Function.prototype.bind</code>. Remember that in JS, <a href="http://bonsaiden.github.io/JavaScript-Garden/#function.this">function calls are late-bound</a>. That means that if you simply pass a function around, the <code>this</code> used inside won&#39;t necessarily be the <code>this</code> you expect. <code>Function.prototype.bind</code> creates a new, properly bound, function so that when called, <code>this</code> is exactly what you expect it to be.</p>
|
|
|
|
<p>Before we launched React, we would write this:</p>
|
|
<div class="highlight"><pre><code class="js language-js" data-lang="js"><span class="nx">React</span><span class="p">.</span><span class="nx">createClass</span><span class="p">({</span>
|
|
<span class="nx">onClick</span><span class="o">:</span> <span class="kd">function</span><span class="p">(</span><span class="nx">event</span><span class="p">)</span> <span class="p">{</span><span class="cm">/* do something with this */</span><span class="p">},</span>
|
|
<span class="nx">render</span><span class="o">:</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
|
|
<span class="hll"> <span class="k">return</span> <span class="o">&lt;</span><span class="nx">button</span> <span class="nx">onClick</span><span class="o">=</span><span class="p">{</span><span class="k">this</span><span class="p">.</span><span class="nx">onClick</span><span class="p">.</span><span class="nx">bind</span><span class="p">(</span><span class="k">this</span><span class="p">)}</span> <span class="o">/&gt;</span><span class="p">;</span>
|
|
</span> <span class="p">}</span>
|
|
<span class="p">});</span>
|
|
</code></pre></div>
|
|
<p>We wrote <code>React.autoBind</code> as a way to cache the function creation and save on memory usage. Since <code>render</code> can get called multiple times, if you used <code>this.onClick.bind(this)</code> you would actually create a new function on each pass. With React v0.3 you were able to write this instead:</p>
|
|
<div class="highlight"><pre><code class="js language-js" data-lang="js"><span class="nx">React</span><span class="p">.</span><span class="nx">createClass</span><span class="p">({</span>
|
|
<span class="hll"> <span class="nx">onClick</span><span class="o">:</span> <span class="nx">React</span><span class="p">.</span><span class="nx">autoBind</span><span class="p">(</span><span class="kd">function</span><span class="p">(</span><span class="nx">event</span><span class="p">)</span> <span class="p">{</span><span class="cm">/* do something with this */</span><span class="p">}),</span>
|
|
</span> <span class="nx">render</span><span class="o">:</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
|
|
<span class="hll"> <span class="k">return</span> <span class="o">&lt;</span><span class="nx">button</span> <span class="nx">onClick</span><span class="o">=</span><span class="p">{</span><span class="k">this</span><span class="p">.</span><span class="nx">onClick</span><span class="p">}</span> <span class="o">/&gt;</span><span class="p">;</span>
|
|
</span> <span class="p">}</span>
|
|
<span class="p">});</span>
|
|
</code></pre></div>
|
|
<h2>What&#39;s Changing in v0.4?</h2>
|
|
|
|
<p>After using <code>React.autoBind</code> for a few weeks, we realized that there were very few times that we didn&#39;t want that behavior. So we made it the default! Now all methods defined within <code>React.createClass</code> will already be bound to the correct instance.</p>
|
|
|
|
<p>Starting with v0.4 you can just write this:</p>
|
|
<div class="highlight"><pre><code class="js language-js" data-lang="js"><span class="nx">React</span><span class="p">.</span><span class="nx">createClass</span><span class="p">({</span>
|
|
<span class="hll"> <span class="nx">onClick</span><span class="o">:</span> <span class="kd">function</span><span class="p">(</span><span class="nx">event</span><span class="p">)</span> <span class="p">{</span><span class="cm">/* do something with this */</span><span class="p">},</span>
|
|
</span> <span class="nx">render</span><span class="o">:</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
|
|
<span class="hll"> <span class="k">return</span> <span class="o">&lt;</span><span class="nx">button</span> <span class="nx">onClick</span><span class="o">=</span><span class="p">{</span><span class="k">this</span><span class="p">.</span><span class="nx">onClick</span><span class="p">}</span> <span class="o">/&gt;</span><span class="p">;</span>
|
|
</span> <span class="p">}</span>
|
|
<span class="p">});</span>
|
|
</code></pre></div>
|
|
<p>For v0.4 we will simply be making <code>React.autoBind</code> a no-op — it will just return the function you pass to it. Most likely you won&#39;t have to change your code to account for this change, though we encourage you to update. We&#39;ll publish a migration guide documenting this and other changes that come along with React v0.4.</p>
|
|
</description>
|
|
<pubDate>2013-07-02T00:00:00-07:00</pubDate>
|
|
<link>http://facebook.github.io/react/blog/2013/07/02/react-v0-4-autobind-by-default.html</link>
|
|
<guid isPermaLink="true">http://facebook.github.io/react/blog/2013/07/02/react-v0-4-autobind-by-default.html</guid>
|
|
</item>
|
|
|
|
<item>
|
|
<title>Community Round-up #3</title>
|
|
<description><p>The highlight of this week is that an interaction-heavy app has been ported to React. React components are solving issues they had with nested views.</p>
|
|
|
|
<h2>Moving From Backbone To React</h2>
|
|
|
|
<p><a href="http://twitter.com/clayallsopp">Clay Allsopp</a> successfuly ported <a href="http://usepropeller.com/blog/posts/from-backbone-to-react/">Propeller</a>, a fairly big, interaction-heavy JavaScript app, to React.</p>
|
|
|
|
<blockquote>
|
|
<p><a href="http://usepropeller.com/blog/posts/from-backbone-to-react/"><img style="float: right; margin: 0 0 10px 10px;" src="/react/img/blog/propeller-logo.png" /></a>Subviews involve a lot of easy-to-forget boilerplate that Backbone (by design) doesn&#39;t automate. Libraries like Backbone.Marionette offer more abstractions to make view nesting easier, but they&#39;re all limited by the fact that Backbone delegates how and went view-document attachment occurs to the application code.</p>
|
|
|
|
<p>React, on the other hand, manages the DOM and only exposes real nodes at select points in its API. The &quot;elements&quot; you code in React are actually objects which wrap DOM nodes, not the actual objects which get inserted into the DOM. Internally, React converts those abstractions into actual DOMElements and fills out the document accordingly. [...]</p>
|
|
|
|
<p>We moved about 20 different Backbone view classes to React over the past few weeks, including the live-preview pane that you see in our little iOS demo. Most importantly, it&#39;s allowed us to put energy into making each component work great on its own, instead of spending extra cycles to ensure they function in unison. For that reason, we think React is a more scalable way to build view-intensive apps than Backbone alone, and it doesn&#39;t require you to drop-everything-and-refactor like a move to Ember or Angular would demand.</p>
|
|
|
|
<p><a href="http://usepropeller.com/blog/posts/from-backbone-to-react/">Read the full post...</a></p>
|
|
</blockquote>
|
|
|
|
<h2>Grunt Task for JSX</h2>
|
|
|
|
<p><a href="http://ericclemmons.github.io/">Eric Clemmons</a> wrote a task for <a href="http://gruntjs.com/">Grunt</a> that applies the JSX transformation to your Javascript files. It also works with <a href="http://browserify.org/">Browserify</a> if you want all your files to be concatenated and minified together.</p>
|
|
|
|
<blockquote>
|
|
<p>Grunt task for compiling Facebook React&#39;s .jsx templates into .js</p>
|
|
<div class="highlight"><pre><code class="javascript language-javascript" data-lang="javascript"><span class="nx">grunt</span><span class="p">.</span><span class="nx">initConfig</span><span class="p">({</span>
|
|
<span class="nx">react</span><span class="o">:</span> <span class="p">{</span>
|
|
<span class="nx">app</span><span class="o">:</span> <span class="p">{</span>
|
|
<span class="nx">options</span><span class="o">:</span> <span class="p">{</span> <span class="nx">extension</span><span class="o">:</span> <span class="s1">&#39;js&#39;</span> <span class="p">},</span>
|
|
<span class="nx">files</span><span class="o">:</span> <span class="p">{</span> <span class="s1">&#39;path/to/output/dir&#39;</span><span class="o">:</span> <span class="s1">&#39;path/to/jsx/templates/dir&#39;</span> <span class="p">}</span>
|
|
</code></pre></div>
|
|
<p>It also works great with <code>grunt-browserify</code>!</p>
|
|
<div class="highlight"><pre><code class="javascript language-javascript" data-lang="javascript"><span class="nx">browserify</span><span class="o">:</span> <span class="p">{</span>
|
|
<span class="nx">options</span><span class="o">:</span> <span class="p">{</span>
|
|
<span class="nx">transform</span><span class="o">:</span> <span class="p">[</span> <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;grunt-react&#39;</span><span class="p">).</span><span class="nx">browserify</span> <span class="p">]</span>
|
|
<span class="p">},</span>
|
|
<span class="nx">app</span><span class="o">:</span> <span class="p">{</span>
|
|
<span class="nx">src</span><span class="o">:</span> <span class="s1">&#39;path/to/source/main.js&#39;</span><span class="p">,</span>
|
|
<span class="nx">dest</span><span class="o">:</span> <span class="s1">&#39;path/to/target/output.js&#39;</span>
|
|
</code></pre></div>
|
|
<p><a href="https://github.com/ericclemmons/grunt-react">Check out the project ...</a></p>
|
|
</blockquote>
|
|
|
|
<h2>Backbone/Handlebars Nested Views</h2>
|
|
|
|
<p><a href="http://joelburget.com/">Joel Burget</a> wrote a blog post talking about the way we would write React-like components in Backbone and Handlebars.</p>
|
|
|
|
<blockquote>
|
|
<p>The problem here is that we&#39;re trying to maniplate a tree, but there&#39;s a textual layer we have to go through. Our views are represented as a tree - the subviews are children of CommentCollectionView - and they end up as part of a tree in the DOM. But there&#39;s a Handlebars layer in the middle (which deals in flat strings), so the hierarchy must be destructed and rebuilt when we render.</p>
|
|
|
|
<p>What does it take to render a collection view? In the Backbone/Handlebars view of the world you have to render the template (with stubs), render each subview which replaces a stub, and keep a reference to each subview (or anything within the view that could change in the future).</p>
|
|
|
|
<p>So while our view is conceptually hierarchical, due to the fact that it has to go through a flat textual representation, we need to do a lot of extra work to reassemble that structure after rendering.</p>
|
|
|
|
<p><a href="http://joelburget.com/react/">Read the full post...</a></p>
|
|
</blockquote>
|
|
|
|
<h2>JSRomandie Meetup</h2>
|
|
|
|
<p><a href="https://twitter.com/renajohn/">Renault John Lecoultre</a> from <a href="http://www.bugbuster.com">BugBuster</a> did a React introduction talk at a JS meetup called <a href="https://twitter.com/jsromandie">JS Romandie</a> last week.</p>
|
|
|
|
<script async class="speakerdeck-embed" data-id="888a9d50c01b01300df36658d0894ac1" data-ratio="1.33333333333333" src="//speakerdeck.com/assets/embed.js"></script>
|
|
|
|
<h2>CoffeeScript integration</h2>
|
|
|
|
<p><a href="http://blog.vjeux.com/">Vjeux</a> used the fact that JSX is just a syntactic sugar on-top of regular JS to rewrite the React front-page examples in CoffeeScript.</p>
|
|
|
|
<blockquote>
|
|
<p>Multiple people asked what&#39;s the story about JSX and CoffeeScript. There is no JSX pre-processor for CoffeeScript and I&#39;m not aware of anyone working on it. Fortunately, CoffeeScript is pretty expressive and we can play around the syntax to come up with something that is usable.</p>
|
|
<div class="highlight"><pre><code class="javascript language-javascript" data-lang="javascript"><span class="p">{</span><span class="nx">div</span><span class="p">,</span> <span class="nx">h3</span><span class="p">,</span> <span class="nx">textarea</span><span class="p">}</span> <span class="o">=</span> <span class="nx">React</span><span class="p">.</span><span class="nx">DOM</span>
|
|
<span class="p">(</span><span class="nx">div</span> <span class="p">{</span><span class="nx">className</span><span class="o">:</span> <span class="s1">&#39;MarkdownEditor&#39;</span><span class="p">},</span> <span class="p">[</span>
|
|
<span class="p">(</span><span class="nx">h3</span> <span class="p">{},</span> <span class="s1">&#39;Input&#39;</span><span class="p">),</span>
|
|
<span class="p">(</span><span class="nx">textarea</span> <span class="p">{</span><span class="nx">onKeyUp</span><span class="o">:</span> <span class="err">@</span><span class="nx">handleKeyUp</span><span class="p">,</span> <span class="nx">ref</span><span class="o">:</span> <span class="s1">&#39;textarea&#39;</span><span class="p">},</span>
|
|
<span class="err">@</span><span class="nx">state</span><span class="p">.</span><span class="nx">value</span>
|
|
<span class="p">)</span>
|
|
<span class="p">])</span>
|
|
</code></pre></div>
|
|
<p><a href="http://blog.vjeux.com/2013/javascript/react-coffeescript.html">Read the full post...</a></p>
|
|
</blockquote>
|
|
|
|
<h2>Tutorial in Plain Javascript</h2>
|
|
|
|
<p>We&#39;ve seen a lot of people comparing React with various frameworks. <a href="http://ricardo.cc/">Ricardo Tomasi</a> decided to re-implement the tutorial without any framework, just plain Javascript.</p>
|
|
|
|
<blockquote>
|
|
<p>Facebook &amp; Instagram launched the React framework and an accompanying tutorial. Developer Vlad Yazhbin decided to rewrite that using AngularJS. The end result is pretty neat, but if you&#39;re like me you will not actually appreciate the HTML speaking for itself and doing all the hard work. So let&#39;s see what that looks like in plain javascript.</p>
|
|
|
|
<p><a href="http://ricardo.cc/2013/06/07/react-tutorial-rewritten-in-plain-javascript.html">Read the full post...</a></p>
|
|
</blockquote>
|
|
</description>
|
|
<pubDate>2013-06-27T00:00:00-07:00</pubDate>
|
|
<link>http://facebook.github.io/react/blog/2013/06/27/community-roundup-3.html</link>
|
|
<guid isPermaLink="true">http://facebook.github.io/react/blog/2013/06/27/community-roundup-3.html</guid>
|
|
</item>
|
|
|
|
<item>
|
|
<title>React v0.3.3</title>
|
|
<description><p>We have a ton of great stuff coming in v0.4, but in the meantime we&#39;re releasing v0.3.3. This release addresses some small issues people were having and simplifies our tools to make them easier to use.</p>
|
|
|
|
<h2>react-tools</h2>
|
|
|
|
<ul>
|
|
<li>Upgrade Commoner so <code>require</code> statements are no longer relativized when passing through the transformer. This was a feature needed when building React, but doesn&#39;t translate well for other consumers of <code>bin/jsx</code>.</li>
|
|
<li>Upgraded our dependencies on Commoner and Recast so they use a different directory for their cache.</li>
|
|
<li>Freeze our esprima dependency.</li>
|
|
</ul>
|
|
|
|
<h2>React</h2>
|
|
|
|
<ul>
|
|
<li>Allow reusing the same DOM node to render different components. e.g. <code>React.renderComponent(&lt;div/&gt;, domNode); React.renderComponent(&lt;span/&gt;, domNode);</code> will work now.</li>
|
|
</ul>
|
|
|
|
<h2>JSXTransformer</h2>
|
|
|
|
<ul>
|
|
<li>Improved the in-browser transformer so that transformed scripts will execute in the expected scope. The allows components to be defined and used from separate files.</li>
|
|
</ul>
|
|
</description>
|
|
<pubDate>2013-06-21T00:00:00-07:00</pubDate>
|
|
<link>http://facebook.github.io/react/blog/2013/06/21/react-v0-3-3.html</link>
|
|
<guid isPermaLink="true">http://facebook.github.io/react/blog/2013/06/21/react-v0-3-3.html</guid>
|
|
</item>
|
|
|
|
<item>
|
|
<title>Community Round-up #2</title>
|
|
<description><p>Since the launch we have received a lot of feedback and are actively working on React 0.4. In the meantime, here are the highlights of this week.</p>
|
|
|
|
<h2>Some quick thoughts on React</h2>
|
|
|
|
<p><a href="http://www.andrewgreig.com/">Andrew Greig</a> made a blog post that gives a high level description of what React is.</p>
|
|
|
|
<blockquote>
|
|
<p>I have been using Facebooks recently released Javascript framework called React.js for the last few days and have managed to obtain a rather high level understanding of how it works and formed a good perspective on how it fits in to the entire javascript framework ecosystem.</p>
|
|
|
|
<p>Basically, React is not an MVC framework. It is not a replacement for Backbone or Knockout or Angular, instead it is designed to work with existing frameworks and help extend their functionality.</p>
|
|
|
|
<p>It is designed for building big UIs. The type where you have lots of reusable components that are handling events and presenting and changing some backend data. In a traditional MVC app, React fulfils the role of the View. So you would still need to handle the Model and Controller on your own.</p>
|
|
|
|
<p>I found the best way to utilise React was to pair it with Backbone, with React replacing the Backbone View, or to write your own Model/Data object and have React communicate with that.</p>
|
|
|
|
<p><a href="http://www.andrewgreig.com/637/">Read the full post...</a></p>
|
|
</blockquote>
|
|
|
|
<h2>React and Socket.IO Chat Application</h2>
|
|
|
|
<p><a href="http://danialk.github.io/">Danial Khosravi</a> made a real-time chat application that interacts with the back-end using Socket.IO.</p>
|
|
|
|
<blockquote>
|
|
<p>A week ago I was playing with AngularJS and <a href="https://github.com/btford/angular-socket-io-im">this little chat application</a> which uses socket.io and nodejs for realtime communication. Yesterday I saw a post about ReactJS in <a href="http://www.echojs.com/">EchoJS</a> and started playing with this UI library. After playing a bit with React, I decided to write and chat application using React and I used Bran Ford&#39;s Backend for server side of this little app.
|
|
<figure><a href="http://danialk.github.io/blog/2013/06/16/reactjs-and-socket-dot-io-chat-application/"><img src="/react/img/blog/chatapp.png" alt=""></a></figure></p>
|
|
|
|
<p><a href="http://danialk.github.io/blog/2013/06/16/reactjs-and-socket-dot-io-chat-application/">Read the full post...</a></p>
|
|
</blockquote>
|
|
|
|
<h2>React and Other Frameworks</h2>
|
|
|
|
<p><a href="http://www.petehunt.net/blog/">Pete Hunt</a> wrote an answer on Quora comparing React and Angular directives. At the end, he explains how you can make an Angular directive that is in fact being rendered with React.</p>
|
|
|
|
<blockquote>
|
|
<p>To set the record straight: React components are far more powerful than Angular templates; they should be compared with Angular&#39;s directives instead. So I took the first Google hit for &quot;AngularJS directive tutorial&quot; (AngularJS Directives Tutorial - Fundoo Solutions), rewrote it in React and compared them. [...]</p>
|
|
|
|
<p>We&#39;ve designed React from the beginning to work well with other libraries. Angular is no exception. Let&#39;s take the original Angular example and use React to implement the fundoo-rating directive.</p>
|
|
|
|
<p><a href="http://www.quora.com/Pete-Hunt/Posts/Facebooks-React-vs-AngularJS-A-Closer-Look">Read the full post...</a></p>
|
|
</blockquote>
|
|
|
|
<p>In the same vein, <a href="https://twitter.com/markov_twain/status/345702941845499906">Markov Twain</a> re-implemented the examples on the front-page <a href="http://jsbin.com/azihiw/2/edit">with Ember</a> and <a href="https://twitter.com/vla">Vlad Yazhbin</a> re-implemented the tutorial <a href="http://jsfiddle.net/vla/Cdrse/">with Angular</a>.</p>
|
|
|
|
<h2>Web Components: React &amp; x-tags</h2>
|
|
|
|
<p>Mozilla and Google are actively working on Web Components. <a href="http://blog.vjeux.com/">Vjeux</a> wrote a proof of concept that shows how to implement them using React.</p>
|
|
|
|
<blockquote>
|
|
<p>Using <a href="http://www.x-tags.org/">x-tags</a> from Mozilla, we can write custom tags within the DOM. This is a great opportunity to be able to write reusable components without being tied to a particular library. I wrote <a href="https://github.com/vjeux/react-xtags/">x-react</a> to have them being rendered in React.
|
|
<figure><a href="http://blog.vjeux.com/2013/javascript/custom-components-react-x-tags.html"><img src="/react/img/blog/xreact.png" alt=""></a></figure></p>
|
|
|
|
<p><a href="http://blog.vjeux.com/2013/javascript/custom-components-react-x-tags.html">Read the full post...</a></p>
|
|
</blockquote>
|
|
|
|
<h2>React TodoMVC Example</h2>
|
|
|
|
<p><a href="http://todomvc.com/">TodoMVC.com</a> is a website that collects various implementations of the same basic Todo app. <a href="http://www.petehunt.net/blog/">Pete Hunt</a> wrote an idiomatic React version.</p>
|
|
|
|
<blockquote>
|
|
<p>Developers these days are spoiled with choice when it comes to selecting an MV* framework for structuring and organizing their JavaScript web apps.</p>
|
|
|
|
<p>To help solve this problem, we created TodoMVC - a project which offers the same Todo application implemented using MV* concepts in most of the popular JavaScript MV* frameworks of today.
|
|
<figure><a href="http://todomvc.com/labs/architecture-examples/react/"><img src="/react/img/blog/todomvc.png" alt=""></a></figure></p>
|
|
|
|
<p><a href="https://github.com/tastejs/todomvc/tree/gh-pages/labs/architecture-examples/react">Read the source code...</a></p>
|
|
</blockquote>
|
|
|
|
<h2>JSX is not HTML</h2>
|
|
|
|
<p>Many of you pointed out differences between JSX and HTML. In order to clear up some confusion, we have added some documentation that covers the four main differences:</p>
|
|
|
|
<ul>
|
|
<li><a href="http://facebook.github.io/react/docs/jsx-is-not-html.html">Whitespace removal</a></li>
|
|
<li><a href="http://facebook.github.io/react/docs/jsx-is-not-html.html">HTML Entities</a></li>
|
|
<li><a href="http://facebook.github.io/react/docs/jsx-is-not-html.html">Comments</a></li>
|
|
<li><a href="http://facebook.github.io/react/docs/jsx-is-not-html.html">Custom HTML Attributes</a></li>
|
|
</ul>
|
|
</description>
|
|
<pubDate>2013-06-19T00:00:00-07:00</pubDate>
|
|
<link>http://facebook.github.io/react/blog/2013/06/19/community-roundup-2.html</link>
|
|
<guid isPermaLink="true">http://facebook.github.io/react/blog/2013/06/19/community-roundup-2.html</guid>
|
|
</item>
|
|
|
|
<item>
|
|
<title>Community Round-up #1</title>
|
|
<description><p>React was open sourced two weeks ago and it&#39;s time for a little round-up of what has been going on.</p>
|
|
|
|
<h2>Khan Academy Question Editor</h2>
|
|
|
|
<p>It looks like <a href="http://benalpert.com/">Ben Alpert</a> is the first person outside of Facebook and Instagram to push React code to production. We are very grateful for his contributions in form of pull requests, bug reports and presence on IRC (<a href="irc://chat.freenode.net/reactjs">#reactjs on Freenode</a>). Ben wrote about his experience using React:</p>
|
|
|
|
<blockquote>
|
|
<p>I just rewrote a 2000-line project in React and have now made a handful of pull requests to React. Everything about React I&#39;ve seen so far seems really well thought-out and I&#39;m proud to be the first non-FB/IG production user of React.</p>
|
|
|
|
<p>The project that I rewrote in React (and am continuing to improve) is the Khan Academy question editor which content creators can use to enter questions and hints that will be presented to students:
|
|
<figure><a href="http://benalpert.com/2013/06/09/using-react-to-speed-up-khan-academy.html"><img src="/react/img/blog/khan-academy-editor.png" alt=""></a></figure></p>
|
|
|
|
<p><a href="http://benalpert.com/2013/06/09/using-react-to-speed-up-khan-academy.html">Read the full post...</a></p>
|
|
</blockquote>
|
|
|
|
<h2>Pimp my Backbone.View (by replacing it with React)</h2>
|
|
|
|
<p><a href="https://blog.mayflower.de/">Paul Seiffert</a> wrote a blog post that explains how to integrate React into Backbone applications.</p>
|
|
|
|
<blockquote>
|
|
<p>React has some interesting concepts for JavaScript view objects that can be used to eliminate this one big problem I have with Backbone.js.</p>
|
|
|
|
<p>As in most MVC implementations (although React is probably just a VC implementation), a view is one portion of the screen that is managed by a controlling object. This object is responsible for deciding when to re-render the view and how to react to user input. With React, these view-controllers objects are called components. A component knows how to render its view and how to handle to the user&#39;s interaction with it.</p>
|
|
|
|
<p>The interesting thing is that React is figuring out by itself when to re-render a view and how to do this in the most efficient way.</p>
|
|
|
|
<p><a href="https://blog.mayflower.de/3937-Backbone-React.html">Read the full post...</a></p>
|
|
</blockquote>
|
|
|
|
<h2>Using facebook&#39;s React with require.js</h2>
|
|
|
|
<p><a href="http://blog.xenji.com/">Mario Mueller</a> wrote a menu component in React and was able to easily integrate it with require.js, EventEmitter2 and bower.</p>
|
|
|
|
<blockquote>
|
|
<p>I recently stumbled upon facebook&#39;s React library, which is a Javascript library for building reusable frontend components. Even if this lib is only at version 0.3.x it behaves very stable, it is fast and is fun to code. I&#39;m a big fan of require.js, so I tried to use React within the require.js eco system. It was not as hard as expected and here are some examples and some thoughts about it.</p>
|
|
|
|
<p><a href="http://blog.xenji.com/2013/06/facebooks-react-require-js.html">Read the full post...</a></p>
|
|
</blockquote>
|
|
|
|
<h2>Origins of React</h2>
|
|
|
|
<p><a href="http://www.petehunt.net/blog/">Pete Hunt</a> explained what differentiates React from other JavaScript libraries in <a href="http://facebook.github.io/react/blog/2013/06/05/why-react.html">a previous blog post</a>. <a href="http://leebyron.com/">Lee Byron</a> gives another perspective on Quora:</p>
|
|
|
|
<blockquote>
|
|
<p>React isn&#39;t quite like any other popular Javascript libraries, and it solves a very specific problem: complex UI rendering. It&#39;s also intended to be used along side many other popular libraries. For example, React works well with Backbone.js, amongst many others.</p>
|
|
|
|
<p>React was born out of frustrations with the common pattern of writing two-way data bindings in complex MVC apps. React is an implementation of one-way data bindings.</p>
|
|
|
|
<p><a href="http://www.quora.com/React-JS-Library/How-is-Facebooks-React-JavaScript-library/answer/Lee-Byron?srid=3DcX">Read the full post...</a></p>
|
|
</blockquote>
|
|
</description>
|
|
<pubDate>2013-06-12T00:00:00-07:00</pubDate>
|
|
<link>http://facebook.github.io/react/blog/2013/06/12/community-roundup.html</link>
|
|
<guid isPermaLink="true">http://facebook.github.io/react/blog/2013/06/12/community-roundup.html</guid>
|
|
</item>
|
|
|
|
<item>
|
|
<title>Why did we build React?</title>
|
|
<description><p>There are a lot of JavaScript MVC frameworks out there. Why did we build React
|
|
and why would you want to use it?</p>
|
|
|
|
<h2>React isn&#39;t an MVC framework.</h2>
|
|
|
|
<p>React is a library for building composable user interfaces. It encourages
|
|
the creation of reusable UI components which present data that changes over
|
|
time.</p>
|
|
|
|
<h2>React doesn&#39;t use templates.</h2>
|
|
|
|
<p>Traditionally, web application UIs are built using templates or HTML directives.
|
|
These templates dictate the full set of abstractions that you are allowed to use
|
|
to build your UI.</p>
|
|
|
|
<p>React approaches building user interfaces differently by breaking them into
|
|
<strong>components</strong>. This means React uses JavaScript to generate markup, which we
|
|
see as an advantage over templates for a few reasons:</p>
|
|
|
|
<ul>
|
|
<li><strong>JavaScript is a flexible, powerful programming language</strong> with the ability
|
|
to build abstractions. This is incredibly important in large applications.</li>
|
|
<li>By unifying your markup with its corresponding view logic, React can actually
|
|
make views <strong>easier to extend and maintain</strong>.</li>
|
|
<li>By baking an understanding of markup and content into JavaScript, there&#39;s
|
|
<strong>no manual string concatenation</strong> and therefore less surface area for XSS
|
|
vulnerabilities.</li>
|
|
</ul>
|
|
|
|
<p>We&#39;ve also created <a href="http://facebook.github.io/react/docs/syntax.html">JSX</a>, an optional
|
|
syntax extension, in case you prefer the readability of HTML to raw JavaScript.</p>
|
|
|
|
<h2>Reactive updates are dead simple.</h2>
|
|
|
|
<p>React really shines when your data changes over time.</p>
|
|
|
|
<p>In a traditional JavaScript application, you need to look at what data changed
|
|
and imperatively make changes to the DOM to keep it up-to-date. Even AngularJS,
|
|
which provides a declarative interface via directives and data binding <a href="http://docs.angularjs.org/guide/directive#reasonsbehindthecompilelinkseparation">requires
|
|
a linking function to manually update DOM nodes</a>.</p>
|
|
|
|
<p>React takes a different approach.</p>
|
|
|
|
<p>When your component is first initialized, the <code>render</code> method is called,
|
|
generating a lightweight representation of your view. From that representation,
|
|
a string of markup is produced, and injected into the document. When your data
|
|
changes, the <code>render</code> method is called again. In order to perform updates as
|
|
efficiently as possible, we diff the return value from the previous call to
|
|
<code>render</code> with the new one, and generate a minimal set of changes to be applied
|
|
to the DOM.</p>
|
|
|
|
<blockquote>
|
|
<p>The data returned from <code>render</code> is neither a string nor a DOM node -- it&#39;s a
|
|
lightweight description of what the DOM should look like.</p>
|
|
</blockquote>
|
|
|
|
<p>We call this process <strong>reconciliation</strong>. Check out
|
|
<a href="http://jsfiddle.net/fv6RD/3/">this jsFiddle</a> to see an example of
|
|
reconciliation in action.</p>
|
|
|
|
<p>Because this re-render is so fast (around 1ms for TodoMVC), the developer
|
|
doesn&#39;t need to explicitly specify data bindings. We&#39;ve found this approach
|
|
makes it easier to build apps.</p>
|
|
|
|
<h2>HTML is just the beginning.</h2>
|
|
|
|
<p>Because React has its own lightweight representation of the document, we can do
|
|
some pretty cool things with it:</p>
|
|
|
|
<ul>
|
|
<li>Facebook has dynamic charts that render to <code>&lt;canvas&gt;</code> instead of HTML.</li>
|
|
<li>Instagram is a &quot;single page&quot; web app built entirely with React and
|
|
<code>Backbone.Router</code>. Designers regularly contribute React code with JSX.</li>
|
|
<li>We&#39;ve built internal prototypes that run React apps in a web worker and use
|
|
React to drive <strong>native iOS views</strong> via an Objective-C bridge.</li>
|
|
<li>You can run React
|
|
<a href="http://github.com/petehunt/react-server-rendering">on the server</a>
|
|
for SEO, performance, code sharing and overall flexibility.</li>
|
|
<li>Events behave in a consistent, standards-compliant way in all browsers
|
|
(including IE8) and automatically use
|
|
<a href="http://davidwalsh.name/event-delegate">event delegation</a>.</li>
|
|
</ul>
|
|
|
|
<p>Head on over to
|
|
<a href="http://facebook.github.io/react">facebook.github.io/react</a> to check
|
|
out what we have built. Our documentation is geared towards building
|
|
apps with the framework, but if you are interested in the
|
|
nuts and bolts
|
|
<a href="http://facebook.github.io/react/support.html">get in touch</a> with us!</p>
|
|
|
|
<p>Thanks for reading!</p>
|
|
</description>
|
|
<pubDate>2013-06-05T00:00:00-07:00</pubDate>
|
|
<link>http://facebook.github.io/react/blog/2013/06/05/why-react.html</link>
|
|
<guid isPermaLink="true">http://facebook.github.io/react/blog/2013/06/05/why-react.html</guid>
|
|
</item>
|
|
|
|
<item>
|
|
<title>JSFiddle Integration</title>
|
|
<description><p><a href="http://jsfiddle.net">JSFiddle</a> just announced support for React. This is an exciting news as it makes collaboration on snippets of code a lot easier. You can play around this <strong><a href="http://jsfiddle.net/vjeux/kb3gN/">base React JSFiddle</a></strong>, fork it and share it! A <a href="http://jsfiddle.net/vjeux/VkebS/">fiddle without JSX</a> is also available.</p>
|
|
|
|
<blockquote class="twitter-tweet" align="center"><p>React (by Facebook) is now available on JSFiddle. <a href="http://t.co/wNQf9JPv5u" title="http://facebook.github.io/react/">facebook.github.io/react/</a></p>&mdash; JSFiddle (@jsfiddle) <a href="https://twitter.com/jsfiddle/status/341114115781177344">June 2, 2013</a></blockquote>
|
|
|
|
<script async src="//platform.twitter.com/widgets.js" charset="utf-8"></script>
|
|
</description>
|
|
<pubDate>2013-06-02T00:00:00-07:00</pubDate>
|
|
<link>http://facebook.github.io/react/blog/2013/06/02/jsfiddle-integration.html</link>
|
|
<guid isPermaLink="true">http://facebook.github.io/react/blog/2013/06/02/jsfiddle-integration.html</guid>
|
|
</item>
|
|
|
|
</channel>
|
|
</rss>
|