diff --git a/.gitignore b/.gitignore
index 319bab66ca..21728725b2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -15,7 +15,7 @@ docs/code
docs/_site
docs/.sass-cache
docs/js/*
-docs/downloads
+docs/downloads/*.zip
docs/vendor/bundle
examples/shared/*.js
examples/**/bundle.js
diff --git a/.travis.yml b/.travis.yml
index e2271f6e5d..82ecf2cc87 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -39,7 +39,7 @@ script:
bundle exec rake release
cd $GH_PAGES_DIR
git status
- if ! git diff-index --quiet HEAD --; then
+ if test -n "$(git status --porcelain)"; then
git add -A .
git commit -m "Rebuild website"
git push origin gh-pages
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4cbd79d110..5d09740182 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,30 @@
+## 15.4.0 (November 16, 2016)
+
+### React
+* React package and browser build no longer "secretly" includes React DOM. ([@sebmarkbage](https://github.com/sebmarkbage) in [#7164](https://github.com/facebook/react/pull/7164) and [#7168](https://github.com/facebook/react/pull/7168))
+* Required PropTypes now fail with specific messages for null and undefined. ([@chenglou](https://github.com/chenglou) in [#7291](https://github.com/facebook/react/pull/7291))
+* Improved development performance by freezing children instead of copying. ([@keyanzhang](https://github.com/keyanzhang) in [#7455](https://github.com/facebook/react/pull/7455))
+
+### React DOM
+* Fixed occasional test failures when React DOM is used together with shallow renderer. ([@goatslacker](https://github.com/goatslacker) in [#8097](https://github.com/facebook/react/pull/8097))
+* Added a warning for invalid `aria-` attributes. ([@jessebeach](https://github.com/jessebeach) in [#7744](https://github.com/facebook/react/pull/7744))
+* Added a warning for using `autofocus` rather than `autoFocus`. ([@hkal](https://github.com/hkal) in [#7694](https://github.com/facebook/react/pull/7694))
+* Removed an unnecessary warning about polyfilling `String.prototype.split`. ([@nhunzaker](https://github.com/nhunzaker) in [#7629](https://github.com/facebook/react/pull/7629))
+* Clarified the warning about not calling PropTypes manually. ([@jedwards1211](https://github.com/jedwards1211) in [#7777](https://github.com/facebook/react/pull/7777))
+* The unstable `batchedUpdates` API now passes the wrapped function's return value through. ([@bgnorlov](https://github.com/bgnorlov) in [#7444](https://github.com/facebook/react/pull/7444))
+* Fixed a bug with updating text in IE 8. ([@mnpenner](https://github.com/mnpenner) in [#7832](https://github.com/facebook/react/pull/7832))
+
+### React Perf
+* When ReactPerf is started, you can now view the relative time spent in components as a chart in Chrome Timeline. ([@gaearon](https://github.com/gaearon) in [#7549](https://github.com/facebook/react/pull/7549))
+
+### React Test Utils
+* If you call `Simulate.click()` on a `` then `foo` will get called whereas it didn't before. ([@nhunzaker](https://github.com/nhunzaker) in [#7642](https://github.com/facebook/react/pull/7642))
+
+### React Test Renderer
+* Due to packaging changes, it no longer crashes when imported together with React DOM in the same file. ([@sebmarkbage](https://github.com/sebmarkbage) in [#7164](https://github.com/facebook/react/pull/7164) and [#7168](https://github.com/facebook/react/pull/7168))
+* `ReactTestRenderer.create()` now accepts `{createNodeMock: element => mock}` as an optional argument so you can mock refs with snapshot testing. ([@Aweary](https://github.com/Aweary) in [#7649](https://github.com/facebook/react/pull/7649), [#8261](https://github.com/facebook/react/pull/8261))
+
+
## 15.3.2 (September 19, 2016)
### React
diff --git a/README.md b/README.md
index a2201bcf2b..b592026357 100644
--- a/README.md
+++ b/README.md
@@ -13,11 +13,11 @@ React is a JavaScript library for building user interfaces.
We have several examples [on the website](https://facebook.github.io/react/). Here is the first one to get you started:
```js
-var HelloMessage = React.createClass({
- render: function() {
+class HelloMessage extends React.Component {
+ render() {
return
Hello {this.props.name}
;
}
-});
+}
ReactDOM.render(
,
@@ -35,12 +35,12 @@ The fastest way to get started is to serve JavaScript from a CDN. We're using [u
```html
-
+
-
+
```
-We've also built a [starter kit](https://facebook.github.io/react/downloads/react-15.3.2.zip) which might be useful if this is your first time using React. It includes a webpage with an example of using React with live code.
+We've also built a [starter kit](https://facebook.github.io/react/downloads/react-15.4.0.zip) which might be useful if this is your first time using React. It includes a webpage with an example of using React with live code.
If you'd like to use [bower](http://bower.io), it's as easy as:
diff --git a/docs/README.md b/docs/README.md
index 50448f4a71..f03c32dc2c 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -34,7 +34,7 @@ Use Jekyll to serve the website locally (by default, at `http://localhost:4000`)
$ cd react/docs
$ bundle exec rake
$ bundle exec jekyll serve -w
-$ open http://localhost:4000/react/
+$ open http://localhost:4000/react/index.html
```
We use [SASS](http://sass-lang.com/) (with [Bourbon](http://bourbon.io/)) for our CSS, and we use JSX to transform some of our JS.
diff --git a/docs/Rakefile b/docs/Rakefile
index d50dc5b102..7a9872b7c0 100644
--- a/docs/Rakefile
+++ b/docs/Rakefile
@@ -6,8 +6,8 @@ require('open-uri')
desc "download babel-browser"
task :fetch_remotes do
IO.copy_stream(
- open('https://cdnjs.cloudflare.com/ajax/libs/babel-core/5.8.34/browser.min.js'),
- 'js/babel-browser.min.js'
+ open('https://unpkg.com/babel-standalone@6.15.0/babel.min.js'),
+ 'js/babel.min.js'
)
end
diff --git a/docs/_config.yml b/docs/_config.yml
index 53fa1d01e8..0b6d13d4df 100644
--- a/docs/_config.yml
+++ b/docs/_config.yml
@@ -2,9 +2,9 @@
name: React
description: A JavaScript library for building user interfaces
url: https://facebook.github.io
-baseurl: "/react"
-permalink: "/blog/:year/:month/:day/:title.html"
-paginate_path: "/blog/page:num/"
+baseurl: /react
+permalink: /blog/:year/:month/:day/:title.html
+paginate_path: /blog/page:num/
paginate: 5
timezone: America/Los_Angeles
highlighter: pygments
@@ -20,22 +20,29 @@ defaults:
type: pages
values:
sectionid: blog
+- scope:
+ path: tutorial
+ type: pages
+ values:
+ layout: tutorial
+ sectionid: tutorial
- scope:
path: docs
type: pages
values:
layout: docs
sectionid: docs
-- scope:
- path: tips
- type: pages
- values:
- sectionid: docs
- scope:
path: contributing
type: pages
values:
sectionid: docs
+- scope:
+ path: community
+ type: pages
+ values:
+ layout: community
+ sectionid: community
exclude:
- Gemfile
- Gemfile.lock
@@ -53,13 +60,13 @@ sass:
gems:
- jekyll-redirect-from
- jekyll-paginate
-react_version: 15.3.2
+react_version: 15.4.0
react_hashes:
- dev: bQIyvl+8Ufi5KiKZPG9VItNWmhcAXA1pa5nHIEoBGob+rdbjJnpNV3s288Mz2yZu
- prod: drG4TSBgFQ0Hb/A3ynRyFDT22irpJDL+duuxvYD5mkC9adCYDqEwnX13371waqiH
- addons_dev: gCLxBq3yes/qREmjcw3Tdk5dUh3iB54huWqgxq1lAJZTYzLahJqEik5ZiVnq9Zt4
- addons_prod: pmUKSclxJREtkrfcUJvBYTEoJCvO6Vj5ob8IgPSiIX0G3c4w2dKBJMoGEhlv9Gev
- dom_dev: ZzFfcTbsRst34N23lWs6TtlfonXwDgpeALh+ObwYXav5BSo0j7KsaAtcdn+xrnS1
- dom_prod: MTxlP+/p3lyvc2+LZc2B5xy5reGwrA80whnflxNc6zPgLUmMvbwUoKy7qorBH+P4
- dom_server_dev: jHjmbawtj2AhVuJlmE/O1HXAIbQMzHvoXRZEVdhTSrfJXACRVpZm/BpuAi4K89xn
- dom_server_prod: LCYUMPll/9t/UsNa/Q1zfti2awxxiiczBUZcQBdeGACH0sU6BEAllZuGxo5b6/kf
+ dev: buVLzxzBI8Ps3svVMSUurNdb5dozNidH5Ow4H0YgZeia3t6Oeui2VLpvtAq1fwtK
+ prod: nCjsa0kjNQPQdxWm12/ReVJzfBJaVubEwwDswyQDGMKYJmeWv3qShMuETfU5fisu
+ addons_dev: /u97pKzBwasbC1yj8gSIq1z30o4ZTUX9j1Mv/hyAjmG41ydTNHw9JFOhwFbDgxmR
+ addons_prod: /p86n4b5VTlWoA/INEHQZ+zjx9g1pJduoFmTEJ6fSzFTq1mBaXaBcWVGtZJXD68L
+ dom_dev: lUxkeWjg3I3lXmxcM1gvgo0yvm2w9alc1osa4L8yWZFO6l/vg9h5hSlHPFioltrm
+ dom_prod: u8x1yIGN9IjGNYbBaDMsp1D4MK3sCmMU13mcBX+bm+aMo5+gaT8HIwIj39GlXaRS
+ dom_server_dev: Okj1hVX1VF+oZSkPcJQ/YcnW6bsIpeni222ylwUaMnSmdCe0zWKmMwpFMVqzy4Ws
+ dom_server_prod: wiA4u+G5fEfF4xzhhVnNWeSifVyttoEIpgc3APaMKQgw5A4wHbEMihf63tk1qoyt
diff --git a/docs/_data/nav_community.yml b/docs/_data/nav_community.yml
new file mode 100644
index 0000000000..3740d3af7e
--- /dev/null
+++ b/docs/_data/nav_community.yml
@@ -0,0 +1,14 @@
+- title: Community Resources
+ items:
+ - id: support
+ title: Where To Get Support
+ - id: conferences
+ title: Conferences
+ - id: videos
+ title: Videos
+ - id: complementary-tools
+ title: Complementary Tools
+ href: https://github.com/facebook/react/wiki/Complementary-Tools
+ - id: examples
+ title: Examples
+ href: https://github.com/facebook/react/wiki/Examples
diff --git a/docs/_data/nav_contributing.yml b/docs/_data/nav_contributing.yml
index 22024d081f..1e1f02fd5b 100644
--- a/docs/_data/nav_contributing.yml
+++ b/docs/_data/nav_contributing.yml
@@ -4,5 +4,7 @@
title: How to Contribute
- id: codebase-overview
title: Codebase Overview
+ - id: implementation-notes
+ title: Implementation Notes
- id: design-principles
title: Design Principles
diff --git a/docs/_data/nav_docs.yml b/docs/_data/nav_docs.yml
index e8f6b69132..a6be939b77 100644
--- a/docs/_data/nav_docs.yml
+++ b/docs/_data/nav_docs.yml
@@ -1,104 +1,84 @@
- title: Quick Start
items:
- - id: getting-started
- title: Getting Started
- - id: tutorial
- title: Tutorial
- - id: thinking-in-react
- title: Thinking in React
-- title: Community Resources
+ - id: installation
+ title: Installation
+ - id: hello-world
+ title: Hello World
+ - id: introducing-jsx
+ title: Introducing JSX
+ - id: rendering-elements
+ title: Rendering Elements
+ - id: components-and-props
+ title: Components and Props
+ - id: state-and-lifecycle
+ title: State and Lifecycle
+ - id: handling-events
+ title: Handling Events
+ - id: conditional-rendering
+ title: Conditional Rendering
+ - id: lists-and-keys
+ title: Lists and Keys
+ - id: forms
+ title: Forms
+ - id: lifting-state-up
+ title: Lifting State Up
+ - id: composition-vs-inheritance
+ title: Composition vs Inheritance
+ - id: thinking-in-react
+ title: Thinking In React
+- title: Advanced Guides
items:
- - id: conferences
- title: Conferences
- - id: videos
- title: Videos
- - id: complementary-tools
- title: Complementary Tools
- href: https://github.com/facebook/react/wiki/Complementary-Tools
- - id: examples
- title: Examples
- href: https://github.com/facebook/react/wiki/Examples
-- title: Guides
- items:
- - id: why-react
- title: Why React?
- - id: displaying-data
- title: Displaying Data
- subitems:
- id: jsx-in-depth
- title: JSX in Depth
- - id: jsx-spread
- title: JSX Spread Attributes
- - id: jsx-gotchas
- title: JSX Gotchas
- - id: interactivity-and-dynamic-uis
- title: Interactivity and Dynamic UIs
- - id: multiple-components
- title: Multiple Components
- - id: reusable-components
- title: Reusable Components
- - id: transferring-props
- title: Transferring Props
- - id: forms
- title: Forms
- - id: working-with-the-browser
- title: Working With the Browser
- subitems:
- - id: more-about-refs
- title: Refs to Components
- - id: tooling-integration
- title: Tooling Integration
- subitems:
- - id: language-tooling
- title: Language Tooling
- - id: package-management
- title: Package Management
- - id: environments
- title: Server-side Environments
- - id: addons
- title: Add-Ons
- subitems:
- - id: animation
- title: Animation
- - id: two-way-binding-helpers
- title: Two-Way Binding Helpers
- - id: test-utils
- title: Test Utilities
- - id: clone-with-props
- title: Cloning Elements
- - id: create-fragment
- title: Keyed Fragments
- - id: update
- title: Immutability Helpers
- - id: pure-render-mixin
- title: PureRenderMixin
- - id: perf
- title: Performance Tools
- - id: shallow-compare
- title: Shallow Compare
- - id: advanced-performance
- title: Advanced Performance
- - id: context
- title: Context
+ title: JSX In Depth
+ - id: typechecking-with-proptypes
+ title: Typechecking With PropTypes
+ - id: refs-and-the-dom
+ title: Refs and the DOM
+ - id: uncontrolled-components
+ title: Uncontrolled Components
+ - id: optimizing-performance
+ title: Optimizing Performance
+ - id: react-without-es6
+ title: React Without ES6
+ - id: react-without-jsx
+ title: React Without JSX
+ - id: reconciliation
+ title: Reconciliation
+ - id: context
+ title: Context
+ - id: web-components
+ title: Web Components
- title: Reference
items:
- - id: top-level-api
- title: Top-Level API
- - id: component-api
- title: Component API
- - id: component-specs
- title: Component Specs and Lifecycle
- - id: tags-and-attributes
- title: Supported Tags and Attributes
- - id: events
- title: Event System
- - id: dom-differences
- title: DOM Differences
- - id: special-non-dom-attributes
- title: Special Non-DOM Attributes
- - id: reconciliation
- title: Reconciliation
- - id: webcomponents
- title: Web Components
- - id: glossary
- title: React (Virtual) DOM Terminology
+ - id: react-api
+ title: React
+ subitems:
+ - id: react-component
+ title: React.Component
+ - id: react-dom
+ title: ReactDOM
+ - id: react-dom-server
+ title: ReactDOMServer
+ - id: dom-elements
+ title: DOM Elements
+ - id: events
+ title: SyntheticEvent
+ - id: addons
+ title: Add-Ons
+ subitems:
+ - id: perf
+ title: Performance Tools
+ - id: test-utils
+ title: Test Utilities
+ - id: animation
+ title: Animation
+ - id: create-fragment
+ title: Keyed Fragments
+ - id: update
+ title: Immutability Helpers
+ - id: pure-render-mixin
+ title: PureRenderMixin
+ - id: shallow-compare
+ title: Shallow Compare
+ - id: two-way-binding-helpers
+ title: Two-way Binding Helpers
diff --git a/docs/_data/nav_tips.yml b/docs/_data/nav_tips.yml
deleted file mode 100644
index f568311444..0000000000
--- a/docs/_data/nav_tips.yml
+++ /dev/null
@@ -1,38 +0,0 @@
-- title: Tips
- items:
- - id: introduction
- title: Introduction
- - id: inline-styles
- title: Inline Styles
- - id: if-else-in-JSX
- title: If-Else in JSX
- - id: self-closing-tag
- title: Self-Closing Tag
- - id: maximum-number-of-jsx-root-nodes
- title: Maximum Number of JSX Root Nodes
- - id: style-props-value-px
- title: Shorthand for Specifying Pixel Values in style props
- - id: children-props-type
- title: Type of the Children props
- - id: controlled-input-null-value
- title: Value of null for Controlled Input
- - id: componentWillReceiveProps-not-triggered-after-mounting
- title: componentWillReceiveProps Not Triggered After Mounting
- - id: props-in-getInitialState-as-anti-pattern
- title: Props in getInitialState Is an Anti-Pattern
- - id: dom-event-listeners
- title: DOM Event Listeners in a Component
- - id: initial-ajax
- title: Load Initial Data via AJAX
- - id: false-in-jsx
- title: False in JSX
- - id: communicate-between-components
- title: Communicate Between Components
- - id: expose-component-functions
- title: Expose Component Functions
- - id: children-undefined
- title: this.props.children undefined
- - id: use-react-with-other-libraries
- title: Use React with Other Libraries
- - id: dangerously-set-inner-html
- title: Dangerously Set innerHTML
diff --git a/docs/_data/nav_tutorial.yml b/docs/_data/nav_tutorial.yml
new file mode 100644
index 0000000000..efa090f0ce
--- /dev/null
+++ b/docs/_data/nav_tutorial.yml
@@ -0,0 +1,71 @@
+- title: Tutorial
+ items:
+ - id: tutorial
+ title: Overview
+ subitems:
+ - id: what-were-building
+ title: What We're Building
+ href: /react/tutorial/tutorial.html#what-were-building
+ forceInternal: true
+ - id: what-is-react
+ title: What is React?
+ href: /react/tutorial/tutorial.html#what-is-react
+ forceInternal: true
+ - id: getting-started
+ title: Getting Started
+ href: /react/tutorial/tutorial.html#getting-started
+ forceInternal: true
+ - id: passing-data-through-props
+ title: Passing Data Through Props
+ href: /react/tutorial/tutorial.html#passing-data-through-props
+ forceInternal: true
+ - id: an-interactive-component
+ title: An Interactive Component
+ href: /react/tutorial/tutorial.html#an-interactive-component
+ forceInternal: true
+ - id: developer-tools
+ title: Developer Tools
+ href: /react/tutorial/tutorial.html#developer-tools
+ forceInternal: true
+ - id: lifting-state-up
+ title: Lifting State Up
+ href: /react/tutorial/tutorial.html#lifting-state-up
+ forceInternal: true
+ subitems:
+ - id: why-immutability-is-important
+ title: Why Immutability Is Important
+ href: /react/tutorial/tutorial.html#why-immutability-is-important
+ forceInternal: true
+ - id: functional-components
+ title: Functional Components
+ href: /react/tutorial/tutorial.html#functional-components
+ forceInternal: true
+ - id: taking-turns
+ title: Taking Turns
+ href: /react/tutorial/tutorial.html#taking-turns
+ forceInternal: true
+ - id: declaring-a-winner
+ title: Declaring a Winner
+ href: /react/tutorial/tutorial.html#declaring-a-winner
+ forceInternal: true
+ - id: storing-a-history
+ title: Storing A History
+ href: /react/tutorial/tutorial.html#storing-a-history
+ forceInternal: true
+ subitems:
+ - id: showing-the-moves
+ title: Showing the Moves
+ href: /react/tutorial/tutorial.html#showing-the-moves
+ forceInternal: true
+ - id: keys
+ title: Keys
+ href: /react/tutorial/tutorial.html#keys
+ forceInternal: true
+ - id: implementing-time-travel
+ title: Implementing Time Travel
+ href: /react/tutorial/tutorial.html#implementing-time-travel
+ forceInternal: true
+ - id: wrapping-up
+ title: Wrapping Up
+ href: /react/tutorial/tutorial.html#wrapping-up
+ forceInternal: true
diff --git a/docs/_includes/footer.html b/docs/_includes/footer.html
new file mode 100644
index 0000000000..e2e6fdb658
--- /dev/null
+++ b/docs/_includes/footer.html
@@ -0,0 +1,41 @@
+
diff --git a/docs/_includes/hero.html b/docs/_includes/hero.html
new file mode 100644
index 0000000000..10530a7060
--- /dev/null
+++ b/docs/_includes/hero.html
@@ -0,0 +1,13 @@
+
+
+
React
+
+ A JavaScript library for building user interfaces
+
- {% endif %}
+ {% include navigation.html %}
{{ content }}
-
+ {% include footer.html %}
-
+
-
-
-
-
-
-
-
-
-```
-
-Nel resto della documentazione, ci concentreremo soltanto sul codice JavaScript e assumeremo che sia inserito in un modello come quello qui sopra. Sostituisci il commento segnaposto qui sopra con il seguente codice JSX:
-
-```javascript
-var HelloWorld = React.createClass({
- render: function() {
- return (
-
- Ciao, !
- È il {this.props.date.toTimeString()}
-
- );
- }
-});
-
-setInterval(function() {
- ReactDOM.render(
- ,
- document.getElementById('example')
- );
-}, 500);
-```
-
-
-## Aggiornamenti Reattivi
-
-Apri `hello-react.html` in un browser web e scrivi il tuo nome nel campo di testo. Osserva che React cambia soltanto la stringa di testo dell'ora nella UI — ogni input che inserisci nel campo di testo rimane, anche se non hai scritto alcun codice che gestisce questo comportamento. React lo capisce da solo al tuo posto e fa la cosa giusta.
-
-La maniera in cui siamo in grado di capirlo è che React non manipola il DOM a meno che non sia necessario. **Utilizza un DOM interno fittizio e veloce per effettuare confronti ed effettuare le mutazioni del DOM più efficienti al tuo posto.**
-
-Gli input di questo componente sono chiamati `props` — breve per "properties". Sono passati come attributi nella sintassi JSX. Puoi pensare ad essi come immutabili nel contesto del componente, ovvero, **non assegnare mai `this.props`**.
-
-
-## I Componenti Sono Come Funzioni
-
-I componenti React sono molto semplici. Puoi immaginarli come semplici funzioni che ricevono in ingresso `props` e `state` (discusso in seguito) e rendono HTML. Fatta questa premessa, i componenti sono molto semplici da descrivere.
-
-> Nota:
->
-> **Una limitazione**: i componenti React possono rendere soltanto un singolo nodo radice. Se desideri restituire nodi multipli, essi *devono* essere avvolti in un singolo nodo radice.
-
-
-## Sintassi JSX
-
-Crediamo fermamente che i componenti sono la maniera corretta di separare i concetti anziché i "modelli" e la "logica di presentazione." Pensiamo che il markup e il codice che lo genera siano intimamente collegati. Inoltre, la logica di presentazione è solitamente molto complessa e usare un linguaggio di modello per esprimerla risulta dispendioso.
-
-Abbiamo scoperto che la migliore soluzione a questo problema è generare HTML e un albero di componenti direttamente dal codice JavaScript in maniera da poter utilizzare tutta la potenza espressiva di un vero linguaggio di programmazione per costruire UI.
-
-Per rendere il compito più facile, abbiamo aggiunto una semplice e **opzionale** sintassi simile all'HTML per creare questi nodi di albero React.
-
-**JSX ti permette di creare oggetti JavaScript usando una sintassi HTML.** Per generare un collegamento in React usando puro JavaScript puoi scrivere:
-
-`React.createElement('a', {href: 'https://facebook.github.io/react/'}, 'Ciao!')`
-
-Con JSX ciò diventa:
-
-`Ciao!`
-
-Abbiamo scoperto che questo ha reso la costruzione di applicazioni React più semplice e i designer tendono a preferire la sintassi, ma ciascuno ha un diverso flusso di lavoro, quindi **JSX non è richiesto per utilizzare React.**
-
-JSX è di dimensioni contenute. Per maggiori informazioni, consulta [JSX in profondità](/react/docs/jsx-in-depth-it-IT.html). Oppure osserva la trasformazione in tempo reale sulla [REPL di Babel](https://babeljs.io/repl/).
-
-JSX è simile all'HTML, ma non proprio identico. Consulta la guida [JSX gotchas](/react/docs/jsx-gotchas-it-IT.html) per alcune differenze fondamentali.
-
-[Babel offre una varietà di strumenti per cominciare a usare JSX](http://babeljs.io/docs/setup/), dagli strumenti a riga di comando alle integrazioni in Ruby on Rails. Scegli lo strumento che funziona meglio per te.
-
-
-## React senza JSX
-
-JSX è completamente opzionale; non è necessario utilizzare JSX con React. Puoi creare elementi React in puro JavaScript usando `React.createElement`, che richiede un nome di tag o di componente, un oggetto di proprietà e un numero variabile di argomenti che rappresentano nodi figli opzionali.
-
-```javascript
-var child1 = React.createElement('li', null, 'Primo Contenuto di Testo');
-var child2 = React.createElement('li', null, 'Secondo Contenuto di Testo');
-var root = React.createElement('ul', { className: 'my-list' }, child1, child2);
-ReactDOM.render(root, document.getElementById('example'));
-```
-
-Per comodità, puoi creare funzioni factory scorciatoia per costruire elementi da componenti personalizzati.
-
-```javascript
-var Factory = React.createFactory(ComponentClass);
-...
-var root = Factory({ custom: 'prop' });
-ReactDOM.render(root, document.getElementById('example'));
-```
-
-React possiede già delle factory predefinite per i tag HTML comuni:
-
-```javascript
-var root = React.DOM.ul({ className: 'my-list' },
- React.DOM.li(null, 'Contenuto di Testo')
- );
-```
diff --git a/docs/docs/02-displaying-data.ja-JP.md b/docs/docs/02-displaying-data.ja-JP.md
deleted file mode 100644
index 174d3e0a1a..0000000000
--- a/docs/docs/02-displaying-data.ja-JP.md
+++ /dev/null
@@ -1,125 +0,0 @@
----
-id: displaying-data-ja-JP
-title: データを表示する
-permalink: docs/displaying-data-ja-JP.html
-prev: why-react-ja-JP.html
-next: jsx-in-depth-ja-JP.html
-
----
-
-UIについて、最も基本的なことは、いくつかのデータを表示することです。Reactはデータを表示し、変更された時にはインターフェースを最新の状態に自動的に保つことが簡単にできるようになっています。
-
-## はじめに
-
-本当に単純な例を見てみましょう。`hello-react.html` ファイルを以下のようなコードで作成してください。
-
-```html
-
-
-
-
- Hello React
-
-
-
-
-
-
-
-
-
-```
-
-このドキュメントの中では、JavaScriptのコードにのみフォーカスします。そして、それが上のようなテンプレートに挿入されていると考えます。
-
-```javascript
-var HelloWorld = React.createClass({
- render: function() {
- return (
-
- Hello, !
- It is {this.props.date.toTimeString()}
-
- );
- }
-});
-
-setInterval(function() {
- ReactDOM.render(
- ,
- document.getElementById('example')
- );
-}, 500);
-```
-
-
-## リアクティブなアップデート
-
-`hello-react.html` をウェブブラウザで開き、テキストフィールドにあなたの名前を入力してください。ReactはUIのうち、時間の文字列しか変更しないことに注意してください。あなたがテキストフィールドに入力したものは残っています。あなたはそういったコードを書いていないのにも関わらずです。Reactはあなたのことを理解しており、正しいことを行います。
-
-このことについて私たちが理解できる方法は、Reactは必要になるまで、DOMの操作を行わないということです。 **Reactは、DOMの変化を表現し、あなたにもっとも効率的なDOMの変化を見積もるために早い、内部のモックのDOMを使っています。**
-
-このコンポーネントのインプットは `props` と呼ばれるものです。"properties" の省略形です。それらはJSXシンタックスの中でアトリビュートとして渡されます。それらはコンポーネントの中で不変と考えるべきで、 **`this.props` には書き込まないようにしてください**
-
-## コンポーネントは関数のようなものです。
-
-Reactのコンポーネントはとても単純です。それらは `props` や `state` (後述します)を取り、HTMLをレンダリングする単純な関数だと考えることができます。この考えの元、コンポーネントは簡単に理解することができます。
-
-> 注意:
->
-> **1つの制限**: Reactのコンポーネントは単一の最上位のノードだけをレンダリングします。複数のノードをリターンしたい場合は、単一の最上位のもので *ラップする必要があります* 。
-
-## JSXシンタックス
-
-私たちは関心を分離する正しい方法は「テンプレート」と「ディスプレイロジック」ではなくコンポーネントであると強く考えています。ビューを生成するマークアップとコードは密接につながっていると考えています。加えて、ディスプレイロジックはとても複雑になりえますし、ビューを表現するのにテンプレート言語を使うことはとてもややこしくなりえます。
-
-私たちは、この問題の最適解は、UIを構築するのにリアルなプログラミング言語の表現力の全てを使うことができるように、JavaScriptのコードからHTMLやコンポーネントのツリーを直接生成することだと発見しました。
-
-上記のことを簡単に行うために、私たちはReactのツリーノードを構築するためのとても単純で、 **オプショナルな** HTMLに似たシンタックスを加えました。
-
-**JSXはHTMLのシンタックスを使ってJavaScriptのオブジェクトを構築するのを可能にします。** 純粋にJavaScriptを使ってReactでリンクを構築するには、以下のように書きます。
-
-`React.createElement('a', {href: 'https://facebook.github.io/react/'}, 'Hello!')`
-
-JSXでは、以下のように変換されます。
-
-`Hello!`
-
-以上のようなことで、Reactのアプリを作成するのは簡単になりましたし、デザイナーはこのシンタックスを好むようになると発見しました。しかし、人は自分自身のワークフローを持っているものです。 **JSXはReactを使う際に必ずしも必要ではありません。**
-
-JSXはとても小さいです。さらに学ぶためには、[JSXの深層](/react/docs/jsx-in-depth-ja-JP.html)を参照ください。または、[ライブJSXコンパイラー](/react/jsx-compiler.html)で変換の動作を確認してください。
-
-JSXはHTMLに似ていますが、正確に同じではありません。いくつかのキーの違いについては[JSXの理解](/react/docs/jsx-gotchas.html) をご覧ください。
-
-JSXを初めて使う際に最も簡単なのは、ブラウザで `JSXTransformer` を使う方法です。これはプロダクションでは使わないことを強くお勧めします。コードは、コマンドラインの[react-tools](https://www.npmjs.com/package/react-tools)パッケージを使うことでプリコンパイルできます。
-
-## JSXを使わないReact
-
-JSXは完全にオプションです。Reactと一緒にJSXを使う必要はありません。`React.createElement` を使って、ただのJavaScriptでReactの要素を作ることもできます。それは、タグの名前やコンポーネント、プロパティのオブジェクト、いくつかのオプションの子要素をとります。
-
-```javascript
-var child1 = React.createElement('li', null, 'First Text Content');
-var child2 = React.createElement('li', null, 'Second Text Content');
-var root = React.createElement('ul', { className: 'my-list' }, child1, child2);
-ReactDOM.render(root, document.getElementById('example'));
-```
-便利に書くために、カスタムコンポーネントで要素を作るために簡略した記法でファクトリー関数を作ることができます。
-
-```javascript
-var Factory = React.createFactory(ComponentClass);
-...
-var root = Factory({ custom: 'prop' });
-ReactDOM.render(root, document.getElementById('example'));
-```
-
-Reactはすでに、共通なHTMLのタグについてはビルトインの関数を持っています。
-
-```javascript
-var root = React.DOM.ul({ className: 'my-list' },
- React.DOM.li(null, 'Text Content')
- );
-```
diff --git a/docs/docs/02-displaying-data.ko-KR.md b/docs/docs/02-displaying-data.ko-KR.md
deleted file mode 100644
index 1a9f3738b8..0000000000
--- a/docs/docs/02-displaying-data.ko-KR.md
+++ /dev/null
@@ -1,124 +0,0 @@
----
-id: displaying-data-ko-KR
-title: 데이터를 표시하기
-permalink: docs/displaying-data-ko-KR.html
-prev: why-react-ko-KR.html
-next: jsx-in-depth-ko-KR.html
----
-
-UI를 가지고 할 수 있는 가장 기초적인 것은 데이터를 표시하는 것입니다. React는 데이터를 표시하고 데이터가 변할 때마다 인터페이스를 최신의 상태로 자동으로 유지하기 쉽게 해 줍니다.
-
-## 시작하기
-
-정말 간단한 예제를 보도록 하죠. 다음과 같은 코드의 `hello-react.html` 파일을 만듭시다.
-
-```html
-
-
-
-
- Hello React
-
-
-
-
-
-
-
-
-
-```
-
-문서의 나머지에서, 코드가 위와 같은 HTML 템플릿에 들어갔다고 가정하고 JavaScript 코드에만 집중할 것입니다. 위의 주석 부분을 다음과 같은 JSX 코드로 바꿔 보세요:
-
-```javascript
-var HelloWorld = React.createClass({
- render: function() {
- return (
-
- 안녕, !
- 지금 시간은 {this.props.date.toTimeString()} 입니다.
-
- );
- }
-});
-
-setInterval(function() {
- ReactDOM.render(
- ,
- document.getElementById('example')
- );
-}, 500);
-```
-
-## 반응 적(Reactive) 업데이트
-
-`hello-react.html` 파일을 웹 브라우저에서 열어 당신의 이름을 텍스트 필드에 써 보세요. React는 단지 시간을 표시하는 부분만을 바꿉니다 — 텍스트 필드 안에 입력한 것은 그대로 남아 있구요, 당신이 이 동작을 관리하는 그 어떤 코드도 쓰지 않았음에도 불구하고 말이죠. React는 그걸 올바른 방법으로 알아서 해줍니다.
-
-우리가 이걸 할 수 있었던 건, React는 필요한 경우에만 DOM을 조작하기 때문입니다. **React는 빠른 React 내부의 DOM 모형을 이용하여 변경된 부분을 측정하고, 가장 효율적인 DOM 조작 방법을 계산해 줍니다.**
-
-이 컴포넌트에 대한 입력은 `props` 라고 불립니다 — "properties" 를 줄인 것이죠. 그들은 JSX 문법에서는 어트리뷰트로서 전달됩니다. 당신은 `props` 를 컴포넌트 안에서 불변의(immutable) 엘리먼트로서 생각해야 하고, `this.props` 를 덮어씌우려고 해서는 안됩니다.
-
-## 컴포넌트들은 함수와 같습니다
-
-React 컴포넌트들은 매우 단순합니다. 당신은 그것들을 `props` 와 `state` (이것들은 나중에 언급할 것입니다) 를 받고 HTML을 렌더링하는 단순한 함수들로 생각해도 됩니다. 이걸 염두하면, 컴포넌트의 작동을 이해하는 것도 쉽습니다.
-
-> 주의:
->
-> **한가지 제약이 있습니다**: React 컴포넌트들은 단 하나의 루트 노드(root node)만을 렌더할 수 있습니다. 만약 여러개의 노드들을 리턴하고 싶다면, 그것들은 단 하나의 루트 노드로 싸여져 있어야만 합니다.
-
-## JSX 문법
-
-우리는 컴포넌트를 사용하는 것이 "템플릿"과 "디스플레이 로직(display logic)"을 이용하는 것보다 관심을 분리(separate concerns)하는 데에 올바른 방법이라고 강하게 믿고 있습니다. 우리는 마크업과 그것을 만들어내는 코드는 친밀하게 함께 결합되어있다고 생각합니다. 또한, 디스플레이 로직은 종종 매우 복잡하고, 그것을 템플릿 언어를 이용해 표현하는 것은 점점 사용하기 어렵게 됩니다.
-
-우리는 이 문제를 해결하는 최고의 해결책은, UI를 만드는 진짜 프로그래밍 언어의 표현력을 모두 사용할 수 있는 JavaScript 코드로부터 HTML과 컴포넌트 트리들을 생성하는 것임을 발견했습니다.
-
-이것을 더 쉽게 하기 위해서, 우리는 매우 간단하고, **선택적인** HTML과 비슷한 문법을 추가하여 이 React 트리 노드들을 만들 수 있게 했습니다.
-
-**JSX는 당신으로 하여금 HTML 문법을 이용해 JavaScript 객체를 만들게 해줍니다.** React를 이용해 순수한 JavaScript 문법으로 링크를 만드려고 한다면, 코드는 다음과 같습니다:
-
-`React.createElement('a', {href: 'https://facebook.github.io/react/'}, '안녕하세요!')`
-
-JSX를 이용하면:
-
-`안녕하세요!`
-
-우리는 이것이 React 앱들을 만들기 쉽게 하고, 디자이너들이 이 문법을 더 선호하는 것을 발견했습니다, 하지만 모든 사람은 그들만의 선호하는 워크플로우가 있기 마련이므로, **JSX는 React를 사용하기 위해 필수적이지는 않습니다.**
-
-JSX는 매우 작은 언어입니다. 그것을 배우고 싶다면, [JSX 깊게 살펴보기](/react/docs/jsx-in-depth-ko-KR.html)를 살펴 보시기 바랍니다. 또는, [바벨 REPL](https://babeljs.io/repl/)를 통해 문법이 변환되는 것을 살펴 보시기 바랍니다.
-
-JSX는 HTML과 비슷하지만, 완전히 똑같지는 않습니다. [JSX의 실수하기 쉬운 부분들](/react/docs/jsx-gotchas-ko-KR.html)에 중요한 차이점들에 대해 설명되어 있습니다.
-
-[바벨에서 JSX를 시작하는 여러 방법을 제공합니다](http://babeljs.io/docs/setup/). 여기에는 커맨드 라인 툴부터 루비 온 레일스 연동까지 다양한 방법이 있습니다. 가장 편한 툴을 사용하세요.
-
-## JSX 없이 React 사용하기
-
-JSX는 완전히 선택적입니다. 당신은 React와 JSX를 함께 사용하지 않아도 상관없습니다. 그냥 JavaScript에서 React 엘리먼트를 `React.createElement`로 만들 수 있습니다. 여기에 태그 이름이나 컴포넌트, 속성 객체, 자식 엘리먼트들을 전달하면 됩니다.
-
-```javascript
-var child1 = React.createElement('li', null, 'First Text Content');
-var child2 = React.createElement('li', null, 'Second Text Content');
-var root = React.createElement('ul', { className: 'my-list' }, child1, child2);
-ReactDOM.render(root, document.getElementById('example'));
-```
-
-편의를 위하여, 당신은 팩토리 함수 헬퍼들을 이용해 커스텀 컴포넌트로부터 엘리먼트들을 만들 수 있습니다.
-
-```javascript
-var Factory = React.createFactory(ComponentClass);
-...
-var root = Factory({ custom: 'prop' });
-ReactDOM.render(root, document.getElementById('example'));
-```
-
-React는 이미 일반적인 HTML 태그에 대한 빌트인 팩토리를 가지고 있습니다.
-
-```javascript
-var root = React.DOM.ul({ className: 'my-list' },
- React.DOM.li(null, '텍스트')
- );
-```
diff --git a/docs/docs/02-displaying-data.md b/docs/docs/02-displaying-data.md
deleted file mode 100644
index 70ad425add..0000000000
--- a/docs/docs/02-displaying-data.md
+++ /dev/null
@@ -1,126 +0,0 @@
----
-id: displaying-data
-title: Displaying Data
-permalink: docs/displaying-data.html
-prev: why-react.html
-next: jsx-in-depth.html
----
-
-The most basic thing you can do with a UI is display some data. React makes it easy to display data and automatically keeps the interface up-to-date when the data changes.
-
-## Getting Started
-
-Let's look at a really simple example. Create a `hello-react.html` file with the following code:
-
-```html
-
-
-
-
- Hello React
-
-
-
-
-
-
-
-
-
-```
-
-For the rest of the documentation, we'll just focus on the JavaScript code and assume it's inserted into a template like the one above. Replace the placeholder comment above with the following JSX:
-
-```javascript
-class HelloWorld extends React.Component {
- render() {
- return (
-
- Hello, !
- It is {this.props.date.toTimeString()}
-
- );
- }
-}
-
-function tick() {
- ReactDOM.render(
- ,
- document.getElementById('example')
- );
-}
-
-setInterval(tick, 500);
-```
-
-## Reactive Updates
-
-Open `hello-react.html` in a web browser and type your name into the text field. Notice that React is only changing the time string in the UI — any input you put in the text field remains, even though you haven't written any code to manage this behavior. React figures it out for you and does the right thing.
-
-The way we are able to figure this out is that React does not manipulate the DOM unless it needs to. **It uses a fast, internal mock DOM to perform diffs and computes the most efficient DOM mutation for you.**
-
-The inputs to this component are called `props` — short for "properties". They're passed as attributes in JSX syntax. You should think of these as immutable within the component, that is, **never write to `this.props`**.
-
-## Components are Just Like Functions
-
-React components are very simple. You can think of them as simple functions that take in `props` and `state` (discussed later) and render HTML. With this in mind, components are easy to reason about.
-
-> Note:
->
-> **One limitation**: React components can only render a single root node. If you want to return multiple nodes they *must* be wrapped in a single root.
-
-## JSX Syntax
-
-We strongly believe that components are the right way to separate concerns rather than "templates" and "display logic." We think that markup and the code that generates it are intimately tied together. Additionally, display logic is often very complex and using template languages to express it becomes cumbersome.
-
-We've found that the best solution for this problem is to generate HTML and component trees directly from the JavaScript code such that you can use all of the expressive power of a real programming language to build UIs.
-
-In order to make this easier, we've added a very simple, **optional** HTML-like syntax to create these React tree nodes.
-
-**JSX lets you create JavaScript objects using HTML syntax.** To generate a link in React using pure JavaScript you'd write:
-
-`React.createElement('a', {href: 'https://facebook.github.io/react/'}, 'Hello!')`
-
-With JSX this becomes:
-
-`Hello!`
-
-We've found this has made building React apps easier and designers tend to prefer the syntax, but everyone has their own workflow, so **JSX is not required to use React.**
-
-JSX is very small. To learn more about it, see [JSX in depth](/react/docs/jsx-in-depth.html). Or see the transform in action in [the Babel REPL](https://babeljs.io/repl/).
-
-JSX is similar to HTML, but not exactly the same. See [JSX gotchas](/react/docs/jsx-gotchas.html) for some key differences.
-
-[Babel exposes a number of ways to get started using JSX](http://babeljs.io/docs/setup/), ranging from command line tools to Ruby on Rails integrations. Choose the tool that works best for you.
-
-## React without JSX
-
-JSX is completely optional; you don't have to use JSX with React. You can create React elements in plain JavaScript using `React.createElement`, which takes a tag name or component, a properties object, and variable number of optional child arguments.
-
-```javascript
-var child1 = React.createElement('li', null, 'First Text Content');
-var child2 = React.createElement('li', null, 'Second Text Content');
-var root = React.createElement('ul', { className: 'my-list' }, child1, child2);
-ReactDOM.render(root, document.getElementById('example'));
-```
-
-For convenience, you can create short-hand factory functions to create elements from custom components.
-
-```javascript
-var Factory = React.createFactory(ComponentClass);
-...
-var root = Factory({ custom: 'prop' });
-ReactDOM.render(root, document.getElementById('example'));
-```
-
-React already has built-in factories for common HTML tags:
-
-```javascript
-var root = React.DOM.ul({ className: 'my-list' },
- React.DOM.li(null, 'Text Content')
- );
-```
diff --git a/docs/docs/02-displaying-data.ru-RU.md b/docs/docs/02-displaying-data.ru-RU.md
deleted file mode 100644
index 38e707766a..0000000000
--- a/docs/docs/02-displaying-data.ru-RU.md
+++ /dev/null
@@ -1,124 +0,0 @@
----
-id: displaying-data-ru-RU
-title: Отображение данных
-permalink: docs/displaying-data-ru-RU.html
-prev: why-react-ru-RU.html
-next: jsx-in-depth.html
----
-
-Главная задача интерфейса — это отображать данные. React делает это легко и обновляет интерфейс сразу, как только изменятся данные.
-
-## Начало
-
-Давайте рассмотрим простой пример. Создайте файл `hello-react.html` со следующим текстом:
-
-```html
-
-
-
-
- Hello React
-
-
-
-
-
-
-
-
-
-```
-
-Добавим в этот шаблон немного JavaScript. Замените комментарий на следующий JSX-код:
-
-```javascript
-var HelloWorld = React.createClass({
- render: function() {
- return (
-
- Hello, !
- It is {this.props.date.toTimeString()}
-
- );
- }
-});
-
-setInterval(function() {
- ReactDOM.render(
- ,
- document.getElementById('example')
- );
-}, 500);
-```
-
-## Реактивные обновления
-
-Откройте `hello-react.html` в браузере и введите в текстовое поле свое имя. Что происходит со страницей? Каждые полсекунды обновляется время, остальные же части страницы остаются без изменений. Обратите внимание, что мы не написали ни строчки кода, чтобы управлять этим поведением. React сам отлично понимает что надо делать и обновляет элементы на странице по мере необходимости.
-
-Суть в том, что React не меняет DOM-дерево до тех пор, пока это не потребуется. **Чтобы отразить изменения, React использует быстрое внутреннее представление DOM-дерева и просчитывает как его изменить наиболее эффективно**.
-
-Передаваемые в компонент данные называются `props` — сокращенно от "properties". В JSX коде они передаются как атрибуты компонента. Считайте, что компонент получает `props` только для чтения. **Никогда не перезаписывайте значения `this.props` внутри компонента.**
-
-## Компоненты как функции
-
-Компоненты React — довольно простые сущности. Можно считать их обыкновенными функциями, которые принимают на входе `props` и `state` (см. далее) и возвращают HTML. Если помнить об этом, то компоненты становятся простыми для понимания.
-
-> Замечание:
->
-> **Есть одно ограничение**: Компоненты React умеют возвращать только один узел. Если вам надо вернуть сразу несколько, они *должны* быть обернуты в один корневой узел.
-
-## Синтаксис JSX
-
-Мы убеждены, что компоненты — самый подходящий способ разделения ответственностей, гораздо более удобный чем "шаблоны" и "вынесение логики на страницу". Мы считаем, что разметка и код, который её генерирует, неотделимы друг от друга. Плюс, логика на странице часто бывает запутанной, и использование шаблонизаторов, чтобы описать её, только затрудняет работу.
-
-Мы решили, что лучшим вариантом будет генерировать HTML и деревья компонентов прямо из JS кода. Так вы сможете зайдействовать всю выразительную мощь современного языка программирования для создания интерфейсов.
-
-А чтобы упростить создание узлов дерева, мы ввели **опциональный** HTML-подобный синтаксис.
-
-**JSX позволяет вам создавать JavaScript объекты используя синтаксис HTML**. Для генерации ссылки в React вы напишете на чистом JavaScript:
-
-`React.createElement('a', {href: 'https://facebook.github.io/react/'}, 'Hello!')`
-
-С JSX это станет:
-
-`Hello!`
-
-Мы установили, что с JSX создавать React приложения проще, и дизайнеров как правило устраивает его синтаксис. Но у разных людей разные предпочтения, поэтому стоит сказать, что **JSX необязателен при работе с React.**
-
-JSX сам по себе очень прост. Чтобы узнать о нем больше, почитайте [подробно про JSX](/react/docs/jsx-in-depth.html). Или можете попробовать его в [Babel REPL](https://babeljs.io/repl/).
-
-JSX похож на HTML, но но имеет существенные отличия. Почитайте про [подводные камни JSX](/react/docs/jsx-gotchas.html), чтобы понять их ключевые различия.
-
-[Babel предлагает несколько способов начать работу с JSX](http://babeljs.io/docs/setup/), от консольных утилит до интеграций с Ruby on Rails. Выберите тот инструмент, который лучше всего вам подходит.
-
-## React без использования JSX
-
-JSX полностью опционален; вам совсем необязательно использовать его вместе с React. Вы можете создавать React-элементы на чистом JavaScript используя функцию `React.createElement`, которая принимает имя тега или компонента, объект со свойствами, и набор необязательных дочерних элементов.
-
-```javascript
-var child1 = React.createElement('li', null, 'First Text Content');
-var child2 = React.createElement('li', null, 'Second Text Content');
-var root = React.createElement('ul', { className: 'my-list' }, child1, child2);
-ReactDOM.render(root, document.getElementById('example'));
-```
-
-Для удобства, вы можете создать сокращенные фабричные функции, чтобы создавать React-элементы из ваших собственных компонентов.
-
-```javascript
-var Factory = React.createFactory(ComponentClass);
-...
-var root = Factory({ custom: 'prop' });
-ReactDOM.render(root, document.getElementById('example'));
-```
-
-А для базовых HTML тегов в React уже есть встроенные фабрики:
-
-```javascript
-var root = React.DOM.ul({ className: 'my-list' },
- React.DOM.li(null, 'Text Content')
- );
-```
diff --git a/docs/docs/02-displaying-data.zh-CN.md b/docs/docs/02-displaying-data.zh-CN.md
deleted file mode 100644
index d099c1440e..0000000000
--- a/docs/docs/02-displaying-data.zh-CN.md
+++ /dev/null
@@ -1,124 +0,0 @@
----
-id: displaying-data-zh-CN
-title: 显示数据
-permalink: docs/displaying-data-zh-CN.html
-prev: why-react-zh-CN.html
-next: jsx-in-depth-zh-CN.html
----
-
-用户界面能做的最基础的事就是显示一些数据。React 让显示数据变得简单,当数据变化的时候,用户界面会自动同步更新。
-
-## 开始
-
-让我们看一个非常简单的例子。新建一个名为 `hello-react.html` 的文件,代码内容如下:
-
-```html
-
-
-
-
- Hello React
-
-
-
-
-
-
-
-
-
-```
-
-在接下去的文档中,我们只关注 JavaScript 代码,假设我们把代码插入到上面那个模板中。用下面的代码替换掉上面用来占位的注释。
-
-```javascript
-var HelloWorld = React.createClass({
- render: function() {
- return (
-
- Hello, !
- It is {this.props.date.toTimeString()}
-
- Hello, !
- It is {this.props.date.toTimeString()}
-
- );
- }
-});
-
-setInterval(function() {
- ReactDOM.render(
- ,
- document.getElementById('example')
- );
-}, 500);
-```
-
-## 反應性更新(Reactive Updates)
-
-在一個瀏覽器上開啟檔案 `hello-react.html` 並且在文字區塊填入你的名字. 請注意React僅僅改變UI上的時間字串 — 你在文字區塊輸入的任何文字依舊存在, 即使你並沒有寫任何程式碼來管理這個行為.React可以為你分辨出這樣的行為並且做出正確的回應.
-
-之所以能夠分辨出這樣的行為是因為React除非在真正有必要的情況下,否則不會對DOM做任何操作. **它使用一個快速的, 內部虛擬的DOM(internal mock DOM)來為你施行比較和計算最有效率的DOM變動(DOM mutation)**
-
-輸入到元件(component)的內容我們稱為`props` — 是屬性("properties")的簡稱. 他們在JSX語法中作為傳遞屬性之用. 你應該把這些屬性當做元件中不可被改變的, 也就是說, **永遠不要對 `this.props` 做寫入的行為**.
-
-## 元件就是函數(Components are Just Like Functions)
-
-React元件(components)是非常簡單的. 你能把它們想成是簡單的函數帶入`props`和`state`(後面會討論這部份)並且呈送給HTML(render HTML). 在心中保持住這個想法, 就能容易理解元件(components).
-React components are very simple. You can think of them as simple functions that take in `props` and `state` (discussed later) and render HTML. With this in mind, components are easy to reason about.
-
-> 注意(Note):
->
-> **一個局限性**: React元件(components)只能呈送(render)給一個單一根節點(root node). 如果你想要回傳多個節點(multiple nodes)他們*必須*被包裹在單一根節點內.
-
-## JSX語法
-
-我們深信元件(components)才是分離關注點(separate concerns)的正確方法, 而並非傳統的模板("templates")和顯示邏輯("display logic")觀念. 我們認為標記(markup)和產生它的程式碼應當緊密的綁在一起. 另外, 顯示邏輯(display logic)常常是非常複雜的, 若使用模板語言(template languages)來詮釋它就顯得笨重或累贅.
-
-我們找到解決這個問題的最佳解答就是直接在JavaScript程式內產生HTML和元件樹(component trees)如此一來你就能使用真正的程式語言的表達能力(expressive power)來建立使用者介面(UIs).
-
-為了能更輕鬆實現, 我們增加了一個非常簡單, **可選擇性使用的** 類似HTML的語法(HTML-like syntax) 來創建這些React樹節點(React tree nodes).
-
-**JSX能讓你使用HTML語法來創建JavaScript物件.** 在React裡使用純JavaScript來產生一個鏈接(link)你可以這樣寫:
-
-`React.createElement('a', {href: 'https://facebook.github.io/react/'}, 'Hello!')`
-
-使用JSX語法則變成:
-
-`Hello!`
-
-我們發現這麼做能讓建立React apps更加容易並且設計師往往喜歡語法, 但是每個人都有他們自己的工作流程, 所以**在使用React時JSX並非必要.**
-
-JSX非常簡單易懂. 若想要學習更多關於JSX, 請參閱 [JSX in depth](/react/docs/jsx-in-depth.html). 或是可以使用線上及時轉換工具 [the Babel REPL](https://babeljs.io/repl/).
-
-JSX類似於HTML, 但不盡然完全相同. 參閱 [JSX gotchas](/react/docs/jsx-gotchas.html) 來比較一些主要的差異點.
-
-[Babel exposes a number of ways to get started using JSX](http://babeljs.io/docs/setup/), 涵蓋從命令列工具到Ruby on Rails整合. 可以從中選擇最適合你的工具.
-
-## React不使用JSX的範例(React without JSX)
-
-JSX完全是可選擇性使用的; 你可以不拿JSX跟React一起使用. 你能在純粹的JavaScript環境中使用`React.createElement`來創建React元素(React elements), 它搭配一個標籤名(tag name)或是元件(component), 一個屬性物件(properties object), 和數個選擇性子參數(child arguments).
-
-```javascript
-var child1 = React.createElement('li', null, 'First Text Content');
-var child2 = React.createElement('li', null, 'Second Text Content');
-var root = React.createElement('ul', { className: 'my-list' }, child1, child2);
-ReactDOM.render(root, document.getElementById('example'));
-```
-
-為了方便起見, 你能創建速記factory函式(short-hand factory functions)然後從自訂元件(custom components)建立元素(elements).
-
-```javascript
-var Factory = React.createFactory(ComponentClass);
-...
-var root = Factory({ custom: 'prop' });
-ReactDOM.render(root, document.getElementById('example'));
-```
-
-針對一般的HTML標籤React已經有內建的factories函式:
-
-```javascript
-var root = React.DOM.ul({ className: 'my-list' },
- React.DOM.li(null, 'Text Content')
- );
-```
diff --git a/docs/docs/02.1-jsx-in-depth.it-IT.md b/docs/docs/02.1-jsx-in-depth.it-IT.md
deleted file mode 100644
index 67eac16444..0000000000
--- a/docs/docs/02.1-jsx-in-depth.it-IT.md
+++ /dev/null
@@ -1,228 +0,0 @@
----
-id: jsx-in-depth-it-IT
-title: JSX in Profondità
-permalink: docs/jsx-in-depth-it-IT.html
-prev: displaying-data-it-IT.html
-next: jsx-spread-it-IT.html
----
-
-[JSX](https://facebook.github.io/jsx/) è un'estensione della sintassi JavaScript che somiglia all'XML. Puoi usare una semplice trasformazione sintattica di JSX con React.
-
-## Perché JSX?
-
-Non devi per forza utilizzare JSX con React. Puoi anche usare semplice JS. Tuttavia, raccomandiamo di utilizzare JSX perché usa una sintassi concisa e familiare per definire strutture ad albero dotate di attributi.
-
-È più familiare a sviluppatori occasionali come i designer.
-
-L'XML ha i benefici di tag di apertura e chiusura bilanciati. Ciò rende la lettura di grandi strutture ad albero più semplice di chiamate a funzione o oggetti letterali.
-
-Non altera la semantica di JavaScript.
-
-## Tag HTML o Componenti React
-
-React può sia rendere tag HTML (stringhe) che componenti React (classi).
-
-Per rendere untag HTML, usa nomi di tag minuscoli in JSX:
-
-```javascript
-var myDivElement = ;
-ReactDOM.render(myDivElement, document.getElementById('example'));
-```
-
-Per rendere un componente React, definisci una variabile locale che comincia con una lettera maiuscola:
-
-```javascript
-var MyComponent = React.createClass({/*...*/});
-var myElement = ;
-ReactDOM.render(myElement, document.getElementById('example'));
-```
-
-Il JSX di React utilizza la convenzione maiuscolo o minuscolo per distinguere tra classi di componenti locali e tag HTML.
-
-> Nota:
->
-> Poiché JSX è JavaScript, gli identificatori come `class` e `for` sono sconsigliati
-> come nomi di attributi XML. Invece, i componenti DOM React si aspettano nomi di proprietà
-> come `className` e `htmlFor` rispettivamente.
-
-## La Trasformazione
-
-Il JSX di React viene trasformato da una sintassi XML a JavaScript nativo. Gli elementi XML, gli attributi e i figli sono trasformati in argomenti passati a `React.createElement`.
-
-```javascript
-var Nav;
-// Input (JSX):
-var app = ;
-// Output (JS):
-var app = React.createElement(Nav, {color:"blue"});
-```
-
-Osserva che per utilizzare ``, la variabile `Nav` deve essere visibile.
-
-JSX permette anche di specificare i figli usando una sintassi XML:
-
-```javascript
-var Nav, Profile;
-// Input (JSX):
-var app = ;
-// Output (JS):
-var app = React.createElement(
- Nav,
- {color:"blue"},
- React.createElement(Profile, null, "click")
-);
-```
-
-JSX inferirà il [displayName](/react/docs/component-specs-it-IT.html#displayname) della classe dall'assegnazione delle variabile, quando il valore di displayName è indefinito:
-
-```javascript
-// Input (JSX):
-var Nav = React.createClass({ });
-// Output (JS):
-var Nav = React.createClass({displayName: "Nav", });
-```
-
-Usa la [REPL di Babel](https://babeljs.io/repl/) per provare il JSX e vedere come viene trasformato
-in JavaScript nativo, e il
-[convertitore da HTML a JSX](http://magic.reactjs.net/htmltojsx.htm) per convertire il tuo HTML esistente a
-JSX.
-
-Se desideri utilizzare JSX, la guida [Primi Passi](/react/docs/getting-started-it-IT.html) ti mostra come impostare la compilazione.
-
-> Nota:
->
-> L'espressione JSX viene sempre valutata come un ReactElement. Le implementazioni
-> attuali potrebbero differire. Un modo ottimizzato potrebbe porre il
-> ReactElement in linea come un oggetto letterale per evitare il codice di validazione in
-> `React.createElement`.
-
-## Namespace dei Componenti
-
-Se stai costruendo un componente che ha parecchi figli, come ad esempio un modulo, potresti facilmente trovarti con una quantità di dichiarazioni di variabili:
-
-```javascript
-// Imbarazzante blocco di dichiarazioni di variabili
-var Form = MyFormComponent;
-var FormRow = Form.Row;
-var FormLabel = Form.Label;
-var FormInput = Form.Input;
-
-var App = (
-
-);
-```
-
-Per rendere tutto ciò più semplice e leggibile, *i componenti con un namespace* ti permettono di usare un componente che dispone di altri componenti come proprietà:
-
-```javascript
-var Form = MyFormComponent;
-
-var App = (
-
-
-
-
-
-);
-```
-
-Per fare ciò, devi semplicemente creare i tuoi *"sub-componenti"* come proprietà del componente principale:
-
-```javascript
-var MyFormComponent = React.createClass({ ... });
-
-MyFormComponent.Row = React.createClass({ ... });
-MyFormComponent.Label = React.createClass({ ... });
-MyFormComponent.Input = React.createClass({ ... });
-```
-
-JSX gestirà il tutto correttamente al momento di compilare il tuo codice.
-
-```javascript
-var App = (
- React.createElement(Form, null,
- React.createElement(Form.Row, null,
- React.createElement(Form.Label, null),
- React.createElement(Form.Input, null)
- )
- )
-);
-```
-
-> Nota:
->
-> Questa funzionalità è disponibile nella [v0.11](/react/blog/2014/07/17/react-v0.11.html#jsx) e successive.
-
-## Espressioni JavaScript
-
-### Expressioni come Attributi
-
-Per usare un'espressione JavaScript come valore di un attributo, racchiudi l'espressione in un paio
-di parentesi graffe (`{}`) anziché doppi apici (`""`).
-
-```javascript
-// Input (JSX):
-var person = ;
-// Output (JS):
-var person = React.createElement(
- Person,
- {name: window.isLoggedIn ? window.name : ''}
-);
-```
-
-### Attributi Booleani
-
-Omettere il valore di un attributo fa in modo che JSX lo tratti come `true`. Per passare `false` occorre utilizzare un'espressione come attributo. Ciò capita spesso quando si usano elementi di moduli HTML, con attributi come `disabled`, `required`, `checked` e `readOnly`.
-
-```javascript
-// Queste due forme sono equivalenti in JSX per disabilitare un bottone
-;
-;
-
-// E queste due forme sono equivalenti in JSX per non disabilitare un bottone
-;
-;
-```
-
-### Expressioni per Figli
-
-Similmente, espressioni JavaScript possono essere utilizzate per rappresentare figli:
-
-```javascript
-// Input (JSX):
-var content = {window.isLoggedIn ? : };
-// Output (JS):
-var content = React.createElement(
- Container,
- null,
- window.isLoggedIn ? React.createElement(Nav) : React.createElement(Login)
-);
-```
-
-### Commenti
-
-È facile aggiungere commenti al tuo codice JSX; sono semplici espressioni JS. Devi soltanto prestare attenzione a porre `{}` attorno ai commenti quando ti trovi dentro la sezione figli di un tag.
-
-```javascript
-var content = (
-
-);
-```
-
-> NOTA:
->
-> JSX è simile all'HTML, ma non esattamente identico. Consulta la guida [JSX gotchas](/react/docs/jsx-gotchas-it-IT.html) per le differenze fondamentali.
diff --git a/docs/docs/02.1-jsx-in-depth.ja-JP.md b/docs/docs/02.1-jsx-in-depth.ja-JP.md
deleted file mode 100644
index 4400ca0139..0000000000
--- a/docs/docs/02.1-jsx-in-depth.ja-JP.md
+++ /dev/null
@@ -1,219 +0,0 @@
----
-id: jsx-in-depth
-title: JSXの深層
-permalink: docs/jsx-in-depth-ja-JP.html
-prev: displaying-data-ja-JP.html
-next: jsx-spread-ja_JP.html
----
-
-[JSX](https://facebook.github.io/jsx/)はXMLに似たJavaScriptのシンタックスの拡張です。Reactでは、単純なJSXのシンタックスの変換を使うことができます。
-
-## なぜJSXを使うのでしょうか?
-
-ReactでJSXの使用を強制されるわけではありません。生のJSを使うこともできます。しかし、JSXは簡潔で、木構造とReactの特性を定義しやすいシンタックスであるため、JSXを使うことをお勧めします。
-
-デザイナーのようなカジュアルな開発者にとってはさらに馴染みやすいでしょう。
-
-XMLにはバランスの取れた開始タグと終了タグという利益があります。このことで、関数がオブジェクトリテラルを呼んでいるのを読むよりも簡単に大きな木構造を作ることができます。
-
-これはJavaScriptのセマンティックスを代替するものではありません。
-
-## HTMLタグ対Reactコンポーネント
-
-ReactはHTMLタグ(文字列)とReactコンポーネント(クラス)の両方をレンダリングすることができます。
-
-以下のようにJSXで小文字のタグ名を使用するだけで、HTMLタグをレンダリングできます。
-
-```javascript
-var myDivElement = ;
-ReactDOM.render(myDivElement, document.getElementById('example'));
-```
-
-以下のように大文字から始まるローカル変数を作成するだけで、Reactのコンポーネントをレンダリングできます。
-
-```javascript
-var MyComponent = React.createClass({/*...*/});
-var myElement = ;
-ReactDOM.render(myElement, document.getElementById('example'));
-```
-
-ReactのJSXは大文字と小文字を使うことで、ローカルのコンポーネントクラスとHTMLタグを識別する習慣があります。
-
-> 注意:
->
-> JSXはJavaScriptなので、 `class` や `for` といった識別子はXMLの属性名としては使用しません。代わりに、 ReactのDOMコンポーネントはDOMのプロパティ名がそれぞれ `className` や `htmlFor` といったものであることを期待します。
-
-## The Transform
-
-ReactのJSXはXMLに似たシンタックスをネイティブなJavaScriptに変換します。XML要素や属性や子要素は `React.createElement` で渡される引数に変換されます。
-
-```javascript
-var Nav;
-// 入力 (JSX):
-var app = ;
-// 出力 (JS):
-var app = React.createElement(Nav, {color:"blue"});
-```
-
-`` を使うためには、 `Nav` 変数がスコープの中にないといけないことに注意してください。
-
-以下のように、JSXはXMLシンタックスを使うことで、細かな子要素の使用も許可します。
-
-```javascript
-var Nav, Profile;
-// 入力 (JSX):
-var app = ;
-// 出力 (JS):
-var app = React.createElement(
- Nav,
- {color:"blue"},
- React.createElement(Profile, null, "click")
-);
-```
-
-以下のように、displayNameがundefinedの時には、JSXはクラスの[displayName](/react/docs/component-specs.html#displayname)を変数の割り当てから予測します。
-
-```javascript
-// 入力 (JSX):
-var Nav = React.createClass({ });
-// 出力 (JS):
-var Nav = React.createClass({displayName: "Nav", });
-```
-
-JSXを試し、どのようにネイティブなJavaScriptに変換されるか見るには、[JSX Compiler](/react/jsx-compiler.html)を、すでに存在するHTMLをJSXに変換するには[HTMLからJSXへのコンバーター](http://magic.reactjs.net/htmltojsx.htm)を使ってください。
-
-JSXを使いたい場合は、[始めてみましょう](/react/docs/getting-started-ja-JP.html)というガイドがどのようにコンパイルを設定するか示してくれます。
-
-> 注意:
->
-> JSXという表現は常にReactElementを評価します。実際に実行する際の詳細はおそらく異なっているでしょう。最適化されたモードでは `React.createElement` のコードのバリデーションを避けるためにReactElementをオブジェクトリテラルとして配置するでしょう。
-
-
-## ネームスペース化されたコンポーネント
-
-formのように、たくさんの子要素を持つコンポーネントを構築する際には、以下のように多くの変数を宣言しなければいけないでしょう。
-
-```javascript
-// 変数宣言のあまりよくない部分
-var Form = MyFormComponent;
-var FormRow = Form.Row;
-var FormLabel = Form.Label;
-var FormInput = Form.Input;
-
-var App = (
-
-);
-```
-
-これを単純で簡単にするために、 *ネームスペース化されたコンポーネント* では、以下のように他のコンポーネントを付属物として持つ1つのコンポーネントを使うことができます。
-
-```javascript
-var Form = MyFormComponent;
-
-var App = (
-
-
-
-
-
-);
-```
-
-これを行うためには、以下のようにメインコンポーネントの付属物として、「サブコンポーネント」を作るだけで大丈夫です。
-
-```javascript
-var MyFormComponent = React.createClass({ ... });
-
-MyFormComponent.Row = React.createClass({ ... });
-MyFormComponent.Label = React.createClass({ ... });
-MyFormComponent.Input = React.createClass({ ... });
-```
-
-JSXはコードをコンパイルする際にこのプロパティをハンドルします。
-
-```javascript
-var App = (
- React.createElement(Form, null,
- React.createElement(Form.Row, null,
- React.createElement(Form.Label, null),
- React.createElement(Form.Input, null)
- )
- )
-);
-```
-
-> 注意:
-> この特徴は [v0.11](/react/blog/2014/07/17/react-v0.11.html#jsx) 以上で使用できます。
-
-## JavaScriptの表現
-
-### アトリビュートの表現
-
-JavaScriptで書いたものをアトリビュートの値として使うためには、その表現を引用(`""`)ではなく波括弧(`{}`)で囲ってください。
-
-```javascript
-// 入力 (JSX):
-var person = ;
-// 出力 (JS):
-var person = React.createElement(
- Person,
- {name: window.isLoggedIn ? window.name : ''}
-);
-```
-
-### Booleanのアトリビュート
-
-アトリビュートの値を記述しないと、JSXはそれを `true` として扱ってしまいます。`false` を渡すためには、アトリビュートが使われる必要があります。これらはHTMLのform要素の `disabled` 、 `required` 、 `checked` 、 `readOnly` といったアトリビュートを使う際によく見かけられます。
-
-
-```javascript
-// 以下の2つはボタンを使用不能にするという意味でJSXでは同義です。
-;
-;
-
-// 以下の2つはボタンを使用不能にしないという意味でJSXでは同義です。
-;
-;
-```
-
-### 子要素の表現
-
-同様に、JavaScriptは子要素を表現するのに使われることもあります。
-
-```javascript
-// 入力 (JSX):
-var content = {window.isLoggedIn ? : };
-// 出力 (JS):
-var content = React.createElement(
- Container,
- null,
- window.isLoggedIn ? React.createElement(Nav) : React.createElement(Login)
-);
-```
-
-### コメント
-
-JSXにコメントを加えるのは簡単です。ただのJSの書き方です。タグの内側にコメントを書く時には、 `{}` で囲うことに注意してください。
-
-```javascript
-var content = (
-
-);
-```
-
-> 注意:
-> JSXはHTMLに似ていますが、全く同じではありません。いくつかのキーの違いについては[JSXの理解](/react/docs/jsx-gotchas.html) をご覧ください。
diff --git a/docs/docs/02.1-jsx-in-depth.ko-KR.md b/docs/docs/02.1-jsx-in-depth.ko-KR.md
deleted file mode 100644
index 268fe01faa..0000000000
--- a/docs/docs/02.1-jsx-in-depth.ko-KR.md
+++ /dev/null
@@ -1,223 +0,0 @@
----
-id: jsx-in-depth-ko-KR
-title: JSX 깊이보기
-permalink: docs/jsx-in-depth-ko-KR.html
-prev: displaying-data-ko-KR.html
-next: jsx-spread-ko-KR.html
----
-
-[JSX](https://facebook.github.io/jsx/)는 XML과 비슷한 JavaScript문법 확장입니다. React에서 변환되는 간단한 JSX 구문을 사용하실 수 있습니다.
-
-## 왜 JSX인가?
-
-React를 위해 꼭 JSX를 사용할 필요는 없고, 그냥 일반 JS를 사용할 수도 있습니만 JSX를 사용하기를 추천합니다. 왜냐하면, 어트리뷰트를 가진 트리 구조로 정의할 수 있는 간결하고 익숙한 문법이기 때문입니다.
-
-이것은 디자이너 같은 케쥬얼 개발자에게 더 익숙합니다.
-
-XML에는 여닫는 태그의 장점이 있습니다. 태그는 큰 트리일 때 함수 호출이나 객체 리터럴보다 읽기 쉬워 집니다.
-
-JSX는 JavaScript의 시맨틱을 변경하지 않습니다.
-
-## HTML 태그 vs. React 컴포넌트
-
-React는 렌더 HTML 태그(문자열)이나 React 컴포넌트(클래스)일 수 있습니다.
-
-HTML 태그를 렌더하려면, 그냥 JSX에 소문자 태그를 사용하세요.
-
-```javascript
-var myDivElement = ;
-ReactDOM.render(myDivElement, document.getElementById('example'));
-```
-
-React 컴포넌트를 렌더하려면, 대문자로 시작하는 로컬 변수를 만드세요.
-
-```javascript
-var MyComponent = React.createClass({/*...*/});
-var myElement = ;
-ReactDOM.render(myElement, document.getElementById('example'));
-```
-
-React JSX는 대소문자를 로컬 컴포넌트 클래스와 HTML 태그를 구별하는 컨벤션으로 사용합니다.
-
-> 주의:
->
-> JSX가 JavaScript기 때문에, `class`, `for`같은 식별자는 XML 어트리뷰트 이름으로
-> 권장하지 않습니다. 대신, React DOM 컴포넌트는 각각 `className`, `htmlFor`같은
-> DOM 프로퍼티 이름을 기대합니다.
-
-## 변환
-
-React JSX는 XML같은 문법에서 네이티브 JavaScript로 변환됩니다. XML 엘리먼트, 어트리뷰트, 자식은 `React.createElement`에 넘겨지는 인자로 변환됩니다.
-
-```javascript
-var Nav;
-// 입력 (JSX):
-var app = ;
-// 출력 (JS):
-var app = React.createElement(Nav, {color:"blue"});
-```
-
-``를 사용하려면, `Nav`변수는 스코프에 있어야 합니다.
-
-JSX에서는 XML 구문으로 자식을 지정할 수도 있습니다.
-
-```javascript
-var Nav, Profile;
-// 입력 (JSX):
-var app = ;
-// 출력 (JS):
-var app = React.createElement(
- Nav,
- {color:"blue"},
- React.createElement(Profile, null, "click")
-);
-```
-
-클래스에 [displayName](/react/docs/component-specs-ko-KR.html#displayname)이 정의되어 있지 않으면 JSX는 변수명을 displayName으로 간주할 것입니다:
-
-```javascript
-// 입력 (JSX):
-var Nav = React.createClass({ });
-// 출력 (JS):
-var Nav = React.createClass({displayName: "Nav", });
-```
-
-[바벨 REPL](https://babeljs.io/repl/)를 보면 JSX에서 어떻게 네이티브 JavaScript로 변환(desugars)하는지 볼 수 있고, [HTML-JSX 변환기](http://magic.reactjs.net/htmltojsx.htm)는 이미 있는 HTML을 JSX로 변환해 줍니다.
-
-JSX를 사용 하시려면, [시작하기](/react/docs/getting-started-ko-KR.html) 가이드에서 어떻게 컴파일을 하기 위해 설정하는지 보실 수 있습니다.
-
-> 주의:
->
-> JSX 표현식은 언제나 ReactElement로 변환됩니다. 실제 구현의 세부사항은 많이
-> 다를 수 있습니다. 최적화 모드는 ReactElement를 `React.createElement`에서 검증
-> 코드를 우회하는 객체 리터럴로 ReactElement를 인라인으로 만들 수 있습니다.
-
-## 네임스페이스를 사용한 컴포넌트
-
-폼같은 자식을 많이 가지는 컴포넌트를 만든다면, 많은 변수 선언을 하게 될 것입니다.
-
-```javascript
-// 변수 선언의 어색한 블록
-var Form = MyFormComponent;
-var FormRow = Form.Row;
-var FormLabel = Form.Label;
-var FormInput = Form.Input;
-
-var App = (
-
-);
-```
-
-더 간단하고 쉽게 *네임스페이스를 사용한 컴포넌트*를 사용해서, 다른 컴포넌트를 어트리뷰트로 가지는 하나의 컴포넌트만 쓸 수 있습니다.
-
-```javascript
-var Form = MyFormComponent;
-
-var App = (
-
-
-
-
-
-);
-```
-
-이렇게 하려면, *"sub-components"*를 메인 컴포넌트의 어트리뷰트로 만들 필요가 있습니다.
-
-```javascript
-var MyFormComponent = React.createClass({ ... });
-
-MyFormComponent.Row = React.createClass({ ... });
-MyFormComponent.Label = React.createClass({ ... });
-MyFormComponent.Input = React.createClass({ ... });
-```
-
-코드를 컴파일할 때 JSX는 이것을 제대로 처리해 줍니다.
-
-```javascript
-var App = (
- React.createElement(Form, null,
- React.createElement(Form.Row, null,
- React.createElement(Form.Label, null),
- React.createElement(Form.Input, null)
- )
- )
-);
-```
-
-> 주의:
->
-> 이 기능은 [v0.11](/react/blog/2014/07/17/react-v0.11.html#jsx) 이상에만 있습니다.
-
-## JavaScript 표현식
-
-### 어트리뷰트 표현식
-
-JavaScript 표현식을 어트리뷰트 값으로 사용하려면, 표현식을 쌍따옴표(`""`)대신 중괄호(`{}`)로 감싸야 합니다.
-
-```javascript
-// 입력 (JSX):
-var person = ;
-// 출력 (JS):
-var person = React.createElement(
- Person,
- {name: window.isLoggedIn ? window.name : ''}
-);
-```
-
-### 불린 어트리뷰트
-
-어트리뷰트의 값을 생략하면 JSX는 값을 `true`로 취급합니다. 어트리뷰트 표현식에 `false`를 넘기려면 사용해야만 합니다. HTML 폼 엘리먼트에 `disabled`, `required`, `checked`, `readOnly`같은 어트리뷰트를 사용할 일이 자주 있습니다.
-
-```javascript
-// JSX에서 이 두 줄은 똑같이 버튼을 비활성화합니다.
-;
-;
-
-// 그리고 JSX에서 이 두 줄은 똑같이 버튼을 비활성화하지 않습니다.
-;
-;
-```
-
-### 자식 표현식
-
-비슷하게, JavaScript 표현식을 자식을 표현하는 데 사용할 수 있습니다.
-
-```javascript
-// 입력 (JSX):
-var content = {window.isLoggedIn ? : };
-// 출력 (JS):
-var content = React.createElement(
- Container,
- null,
- window.isLoggedIn ? React.createElement(Nav) : React.createElement(Login)
-);
-```
-
-### 주석
-
-JSX에 주석을 넣기는 쉽습니다. 그냥 JS 표현식과 같습니다. 그냥 태그의 자식 섹션에서만 조심하시면 됩니다. 이럴 땐 주석 주변에 `{}`를 감싸야 합니다.
-
-```javascript
-var content = (
-
-);
-```
-
-> 주의:
->
-> JSX 는 HTML과 비슷하지만 완전히 같지는 않습니다. 중요한 차이점을 보시려면 [JSX gotchas](/react/docs/jsx-gotchas-ko-KR.html)를 보세요.
diff --git a/docs/docs/02.1-jsx-in-depth.md b/docs/docs/02.1-jsx-in-depth.md
deleted file mode 100644
index 9a3a77cc98..0000000000
--- a/docs/docs/02.1-jsx-in-depth.md
+++ /dev/null
@@ -1,224 +0,0 @@
----
-id: jsx-in-depth
-title: JSX in Depth
-permalink: docs/jsx-in-depth.html
-prev: displaying-data.html
-next: jsx-spread.html
----
-
-[JSX](https://facebook.github.io/jsx/) is a JavaScript syntax extension that looks similar to XML. You can use a simple JSX syntactic transform with React.
-
-## Why JSX?
-
-You don't have to use JSX with React. You can just use plain JS. However, we recommend using JSX because it is a concise and familiar syntax for defining tree structures with attributes.
-
-It's more familiar for casual developers such as designers.
-
-XML has the benefit of balanced opening and closing tags. This helps make large trees easier to read than function calls or object literals.
-
-It doesn't alter the semantics of JavaScript.
-
-## HTML Tags vs. React Components
-
-React can either render HTML tags (strings) or React components (classes).
-
-To render an HTML tag, just use lower-case tag names in JSX:
-
-```javascript
-var myDivElement = ;
-ReactDOM.render(myDivElement, document.getElementById('example'));
-```
-
-To render a React Component, just create a local variable that starts with an upper-case letter:
-
-```javascript
-var MyComponent = React.createClass({/*...*/});
-var myElement = ;
-ReactDOM.render(myElement, document.getElementById('example'));
-```
-
-React's JSX uses the upper vs. lower case convention to distinguish between local component classes and HTML tags.
-
-> Note:
->
-> Since JSX is JavaScript, identifiers such as `class` and `for` are discouraged
-> as XML attribute names. Instead, React DOM components expect DOM property
-> names like `className` and `htmlFor`, respectively.
-
-## The Transform
-
-React JSX transforms from an XML-like syntax into native JavaScript. XML elements, attributes and children are transformed into arguments that are passed to `React.createElement`.
-
-```javascript
-var Nav;
-// Input (JSX):
-var app = ;
-// Output (JS):
-var app = React.createElement(Nav, {color:"blue"});
-```
-
-Notice that in order to use ``, the `Nav` variable must be in scope.
-
-JSX also allows specifying children using XML syntax:
-
-```javascript
-var Nav, Profile;
-// Input (JSX):
-var app = ;
-// Output (JS):
-var app = React.createElement(
- Nav,
- {color:"blue"},
- React.createElement(Profile, null, "click")
-);
-```
-
-JSX will infer the class's [displayName](/react/docs/component-specs.html#displayname) from the variable assignment when the displayName is undefined:
-
-```javascript
-// Input (JSX):
-var Nav = React.createClass({ });
-// Output (JS):
-var Nav = React.createClass({displayName: "Nav", });
-```
-
-Use the [Babel REPL](https://babeljs.io/repl/) to try out JSX and see how it desugars into native JavaScript, and the [HTML to JSX converter](http://magic.reactjs.net/htmltojsx.htm) to convert your existing HTML to JSX.
-
-If you want to use JSX, the [Getting Started](/react/docs/getting-started.html) guide shows how to set up compilation.
-
-> Note:
->
-> The JSX expression always evaluates to a ReactElement. The actual
-> implementation details may vary. An optimized mode could inline the
-> ReactElement as an object literal to bypass the validation code in
-> `React.createElement`.
-
-## Namespaced Components
-
-If you are building a component that has many children, like a form, you might end up with something with a lot of variable declarations:
-
-```javascript
-// Awkward block of variable declarations
-var Form = MyFormComponent;
-var FormRow = Form.Row;
-var FormLabel = Form.Label;
-var FormInput = Form.Input;
-
-var App = (
-
-);
-```
-
-To make it simpler and easier, *namespaced components* let you use one component that has other components as attributes:
-
-```javascript
-var Form = MyFormComponent;
-
-var App = (
-
-
-
-
-
-);
-```
-
-To do this, you just need to create your *"sub-components"* as attributes of the main component:
-
-```javascript
-var MyFormComponent = React.createClass({ ... });
-
-MyFormComponent.Row = React.createClass({ ... });
-MyFormComponent.Label = React.createClass({ ... });
-MyFormComponent.Input = React.createClass({ ... });
-```
-
-JSX will handle this properly when compiling your code.
-
-```javascript
-var App = (
- React.createElement(Form, null,
- React.createElement(Form.Row, null,
- React.createElement(Form.Label, null),
- React.createElement(Form.Input, null)
- )
- )
-);
-```
-
-> Note:
->
-> This feature is available in [v0.11](/react/blog/2014/07/17/react-v0.11.html#jsx) and above.
-
-## JavaScript Expressions
-
-### Attribute Expressions
-
-To use a JavaScript expression as an attribute value, wrap the expression in a pair of curly braces (`{}`) instead of quotes (`""`).
-
-```javascript
-// Input (JSX):
-var person = ;
-// Output (JS):
-var person = React.createElement(
- Person,
- {name: window.isLoggedIn ? window.name : ''}
-);
-```
-
-### Boolean Attributes
-
-Omitting the value of an attribute causes JSX to treat it as `true`. To pass `false` an attribute expression must be used. This often comes up when using HTML form elements, with attributes like `disabled`, `required`, `checked` and `readOnly`.
-
-```javascript
-// These two are equivalent in JSX for disabling a button
-;
-;
-
-// And these two are equivalent in JSX for not disabling a button
-;
-;
-```
-
-### Child Expressions
-
-Likewise, JavaScript expressions may be used to express children:
-
-```javascript
-// Input (JSX):
-var content = {window.isLoggedIn ? : };
-// Output (JS):
-var content = React.createElement(
- Container,
- null,
- window.isLoggedIn ? React.createElement(Nav) : React.createElement(Login)
-);
-```
-
-### Comments
-
-It's easy to add comments within your JSX; they're just JS expressions. You just need to be careful to put `{}` around the comments when you are within the children section of a tag.
-
-```javascript
-var content = (
-
-);
-```
-
-> NOTE:
->
-> JSX is similar to HTML, but not exactly the same. See [JSX gotchas](/react/docs/jsx-gotchas.html) for some key differences.
diff --git a/docs/docs/02.1-jsx-in-depth.zh-CN.md b/docs/docs/02.1-jsx-in-depth.zh-CN.md
deleted file mode 100644
index ebf5aa26d2..0000000000
--- a/docs/docs/02.1-jsx-in-depth.zh-CN.md
+++ /dev/null
@@ -1,224 +0,0 @@
----
-id: jsx-in-depth-zh-CN
-title: 深入 JSX
-permalink: docs/jsx-in-depth-zh-CN.html
-prev: displaying-data-zh-CN.html
-next: jsx-spread-zh-CN.html
----
-
-[JSX](https://facebook.github.io/jsx/) 是一个看起来很像 XML 的 JavaScript 语法扩展。React 可以用来做简单的 JSX 句法转换。
-
-## 为什么要用 JSX?
-
-你不需要为了 React 使用 JSX,可以直接使用原生 JS。但是,我们建议使用 JSX 是因为它能精确,也是常用的定义包含属性的树状结构的语法。
-
-它对于非专职开发者比如设计师也比较熟悉。
-
-XML 有固定的标签开启和闭合的优点。这能让复杂的树更易于阅读,优于方法调用和对象字面量的形式。
-
-它没有修改 JavaScript 语义。
-
-
-## HTML 标签对比 React 组件
-
-React 可以渲染 HTML 标签 (strings) 或 React 组件 (classes)。
-
-要渲染 HTML 标签,只需在 JSX 里使用小写字母的标签名。
-
-```javascript
-var myDivElement = ;
-ReactDOM.render(myDivElement, document.getElementById('example'));
-```
-
-要渲染 React 组件,只需创建一个大写字母开头的本地变量。
-
-```javascript
-var MyComponent = React.createClass({/*...*/});
-var myElement = ;
-ReactDOM.render(myElement, document.getElementById('example'));
-```
-
-React 的 JSX 使用大、小写的约定来区分本地组件的类和 HTML 标签。
-
-> 注意:
->
-> 由于 JSX 就是 JavaScript,一些标识符像 `class` 和 `for` 不建议作为 XML
-> 属性名。作为替代,React DOM 使用 `className` 和 `htmlFor` 来做对应的属性。
-
-## 转换(Transform)
-
-JSX 把类 XML 的语法转成原生 JavaScript,XML 元素、属性和子节点被转换成 `React.createElement` 的参数。
-
-```javascript
-var Nav;
-// 输入 (JSX):
-var app = ;
-// 输出 (JS):
-var app = React.createElement(Nav, {color:"blue"});
-```
-
-注意,要想使用 ``,`Nav` 变量一定要在作用区间内。
-
-JSX 也支持使用 XML 语法定义子结点:
-
-```javascript
-var Nav, Profile;
-// 输入 (JSX):
-var app = ;
-// 输出 (JS):
-var app = React.createElement(
- Nav,
- {color:"blue"},
- React.createElement(Profile, null, "click")
-);
-```
-
-当显示名称没有定义时,JSX 会根据变量赋值来推断类的 [显示名称](/react/docs/component-specs.html#displayname) :
-
-```javascript
-// 输入 (JSX):
-var Nav = React.createClass({ });
-// 输出 (JS):
-var Nav = React.createClass({displayName: "Nav", });
-```
-
-使用 [JSX 编译器](/react/jsx-compiler.html) 来试用 JSX 并理解它是如何转换到原生 JavaScript,还有 [HTML 到 JSX 转换器](http://magic.reactjs.net/htmltojsx.htm) 来把现有 HTML 转成 JSX。
-
-如果你要使用 JSX,这篇 [新手入门](/react/docs/getting-started.html) 教程来教你如何搭建环境。
-
-> 注意:
->
->
-> JSX 表达式总是会当作 ReactElement 执行。具体的实际细节可能不同。一种优化
-> 的模式是把 ReactElement 当作一个行内的对象字面量形式来绕过
-> `React.createElement` 里的校验代码。
-
-## 命名组件(Namespaced Components)
-
-如果你正在构建一个有很多子组件的组件,比如表单,你也许会最终得到许多的变量声明。
-
-```javascript
-// 尴尬的变量声明块
-var Form = MyFormComponent;
-var FormRow = Form.Row;
-var FormLabel = Form.Label;
-var FormInput = Form.Input;
-
-var App = (
-
-);
-```
-
-为了使其更简单和容易,*命名组件*令你使用包含其他组件作为属性的单一的组件。
-
-```javascript
-var Form = MyFormComponent;
-
-var App = (
-
-
-
-
-
-);
-```
-
-要做到这一点,你只需要把你的*"子组件"*创建为主组件的属性。
-
-```javascript
-var MyFormComponent = React.createClass({ ... });
-
-MyFormComponent.Row = React.createClass({ ... });
-MyFormComponent.Label = React.createClass({ ... });
-MyFormComponent.Input = React.createClass({ ... });
-```
-
-当编译你的代码时,JSX会恰当的进行处理。
-
-```javascript
-var App = (
- React.createElement(Form, null,
- React.createElement(Form.Row, null,
- React.createElement(Form.Label, null),
- React.createElement(Form.Input, null)
- )
- )
-);
-```
-
-> 注意:
->
-> 此特性在 [v0.11](/react/blog/2014/07/17/react-v0.11.html#jsx) 及以上可用.
-
-## JavaScript 表达式
-
-### 属性表达式
-
-要使用 JavaScript 表达式作为属性值,只需把这个表达式用一对大括号 (`{}`) 包起来,不要用引号 (`""`)。
-
-```javascript
-// 输入 (JSX):
-var person = ;
-// 输出 (JS):
-var person = React.createElement(
- Person,
- {name: window.isLoggedIn ? window.name : ''}
-);
-```
-
-### Boolean 属性
-
-省略一个属性的值会导致JSX把它当做 `true`。要传值 `false`必须使用属性表达式。这常出现于使用HTML表单元素,含有属性如`disabled`, `required`, `checked` 和 `readOnly`。
-
-```javascript
-// 在JSX中,对于禁用按钮这二者是相同的。
-;
-;
-
-// 在JSX中,对于不禁用按钮这二者是相同的。
-;
-;
-```
-
-### 子节点表达式
-
-同样地,JavaScript 表达式可用于描述子结点:
-
-```javascript
-// 输入 (JSX):
-var content = {window.isLoggedIn ? : };
-// 输出 (JS):
-var content = React.createElement(
- Container,
- null,
- window.isLoggedIn ? React.createElement(Nav) : React.createElement(Login)
-);
-```
-
-### 注释
-
-JSX 里添加注释很容易;它们只是 JS 表达式而已。你仅仅需要小心的是当你在一个标签的子节点块时,要用 `{}` 包围要注释的部分。
-
-```javascript
-var content = (
-
-);
-```
-
-> 注意:
->
-> JSX 类似于 HTML,但不完全一样。参考 [JSX 陷阱](/react/docs/jsx-gotchas-zh-CN.html) 了解主要不同。
diff --git a/docs/docs/02.2-jsx-spread.it-IT.md b/docs/docs/02.2-jsx-spread.it-IT.md
deleted file mode 100644
index 6c77990558..0000000000
--- a/docs/docs/02.2-jsx-spread.it-IT.md
+++ /dev/null
@@ -1,52 +0,0 @@
----
-id: jsx-spread-it-IT
-title: Attributi Spread JSX
-permalink: docs/jsx-spread-it-IT.html
-prev: jsx-in-depth-it-IT.html
-next: jsx-gotchas-it-IT.html
----
-
-Se sai in anticipo che tutte le proprietà che desideri assegnare ad un componente, usare JSX è facile:
-
-```javascript
- var component = ;
-```
-
-## Le Props Mutevoli sono il Male
-
-Se non sai quali proprietà desideri impostare, potresti essere tentato di aggiungerle all'oggetto in seguito:
-
-```javascript
- var component = ;
- component.props.foo = x; // male
- component.props.bar = y; // altrettanto male
-```
-
-Questo è un anti-pattern perché significa che non possiamo aiutarti a verificare i propTypes per tempo. Ciò significa che i tuoi errori di propTypes finiscono per avere uno stack trace indecifrabile.
-
-Le props dovrebbero essere considerate immutabili. Mutare l'oggetto props altrove potrebbe causare conseguenze inattese, quindi a questo punto dovrebbe essere idealmente considerato un oggetto congelato.
-
-## Attributi Spread
-
-Adesso puoi utilizzare una nuova caratteristica di JSX chiamata attributi spread:
-
-```javascript
- var props = {};
- props.foo = x;
- props.bar = y;
- var component = ;
-```
-
-Le proprietà dell'oggetto che passi al componente sono copiate nelle sue props.
-
-Puoi usarlo più volte o combinarlo con altri attributi. L'ordine in cui sono specificati è rilevante. Attributi successivi ridefiniscono quelli precedentemente impostati.
-
-```javascript
- var props = { foo: 'default' };
- var component = ;
- console.log(component.props.foo); // 'override'
-```
-
-## Cos'è la strana notazione `...`?
-
-L'operatore `...` (o operatore spread) è già supportato per gli [array in ES6](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator). Esiste anche una proposta per ES7 per le proprietà [Spread e Rest di Object](https://github.com/sebmarkbage/ecmascript-rest-spread). Stiamo prendendo spunto da questi standard supportati o in corso di sviluppo per fornire una sintassi più pulita a JSX.
diff --git a/docs/docs/02.2-jsx-spread.ja-JP.md b/docs/docs/02.2-jsx-spread.ja-JP.md
deleted file mode 100644
index c3c14f4cf5..0000000000
--- a/docs/docs/02.2-jsx-spread.ja-JP.md
+++ /dev/null
@@ -1,52 +0,0 @@
----
-id: jsx-spread
-title: JSXの拡張属性
-permalink: docs/jsx-spread-ja-JP.html
-prev: jsx-in-depth-ja-JP.html
-next: jsx-gotchas-ja-JP.html
----
-
-以下のように、コンポーネントにどのようなプロパティを配置したいか前もって全て分かっている場合は、JSXを使うことは簡単です。
-
-```javascript
- var component = ;
-```
-
-## Propsを変更してはいけない
-
-セットしたいプロパティが分からない場合は、以下のように後からオブジェクトに追加したいと思うでしょう。
-
-```javascript
- var component = ;
- component.props.foo = x; // だめ
- component.props.bar = y; // 同様にだめ
-```
-
-これはアンチパターンです。なぜなら、後々まで正しいpropTypesであるかどうかチェックすることを助けることができないことを意味するからです。これは、propTypesのエラーが隠されたスタックトレースに出力されて終わってしまうことを意味します。
-
-propsは変更不可と考えられるべきです。propsのオブジェクトをどこかで変更することは予期せぬ結果を発生させる可能性があるので、理想的には、この時点ではpropsは固定のオブジェクトであるべきです。
-
-## 拡張属性
-
-以下のように、拡張属性というJSXの新しい特徴を使うことができます。
-
-```javascript
- var props = {};
- props.foo = x;
- props.bar = y;
- var component = ;
-```
-
-あなたが渡したオブジェクトのプロパティはコンポーネントのpropsにコピーされます。
-
-これを複数回使用したり、他の属性と組み合わせたりすることもできます。仕様書では、順序が重要となっています。後の属性は前の属性をオーバーライドします。
-
-```javascript
- var props = { foo: 'default' };
- var component = ;
- console.log(component.props.foo); // 'override'
-```
-
-## 奇妙な `...` という表現は何でしょうか?
-
-`...` 操作(拡張操作)は既に[ES6のarrays](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator)でサポートされています。[Object Rest と Spread Properties](https://github.com/sebmarkbage/ecmascript-rest-spread)のES7のプロポーザルもあります。JSXのきれいなシンタックスを供給するために、それらのサポートや開発中の標準使用を利用しています。
diff --git a/docs/docs/02.2-jsx-spread.ko-KR.md b/docs/docs/02.2-jsx-spread.ko-KR.md
deleted file mode 100644
index ea63c5eee8..0000000000
--- a/docs/docs/02.2-jsx-spread.ko-KR.md
+++ /dev/null
@@ -1,52 +0,0 @@
----
-id: jsx-spread-ko-KR
-title: JSX 스프레드 어트리뷰트
-permalink: docs/jsx-spread-ko-KR.html
-prev: jsx-in-depth-ko-KR.html
-next: jsx-gotchas-ko-KR.html
----
-
-미리 컴포넌트에 넣을 모든 프로퍼티를 알게 된다면, JSX를 사용하기 쉬워집니다.
-
-```javascript
- var component = ;
-```
-
-## Props의 변경은 나빠요
-
-하지만 어떤 프로퍼티를 설정하고 싶은지 모른다면, 객체 레이어에 넣고 싶어질 수도 있습니다.
-
-```javascript
- var component = ;
- component.props.foo = x; // 나쁨
- component.props.bar = y; // 역시 나쁨
-```
-
-이것은 안티 패턴입니다. 왜냐하면 한참 뒤까지 정확한 propTypes을 체크할 수 없다는 뜻이기 때문입니다. 이것은 propTypes 에러는 알기 힘든 스택 트레이스로 끝난다는 의미입니다.
-
-props는 변하지 않는 것으로 간주해야 합니다. props 객체를 변경하는 것은 다른 곳에서 예기치 못한 결과가 생길 수 있기 때문에 이상적으로는 이 시점에서 frozen 객체가 되어야 합니다.
-
-## 스프레드 어트리뷰트
-
-이제 JSX의 새로운 기능인 스프레드 어트리뷰트를 사용하실 수 있습니다.
-
-```javascript
- var props = {};
- props.foo = x;
- props.bar = y;
- var component = ;
-```
-
-전달한 객체의 프로퍼티가 컴포넌트의 props에 복사됩니다.
-
-이렇게 여러 번 사용하거나 다른 어트리뷰트와 조합해서 사용할 수 있습니다. 명세의 순서는 중요합니다. 나중의 어트리뷰트가 이전 것보다 우선되기 때문입니다.
-
-```javascript
- var props = { foo: 'default' };
- var component = ;
- console.log(component.props.foo); // 'override'
-```
-
-## 이상한 `...` 표기법은 무엇인가요?
-
-`...` 연산자(스프레드 연산자)는 이미 [ES6의 배열](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator)에서 지원합니다. [객체 rest와 스프레드 프로퍼티](https://github.com/sebmarkbage/ecmascript-rest-spread)에 대한 ES7의 제안도 있습니다. JSX의 구문을 더 깔끔하게 하기 위해 지원되고 개발중인 표준을 활용하고 있습니다.
diff --git a/docs/docs/02.2-jsx-spread.md b/docs/docs/02.2-jsx-spread.md
deleted file mode 100644
index 2363d7268a..0000000000
--- a/docs/docs/02.2-jsx-spread.md
+++ /dev/null
@@ -1,52 +0,0 @@
----
-id: jsx-spread
-title: JSX Spread Attributes
-permalink: docs/jsx-spread.html
-prev: jsx-in-depth.html
-next: jsx-gotchas.html
----
-
-If you know all the properties that you want to place on a component ahead of time, it is easy to use JSX:
-
-```javascript
- var component = ;
-```
-
-## Mutating Props is Bad
-
-If you don't know which properties you want to set, you might be tempted to add them onto the object later:
-
-```javascript
- var component = ;
- component.props.foo = x; // bad
- component.props.bar = y; // also bad
-```
-
-This is an anti-pattern because it means that we can't help you check the right propTypes until way later. This means that your propTypes errors end up with a cryptic stack trace.
-
-The props should be considered immutable. Mutating the props object somewhere else could cause unexpected consequences so ideally it would be a frozen object at this point.
-
-## Spread Attributes
-
-Now you can use a new feature of JSX called spread attributes:
-
-```javascript
- var props = {};
- props.foo = x;
- props.bar = y;
- var component = ;
-```
-
-The properties of the object that you pass in are copied onto the component's props.
-
-You can use this multiple times or combine it with other attributes. The specification order is important. Later attributes override previous ones.
-
-```javascript
- var props = { foo: 'default' };
- var component = ;
- console.log(component.props.foo); // 'override'
-```
-
-## What's with the weird `...` notation?
-
-The `...` operator (or spread operator) is already supported for [arrays in ES6](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator). There is also an ECMAScript proposal for [Object Rest and Spread Properties](https://github.com/sebmarkbage/ecmascript-rest-spread). We're taking advantage of these supported and developing standards in order to provide a cleaner syntax in JSX.
diff --git a/docs/docs/02.2-jsx-spread.zh-CN.md b/docs/docs/02.2-jsx-spread.zh-CN.md
deleted file mode 100644
index 7d381f8b00..0000000000
--- a/docs/docs/02.2-jsx-spread.zh-CN.md
+++ /dev/null
@@ -1,52 +0,0 @@
----
-id: jsx-spread-zh-CN
-title: JSX 展开属性
-permalink: docs/jsx-spread-zh-CN.html
-prev: jsx-in-depth-zh-CN.html
-next: jsx-gotchas-zh-CN.html
----
-
-如果你事先知道组件需要的全部 Props(属性),JSX 很容易地这样写:
-
-```javascript
- var component = ;
-```
-
-## 修改 Props 是不好的,明白吗
-
-如果你不知道要设置哪些 Props,那么现在最好不要设置它:
-
-```javascript
- var component = ;
- component.props.foo = x; // 不好
- component.props.bar = y; // 同样不好
-```
-
-这样是反模式,因为 React 不能帮你检查属性类型(propTypes)。这样即使你的 属性类型有错误也不能得到清晰的错误提示。
-
-Props 应该被认为是不可变的。在别处修改 props 对象可能会导致预料之外的结果,所以原则上这将是一个冻结的对象。
-
-## 展开属性(Spread Attributes)
-
-现在你可以使用 JSX 的新特性 - 展开属性:
-
-```javascript
- var props = {};
- props.foo = x;
- props.bar = y;
- var component = ;
-```
-
-传入对象的属性会被复制到组件内。
-
-它能被多次使用,也可以和其它属性一起用。注意顺序很重要,后面的会覆盖掉前面的。
-
-```javascript
- var props = { foo: 'default' };
- var component = ;
- console.log(component.props.foo); // 'override'
-```
-
-## 这个奇怪的 `...` 标记是什么?
-
-这个 `...` 操作符(增强的操作符)已经被 [ES6 数组](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator) 支持。相关的还有 ECMAScript 规范草案中的 [Object 剩余和展开属性(Rest and Spread Properties)](https://github.com/sebmarkbage/ecmascript-rest-spread)。我们利用了这些还在制定中标准中已经被支持的特性来使 JSX 拥有更优雅的语法。
diff --git a/docs/docs/02.3-jsx-gotchas.it-IT.md b/docs/docs/02.3-jsx-gotchas.it-IT.md
deleted file mode 100644
index 7b28ac4cf7..0000000000
--- a/docs/docs/02.3-jsx-gotchas.it-IT.md
+++ /dev/null
@@ -1,68 +0,0 @@
----
-id: jsx-gotchas-it-IT
-title: JSX Gotchas
-permalink: docs/jsx-gotchas-it-IT.html
-prev: jsx-spread-it-IT.html
-next: interactivity-and-dynamic-uis-it-IT.html
----
-
-JSX somiglia all'HTML ma ci sono delle differenze importanti da tenere in considerazione.
-
-> Nota:
->
-> Per le differenze del DOM, come l'attributo `style` in linea, consulta [here](/react/docs/dom-differences-it-IT.html).
-
-## Entità HTML
-
-Puoi inserire entità HTML nel testo letterale in JSX:
-
-```javascript
-
Primo · Secondo
-```
-
-Se desideri visualizzare un'entità HTML all'interno di un contenuto dinamico, avrai problemi con il doppio escape, poiché React effettua in maniera predefinita l'escape di tutte le stringhe visualizzate per prevenire un'ampia gamma di attacchi XSS.
-
-```javascript
-// Male: Mostra "Primo · Secondo"
-
{'Primo · Secondo'}
-```
-
-Esistono molte maniere di aggirare questo problema. La più facile è scrivere i caratteri Unicode direttamente in JavaScript. Dovrai assicurarti che il file sia salvato come UTF-8 e che le appropriate direttive UTF-8 siano impostate in modo che il browser li visualizzi correttamente.
-
-```javascript
-
{'Primo · Secondo'}
-```
-
-Un'alternativa più sicura consiste nel trovare il [codice Unicode corrispondente all'entità](http://www.fileformat.info/info/unicode/char/b7/index.htm) e usarlo all'interno di una stringa JavaScript.
-
-```javascript
-
-```
-
-最後の手段として、常に[生のHTMLを挿入](/react/tips/dangerously-set-inner-html.html)することもできます。
-
-```javascript
-
-```
-
-
-## カスタムされたHTMLの属性
-
-HTMLの仕様書に存在しない要素をネイティブなHTML要素に渡した場合は、Reactはそれらをレンダリングしません。カスタムした属性を使う場合は、 `data-` を頭につけてください。
-
-```javascript
-
-```
-
-`aria-` から始まる[Webアクセシビリティ](http://www.w3.org/WAI/intro/aria)属性はプロパティをレンダリングします。
-
-```javascript
-
-```
diff --git a/docs/docs/02.3-jsx-gotchas.ko-KR.md b/docs/docs/02.3-jsx-gotchas.ko-KR.md
deleted file mode 100644
index a2900cd583..0000000000
--- a/docs/docs/02.3-jsx-gotchas.ko-KR.md
+++ /dev/null
@@ -1,68 +0,0 @@
----
-id: jsx-gotchas-ko-KR
-title: JSX Gotchas
-permalink: docs/jsx-gotchas-ko-KR.html
-prev: jsx-spread-ko-KR.html
-next: interactivity-and-dynamic-uis-ko-KR.html
----
-
-JSX는 HTML처럼 보이지만, 작업하다 보면 마주치게 될 몇 가지 중요한 차이점이 있습니다.
-
-> 주의:
->
-> 인라인 `style` 어트리뷰트 같은 DOM과의 차이점은 [여기](/react/tips/dangerously-set-inner-html-ko-KR.html)를 보세요.
-
-## HTML 엔티티
-
-JSX의 리터럴 텍스트에 HTML 엔티티를 넣을 수 있습니다.
-
-```javascript
-
First · Second
-```
-
-동적 콘텐츠 안에 HTML 엔티티를 표시하려 할 때, React에서는 XSS 공격을 광범위하게 막기 위해서 기본적으로 모든 표시하는 문자열을 이스케이프 하기 때문에 더블 이스케이프 문제에 부딪히게 됩니다.
-
-```javascript
-// 나쁨: "First · Second"를 표시
-
{'First · Second'}
-```
-
-이 이슈를 피해 갈 방법은 여럿 있지만, 가장 쉬운 방법은 유니코드 문자를 JavaScript에 직접 쓰는 것입니다. 브라우저가 올바르게 표시하도록 파일이 UTF-8으로 저장되어 있고 올바른 UTF-8 지시자를 사용하고 있는지 확인해야 합니다.
-
-```javascript
-
{'First · Second'}
-```
-
-더 안전한 대안으로 [엔티티에 대응하는 유니코드 숫자](http://www.fileformat.info/info/unicode/char/b7/index.htm)를 찾아 JavaScript 문자열 안에서 사용하는 방법도 있습니다.
-
-```javascript
-
{'First \u00b7 Second'}
-
{'First ' + String.fromCharCode(183) + ' Second'}
-```
-
-문자열과 JSX 엘리먼트를 혼합한 배열을 사용할 수도 있습니다.
-
-```javascript
-
{['First ', ·, ' Second']}
-```
-
-최후의 수단으로, 항상 [생 HTML을 삽입](/react/docs/dom-differences-ko-KR.html)할 수 있습니다.
-
-```javascript
-
-```
-
-
-## 커스텀 HTML 어트리뷰트
-
-프로퍼티를 HTML 사양에는 없는 네이티브 HTML 엘리먼트에 넘기면, React는 그 프로퍼티를 렌더하지 않습니다. 커스텀 어트리뷰트를 사용하고 싶다면, 접두사로 `data-`를 붙이셔야 합니다.
-
-```javascript
-
-```
-
-`aria-`로 시작하는 [Web 접근성](http://www.w3.org/WAI/intro/aria) 어트리뷰트는 제대로 렌더될 것입니다.
-
-```javascript
-
-```
diff --git a/docs/docs/02.3-jsx-gotchas.md b/docs/docs/02.3-jsx-gotchas.md
deleted file mode 100644
index 8d167bbd9a..0000000000
--- a/docs/docs/02.3-jsx-gotchas.md
+++ /dev/null
@@ -1,74 +0,0 @@
----
-id: jsx-gotchas
-title: JSX Gotchas
-permalink: docs/jsx-gotchas.html
-prev: jsx-spread.html
-next: interactivity-and-dynamic-uis.html
----
-
-JSX looks like HTML but there are some important differences you may run into.
-
-> Note:
->
-> For DOM differences, such as the inline `style` attribute, check [here](/react/docs/dom-differences.html).
-
-## HTML Entities
-
-You can insert HTML entities within literal text in JSX:
-
-```javascript
-
First · Second
-```
-
-If you want to display an HTML entity within dynamic content, you will run into double escaping issues as React escapes all the strings you are displaying in order to prevent a wide range of XSS attacks by default.
-
-```javascript
-// Bad: It displays "First · Second"
-
{'First · Second'}
-```
-
-There are various ways to work-around this issue. The easiest one is to write Unicode characters directly in JavaScript. You need to make sure that the file is saved as UTF-8 and that the proper UTF-8 directives are set so the browser will display it correctly.
-
-```javascript
-
{'First · Second'}
-```
-
-A safer alternative is to find the [unicode number corresponding to the entity](http://www.fileformat.info/info/unicode/char/b7/index.htm) and use it inside of a JavaScript string.
-
-```javascript
-
{'First \u00b7 Second'}
-
{'First ' + String.fromCharCode(183) + ' Second'}
-```
-
-You can use mixed arrays with strings and JSX elements. Each JSX element in the array needs a unique key.
-
-```javascript
-
{['First ', ·, ' Second']}
-```
-
-As a last resort, you always have the ability to [insert raw HTML](/react/tips/dangerously-set-inner-html.html).
-
-```javascript
-
-```
-
-
-## Custom HTML Attributes
-
-If you pass properties to native HTML elements that do not exist in the HTML specification, React will not render them. If you want to use a custom attribute, you should prefix it with `data-`.
-
-```javascript
-
-```
-
-However, arbitrary attributes are supported on custom elements (those with a hyphen in the tag name or an `is="..."` attribute).
-
-```javascript
-
-```
-
-[Web Accessibility](http://www.w3.org/WAI/intro/aria) attributes starting with `aria-` will be rendered properly.
-
-```javascript
-
-```
diff --git a/docs/docs/02.3-jsx-gotchas.zh-CN.md b/docs/docs/02.3-jsx-gotchas.zh-CN.md
deleted file mode 100644
index 2127ebcdf0..0000000000
--- a/docs/docs/02.3-jsx-gotchas.zh-CN.md
+++ /dev/null
@@ -1,74 +0,0 @@
----
-id: jsx-gotchas-zh-CN
-title: JSX 陷阱
-permalink: docs/jsx-gotchas-zh-CN.html
-prev: jsx-spread-zh-CN.html
-next: interactivity-and-dynamic-uis-zh-CN.html
----
-
-JSX 与 HTML 非常相似,但是有些关键区别要注意。
-
-> 注意:
->
-> 关于 DOM 的区别,如行内样式属性 `style`,参考 [DOM 区别](/react/docs/dom-differences.html)
-
-## HTML 实体
-
-HTML 实体可以插入到 JSX 的文本中。
-
-```javascript
-
-```
-
-万不得已,可以直接[插入原始HTML](/react/tips/dangerously-set-inner-html.html)。
-
-```javascript
-
-```
-
-
-## 自定义 HTML 属性
-
-如果往原生 HTML 元素里传入 HTML 规范里不存在的属性,React 不会显示它们。如果需要使用自定义属性,要加 `data-` 前缀。
-
-```javascript
-
-```
-
-然而,在自定义元素中任意的属性都是被支持的 (那些在tag名里带有连接符或者 `is="..."` 属性的)
-
-```javascript
-
-```
-
-以 `aria-` 开头的 [网络无障碍](http://www.w3.org/WAI/intro/aria) 属性可以正常使用。
-
-```javascript
-
-```
diff --git a/docs/docs/03-interactivity-and-dynamic-uis.it-IT.md b/docs/docs/03-interactivity-and-dynamic-uis.it-IT.md
deleted file mode 100644
index 5aea1b9eb3..0000000000
--- a/docs/docs/03-interactivity-and-dynamic-uis.it-IT.md
+++ /dev/null
@@ -1,84 +0,0 @@
----
-id: interactivity-and-dynamic-uis-it-IT
-title: Interattività e UI Dinamiche
-permalink: docs/interactivity-and-dynamic-uis-it-IT.html
-prev: jsx-gotchas-it-IT.html
-next: multiple-components-it-IT.html
----
-
-Hai già [imparato a mostrare dati](/react/docs/displaying-data-it-IT.html) con React. Adesso vediamo come rendere le nostre UI interattive.
-
-
-## Un Esempio Semplice
-
-```javascript
-var LikeButton = React.createClass({
- getInitialState: function() {
- return {liked: false};
- },
- handleClick: function(event) {
- this.setState({liked: !this.state.liked});
- },
- render: function() {
- var text = this.state.liked ? 'mi piace' : 'non mi piace';
- return (
-
- You {text} this. Click to toggle.
-
- );
- }
-});
-
-ReactDOM.render(
- ,
- document.getElementById('example')
-);
-```
-
-
-## Gestione degli Eventi ed Eventi Sintetici
-
-Con React devi semplicemente passare il tuo gestore di eventi come una proprietà camelCased in modo simile a come faresti nel normale HTML. React si assicura che tutti gli eventi si comportano in maniera identica in IE8 e successivi implementando un sistema di eventi sintetici. Ovvero, React sa come propagare e catturare eventi secondo la specifica, e garantisce che gli eventi passati ai tuoi gestori di eventi siano consistenti con la [specifica W3C](http://www.w3.org/TR/DOM-Level-3-Events/), qualunque browser tu stia utilizzando.
-
-
-## Dietro le Quinte: Binding Automatico e Delega degli Eventi
-
-Dietro le quinte, React esegue alcune operazioni per mantenere il tuo codice ad alte prestazioni e facile da comprendere.
-
-**Binding automatico:** Quando crei le callback in JavaScript, solitamente devi fare il binding esplicito del metodo alla sua istanza, in modo che il valore di `this` sia corretto. Con React, ogni metodo è automaticamente legato alla propria istanza del componente (eccetto quando si usa la sintassi delle classi ES6). React immagazzina il metodo legato in maniera tale da essere estremamente efficiente in termini di CPU e memoria. Ti permette anche di scrivere meno codice!
-
-**Delega degli eventi:** React non associa realmente i gestori di eventi ai nodi stessi. Quando React si avvia, comincia ad ascoltare tutti gli eventi a livello globale usando un singolo event listener. Quando un componente viene montato o smontato, i gestori di eventi sono semplicemente aggiunti o rimossi da un mapping interno. Quando si verifica un evento, React sa come inoltrarlo utilizzando questo mapping. Quando non ci sono più gestori di eventi rimasti nel mapping, i gestori di eventi di React sono semplici operazioni fittizie. Per saperne di più sul perché questo approccio è veloce, leggi [l'eccellente articolo sul blog di David Walsh](http://davidwalsh.name/event-delegate).
-
-
-## I Componenti Sono Macchine a Stati Finiti
-
-React considera le UI come semplici macchine a stati finiti. Pensando alla UI come in uno di tanti stati diversi e visualizzando questi stati, è facile mantenere la UI consistente.
-
-In React, aggiorni semplicemente lo stato di un componente, e quindi visualizzi una nuova UI basata su questo nuovo stato. React si occupa di aggiornare il DOM al tuo posto nella maniera più efficiente.
-
-
-## Come Funziona lo Stato
-
-Una maniera comune di informare React di un cambiamento nei dati è chiamare `setState(data, callback)`. Questo metodo effettua il merge di `data` in `this.state` e ridisegna il componente. Quando il componente ha terminato la fase di ri-rendering, la `callback` opzionale viene invocata. Nella maggior parte dei casi non avrai bisogno di fornire una `callback` dal momento che React si occuperà di mantenere la UI aggiornata per te.
-
-
-## Quali Componenti Devono Avere uno Stato?
-
-La maggior parte dei tuoi componenti dovrebbero semplicemente ricevere dei dati da `props` e visualizzarli. Tuttavia, a volte hai bisogno di reagire all'input dell'utente, una richiesta al server o il trascorrere del tempo. In questi casi utilizzi lo stato.
-
-**Prova a mantenere il maggior numero possibile dei tuoi componenti privi di stato.** Facendo ciò, isolerai lo stato nel suo luogo logicamente corretto e minimizzerai la ridondanza, rendendo più semplice ragionare sulla tua applicazione.
-
-Un pattern comune è quello di creare diversi componenti privi di stato che mostrano semplicemente dati, e di avere un componente dotato di stato al di sopra di essi nella gerarchia, che passa il proprio stato ai suoi figli tramite le `props`. Il componente dotato di stato incapsula tutta la logica di interazione, mentre i componenti privi di stato si occupano della visualizzazione dei dati in maniera dichiarativa.
-
-
-## Cosa *Dovrebbe* Contenere lo Stato?
-
-**Lo stato dovrebbe contenere dati che i gestori di eventi del componente possono modificare per scatenare un aggiornamento della UI.** In applicazioni reali, questi dati tendono ad essere molto limitati e serializzabili come JSON. Quando costruisci un componente dotato di stato, pensa alla minima rappresentazione possibile del suo stato, e conserva solo quelle proprietà in `this.state`. All'interno di `render()` calcola quindi ogni altra informazione necessaria basandoti sullo stato. Ti accorgerai che pensare e scrivere applicazioni in questo modo porta alla scrittura dell'applicazione più corretta, dal momento che aggiungere valori ridondanti o calcolati allo stato significherebbe doverli mantenere sincronizzati esplicitamente, anziché affidarti a React perché li calcoli al tuo posto.
-
-## Cosa *Non Dovrebbe* Contenere lo Stato?
-
-`this.state` dovrebbe contenere soltanto la quantità minima di dati indispensabile a rappresentare lo stato della tua UI. In quanto tale, non dovrebbe contenere:
-
-* **Dati calcolati:** Non preoccuparti di precalcolare valori basati sullo stato — è più semplice assicurarti che la tua UI sia consistente se effettui tutti i calcoli all'interno di `render()`. Per esempio, se lo stato contiene un array di elementi di una lista, e vuoi mostrare il numero di elementi come stringa, mostra semplicemente `this.state.listItems.length + ' elementi nella lista'` nel tuo metodo `render()` anziché conservarlo nello stato.
-* **Componenti React:** Costruiscili in `render()` basandoti sulle proprietà e sullo stato del componente.
-* **Dati duplicati dalle proprietà:** Prova ad utilizzare le proprietà come fonte di verità ove possibile. Un uso valido dello stato per i valori delle proprietà è conservarne il valore precedente quando le proprietà cambiano nel tempo.
diff --git a/docs/docs/03-interactivity-and-dynamic-uis.ja-JP.md b/docs/docs/03-interactivity-and-dynamic-uis.ja-JP.md
deleted file mode 100644
index a2e09662c9..0000000000
--- a/docs/docs/03-interactivity-and-dynamic-uis.ja-JP.md
+++ /dev/null
@@ -1,84 +0,0 @@
----
-id: interactivity-and-dynamic-uis
-title: 相互作用と動的なUI
-permalink: docs/interactivity-and-dynamic-uis-ja-JP.html
-prev: jsx-gotchas-ja-JP.html
-next: multiple-components-ja-JP.html
----
-
-Reactで[どうやってデータを表示するか](/react/docs/displaying-data-ja-JP.html)については既に学んでいます。これからは、どうやって相互に作用するUIを作成するかを見ていきましょう。
-
-
-## 単純な例
-
-```javascript
-var LikeButton = React.createClass({
- getInitialState: function() {
- return {liked: false};
- },
- handleClick: function(event) {
- this.setState({liked: !this.state.liked});
- },
- render: function() {
- var text = this.state.liked ? 'liked' : 'haven\'t liked';
- return (
-
- );
- }
-});
-
-ReactDOM.render(
- ,
- document.getElementById('example')
-);
-```
-
-## 이벤트 핸들링과 통합적인(Synthetic) 이벤트
-
-React에서의 이벤트 핸들러는 HTML에서 그러던 것처럼 간단히 카멜케이스 프로퍼티(camelCased prop)로 넘기면 됩니다. React의 모든 이벤트는 통합적인 이벤트 시스템의 구현으로 IE8 이상에서는 같은 행동이 보장됩니다. 즉, React는 사양에 따라 어떻게 이벤트를 일으키고(bubble) 잡는지 알고 있고, 당신이 사용하는 브라우저와 관계없이 이벤트 핸들러에 전달되는 이벤트는 [W3C 사양](http://www.w3.org/TR/DOM-Level-3-Events/)과 같도록 보장됩니다.
-
-## 기본 구현: 오토바인딩과 이벤트 델리게이션
-
-
-코드를 고성능으로 유지하고 이해하기 쉽게 하기 위해, React는 보이지 않는 곳에서 몇 가지 일을 수행합니다.
-
-**오토바인딩:** JavaScript에서 콜백을 만들 때, 보통은 `this`의 값이 정확하도록 명시적으로 메소드를 인스턴스에 바인드해야 합니다. React에서는 모든 메소드가 자동으로 React의 컴포넌트 인스턴스에 바인드됩니다.(ES6 클래스 문법을 사용할 때는 재외하고) React가 바인드 메소드를 캐시하기 때문에 매우 CPU와 메모리에 효율적입니다. 타이핑해야 할 것도 줄어들죠!
-
-**이벤트 델리게이션:** React는 실제로는 노드자신에게 이벤트 핸들러를 붙이지 않습니다. React가 시작되면 React는 탑 레벨의 단일 이벤트 리스너로 모든 이벤트를 리스닝하기 시작합니다. 컴포넌트가 마운트되거나 언마운트 될 때, 이벤트 핸들러는 그냥 내부 매핑에서 넣거나 뺄 뿐입니다. 이벤트가 발생하면, React는 이 매핑을 사용해서 어떻게 디스패치할 지를 알게 됩니다. 매핑에 이벤트 핸들러가 남아있지 않으면, React의 이벤트 핸들러는 그냥 아무것도 하지 않습니다. 왜 이 방식이 빠른지 더 알고 싶으시면, [David Walsh의 멋진 블로그 글](http://davidwalsh.name/event-delegate)을 읽어 보세요.
-
-## 컴포넌트는 그냥 state 머신일 뿐
-
-React는 UI를 간단한 state 머신이라 생각합니다. UI를 다양한 state와 그 state의 렌더링으로 생각함으로써 UI를 일관성 있게 관리하기 쉬워집니다.
-
-React에서는, 간단히 컴포넌트의 state를 업데이트하고, 이 새로운 state의 UI를 렌더링합니다. React는 DOM의 변경을 가장 효율적인 방법으로 관리해줍니다.
-
-## state의 동작 원리
-
-React에게 데이터의 변경을 알리는 일반적인 방법은 `setState(data, callback)`을 호출하는 것입니다. 이 메소드는 `this.state`에 `data`를 머지하고 컴포넌트를 다시 렌더링 합니다. 컴포넌트의 재-렌더링이 끝나면, 생략가능한 `callback`이 호출됩니다. 대부분의 경우 React가 UI를 최신상태로 유지해주기 때문에 `callback`을 사용할 필요가 없습니다.
-
-## 어떤 컴포넌트가 state를 가져야 할까요?
-
-대부분의 컴포넌트는 `props`로부터 데이터를 받아 렌더할 뿐입니다만, 가끔 유저 인풋, 서버 요청, 시간의 경과에 반응해야 할 필요가 있습니다. 이럴 때 state를 사용합니다.
-
-**가능한 한 컴포넌트가 상태를 가지지 않도록(stateless) 하세요.** 이렇게 함으로써 가장 논리적인 장소로 state를 격리하게 되고 쉽게 애플리케이션을 추론할 수 있도록 중복을 최소화할 수 있습니다.
-
-일반적인 패턴은 데이터만 렌더하는 여러 상태를 가지지 않은 컴포넌트를 만들고, 그 위에 상태기반(stateful) 컴포넌트를 만들어 계층 안의 자식 컴포넌트에게 `props`를 통해 state를 전달하는 것입니다. state를 가지지 않은 컴포넌트가 선언적인 방법으로 데이터를 렌더링 하는 동안, 상태기반 컴포넌트는 모든 상호작용 로직을 캡슐화합니다.
-
-## state를 어떻게 *써야* 할까요?
-
-**state는 컴포넌트의 이벤트 핸들러에 의해 UI 업데이트를 트리거할때 변경될 가능성이 있어, 그때 사용할 데이터를 가져야 합니다.** 실제 앱에서는 이 데이터는 매우 작고 JSON 직렬화 가능한 경향이 있습니다. 상태기반 컴포넌트를 만들때, 가능한 작게 state를 서술하고 `this.state`에만 저장하도록 해보세요. 그냥 `render()` 안에서 이 state를 기반으로 다른 모든 정보를 계산합니다. 이 방식으로 애플리케이션을 작성하고 생각하면 가장 최적의 애플리케이션으로 발전해가는 경향이 있다는 것을 발견하게 될 것입니다. 꼭 필요하지 않은 값이나 계산된 값을 state에 추가하는 것은 render가 그것을 계산하는 대신에 명시적으로 그것들을 맞춰줘야 하는 것을 의미하기 때문이죠.
-
-## state를 어떻게 *쓰지 말아야* 할까요?
-
-`this.state`는 UI의 state를 표현할 최소한의 데이터만을 가져야 합니다. 그래서 이런 것들을 가지지 않게끔 해야 합니다.
-
-* **계산된 데이터:** state에 따라 값을 미리 계산하는 것에 대해 염려하지 마세요. 계산은 모두 `render()`에서 하는 것이 UI의 일관성을 유지하기 쉽습니다. 예를 들어, state에서 list items 배열을 가지고 있고 문자열으로 카운트를 렌더링 할 경우, state에 저장하기보다는 그냥 `render()` 메소드안에서 `this.state.listItems.length + ' list items'`를 렌더하세요.
-* **React 컴포넌트:** 가지고 있는 props와 state로 `render()`안에서 만드세요.
-* **props에서 복사한 데이터:** 가능한 한 원래의 소스로 props를 사용하도록 해보세요. props를 state에 저장하는 단 하나의 올바른 사용법은 이전 값을 알고 싶을 때입니다. props는 부모 컴포넌트의 재 렌더링의 결과 변경될 수도 있기 때문이죠.
diff --git a/docs/docs/03-interactivity-and-dynamic-uis.md b/docs/docs/03-interactivity-and-dynamic-uis.md
deleted file mode 100644
index 57b5ff8efa..0000000000
--- a/docs/docs/03-interactivity-and-dynamic-uis.md
+++ /dev/null
@@ -1,81 +0,0 @@
----
-id: interactivity-and-dynamic-uis
-title: Interactivity and Dynamic UIs
-permalink: docs/interactivity-and-dynamic-uis.html
-prev: jsx-gotchas.html
-next: multiple-components.html
----
-
-You've already [learned how to display data](/react/docs/displaying-data.html) with React. Now let's look at how to make our UIs interactive.
-
-## A Simple Example
-
-```javascript
-class LikeButton extends React.Component {
- constructor() {
- super();
- this.state = {
- liked: false
- };
- this.handleClick = this.handleClick.bind(this);
- }
- handleClick() {
- this.setState({liked: !this.state.liked});
- }
- render() {
- const text = this.state.liked ? 'liked' : 'haven\'t liked';
- return (
-
- You {text} this. Click to toggle.
-
- );
- }
-}
-
-ReactDOM.render(
- ,
- document.getElementById('example')
-);
-```
-
-## Event Handling and Synthetic Events
-
-With React you simply pass your event handler as a camelCased prop similar to how you'd do it in normal HTML. React ensures that all events behave similarly in all browsers by implementing a synthetic event system. That is, React knows how to bubble and capture events according to the spec, and the events passed to your event handler are guaranteed to be consistent with [the W3C spec](http://www.w3.org/TR/DOM-Level-3-Events/), regardless of which browser you're using.
-
-## Under the Hood: Autobinding and Event Delegation
-
-Under the hood, React does a few things to keep your code performant and easy to understand.
-
-**Autobinding:** When creating callbacks in JavaScript, you usually need to explicitly bind a method to its instance such that the value of `this` is correct. With React, every method is automatically bound to its component instance ([except when using ES6 class syntax](/react/docs/reusable-components.html#no-autobinding)). React caches the bound method such that it's extremely CPU and memory efficient. It's also less typing!
-
-**Event delegation:** React doesn't actually attach event handlers to the nodes themselves. When React starts up, it starts listening for all events at the top level using a single event listener. When a component is mounted or unmounted, the event handlers are simply added or removed from an internal mapping. When an event occurs, React knows how to dispatch it using this mapping. When there are no event handlers left in the mapping, React's event handlers are simple no-ops. To learn more about why this is fast, see [David Walsh's excellent blog post](http://davidwalsh.name/event-delegate).
-
-## Components are Just State Machines
-
-React thinks of UIs as simple state machines. By thinking of a UI as being in various states and rendering those states, it's easy to keep your UI consistent.
-
-In React, you simply update a component's state, and then render a new UI based on this new state. React takes care of updating the DOM for you in the most efficient way.
-
-## How State Works
-
-A common way to inform React of a data change is by calling `setState(data, callback)`. This method merges `data` into `this.state` and re-renders the component. When the component finishes re-rendering, the optional `callback` is called. Most of the time you'll never need to provide a `callback` since React will take care of keeping your UI up-to-date for you.
-
-## What Components Should Have State?
-
-Most of your components should simply take some data from `props` and render it. However, sometimes you need to respond to user input, a server request or the passage of time. For this you use state.
-
-**Try to keep as many of your components as possible stateless.** By doing this you'll isolate the state to its most logical place and minimize redundancy, making it easier to reason about your application.
-
-A common pattern is to create several stateless components that just render data, and have a stateful component above them in the hierarchy that passes its state to its children via `props`. The stateful component encapsulates all of the interaction logic, while the stateless components take care of rendering data in a declarative way.
-
-## What *Should* Go in State?
-
-**State should contain data that a component's event handlers may change to trigger a UI update.** In real apps this data tends to be very small and JSON-serializable. When building a stateful component, think about the minimal possible representation of its state, and only store those properties in `this.state`. Inside of `render()` simply compute any other information you need based on this state. You'll find that thinking about and writing applications in this way tends to lead to the most correct application, since adding redundant or computed values to state means that you need to explicitly keep them in sync rather than rely on React computing them for you.
-
-## What *Shouldn't* Go in State?
-
-`this.state` should only contain the minimal amount of data needed to represent your UI's state. As such, it should not contain:
-
-* **Computed data:** Don't worry about precomputing values based on state — it's easier to ensure that your UI is consistent if you do all computation within `render()`. For example, if you have an array of list items in state and you want to render the count as a string, simply render `this.state.listItems.length + ' list items'` in your `render()` method rather than storing it on state.
-* **React components:** Build them in `render()` based on underlying props and state.
-* **Duplicated data from props:** Try to use props as the source of truth where possible. One valid use to store props in state is to be able to know its previous values, because props may change as the result of a parent component re-rendering.
diff --git a/docs/docs/03-interactivity-and-dynamic-uis.ru-RU.md b/docs/docs/03-interactivity-and-dynamic-uis.ru-RU.md
deleted file mode 100644
index def42b0b0b..0000000000
--- a/docs/docs/03-interactivity-and-dynamic-uis.ru-RU.md
+++ /dev/null
@@ -1,78 +0,0 @@
----
-id: interactivity-and-dynamic-uis-ru-RU
-title: Интерактивные и динамические интерфейсы
-permalink: docs/interactivity-and-dynamic-uis-ru-RU.html
-prev: jsx-gotchas.html
-next: multiple-components.html
----
-
-Вы уже знаете [как показывать данные](/react/docs/displaying-data.html) с React. Теперь давайте добавим в наши интферфейсы немного интерактивности.
-
-## Простой пример
-
-```javascript
-var LikeButton = React.createClass({
- getInitialState: function() {
- return {liked: false};
- },
- handleClick: function(event) {
- this.setState({liked: !this.state.liked});
- },
- render: function() {
- var text = this.state.liked ? 'liked' : 'haven\'t liked';
- return (
-
- You {text} this. Click to toggle.
-
- );
- }
-});
-
-ReactDOM.render(
- ,
- document.getElementById('example')
-);
-```
-
-## Обработка событий и синтетические события
-
-С React вы просто передаете функцию-обработчик нужного события как аргумент, почти так же, как делали это в HTML. Благодаря механизму синтетических событий React гарантирует, что все события будут вести себя одинаково во всех браузерах. Другими словами, React знает, как работает всплытие и перехват событий по спецификации. События, которые он передает в ваши обработчики, будут соответствовать [спецификации W3C](http://www.w3.org/TR/DOM-Level-3-Events/), несмотря на то, каким браузером вы пользуетесь.
-
-## Как это работает: автоматическое связывание и делегирование событий
-
-Чтобы ваш код был не только понятным, но и быстрым, React делает следующее:
-
-**Автоматическое связывание:** Когда в JavaScript создаются функции обратного вызова, вам надо привязать метод к тому объекту, на котором он будет вызываться, чтобы значение `this` было корректным. С React привязка метода к компоненту происходит автоматически ([кроме тех случаев, когда вы используете классы ES6](/react/docs/reusable-components.html#no-autobinding)). И делается это с минимальной нагрузкой на процессор и память.
-
-**Делегирование событий:** На самом же деле, React добавляет обработчики событий не к узлам дерева. Сразу после запуска, React начинает прослушивать все события с самого верхнего уровня, используя единый слушатель. Когда добавляется новый компонент или удаляется старый, обработчики событий просто добавляются или удаляются из памяти React. И когда событие наступает, React уже заранее знает какому из обработчиков его передать. Когда в памяти больше не остается обработчиков, React перестает обрабатывать события. Если хотите узнать о том, почему эта механика так быстро работает, почитайте [отличный пост в блоге David Walsh](http://davidwalsh.name/event-delegate).
-
-## Компоненты как конечные автоматы
-
-React считает интерфейсы обыкновенными конечными автоматами. Работать с интерфейсом становится проще, если представлять его как конечный автомат, который меняет состояния и отрисовывает их.
-
-В React вы просто обновляете состояние компонента, а потом выводите новый интерфейс уже с новыми данными. Все изменения в DOM-дереве React сделает сам, причем наиболее эффективным способом.
-
-## Как работает состояние
-
-Чтобы сообщить React о том, что данные изменились, вы вызываете метод `setState(data, callback)`. В этом методе происходит обновление состояния `this.state` новыми данными из `data`, и компонент отрисуется заново. После этого вызывается функция `callback`. Но вы редко будете ей пользоваться, ведь React сам обновляет интерфейс.
-
-## В каких компонентах хранить состояние?
-
-Большинство компонентов должны просто брать данные из `props` и отрисовывать их. Но иногда вам надо реагировать на действия пользователя, делать запросы на сервер или просто сделать что-то по таймеру. В таких случаях используйте состояние.
-
-**Старайтесь делать компоненты без состояния.** Следуя этому правилу, вы будете выносить работу с состоянием с уровня представления в другие, более подходящие места. Тем самым, вы снизите сложность приложения, упрощая его понимание.
-
-Основной принцип такой: создаются несколько компонентов без состояния, которые формируют дерево. Они будут заниматься только отрисовкой данных. А все данные для них будут у родительского компонента, который будет на вершине этого дерева компонентов. Он и будет передавать данные дочерним узлам через `props`. Этот компонент с общим состоянием содержит в себе всю логику взаимодействия, а дочерние компоненты будут только отрисовывать данные, которые будут у них в `props`.
-
-## Какие данные *надо* помещать в состояние?
-
-**Состояние должно содержать данные, которые нужны для обновления интерфейса.** В реальных приложениях такие данные, как правило, незначительны по объему, и могут быть сериализованы в JSON. Когда вы создаете компонент с состоянием, старайтесь поместить в него минимум данных. А уже внутри метода `render()` вычисляйте остальные данные, используя значения из состояния.
-Со временем вы увидите, что такой подход позволяет создавать более стройные и устойчивые к изменениям приложения. Добавление в состояние лишних данных требует от вас дополнительных затрат на их синхронизацию. Но этого можно избежать, если позволить React делать все эти вычисления за вас.
-
-## Какие данные *не надо* помещать в состояние?
-
-Состояние `this.state` должно содержать минимум данных, необходимых для отображения интерфейса. Поэтому не стоит хранить в нем:
-
-* **Вычисляемые данные:** Не волнуйтесь о данных, которые можно вычислить из состояния. Согласованность данных проще обеспечить, если производить все вычисления в методе `render()`. Например, если в состоянии хранится список элементов, и вам надо вывести его размер в виде строки, напишите `this.state.listItems.length + ' элементов'` в методе `render()`. Это будет правильнее, чем хранить размер списка в состоянии.
-* **Компоненты React:** Создавайте их в методе `render()`, опираясь на данные из `props` и `state`.
-* **Значения, повторяющие `props`:** Старайтесь по мере возможности использовать `props` как единственный источник данных. Хранить значения `props` в состоянии допускается, только если вам надо где-то хранить их прошлые значения, ведь `props` могут измениться после отрисовки родительского компонента.
diff --git a/docs/docs/03-interactivity-and-dynamic-uis.zh-CN.md b/docs/docs/03-interactivity-and-dynamic-uis.zh-CN.md
deleted file mode 100644
index e6ece97de4..0000000000
--- a/docs/docs/03-interactivity-and-dynamic-uis.zh-CN.md
+++ /dev/null
@@ -1,77 +0,0 @@
----
-id: interactivity-and-dynamic-uis-zh-CN
-title: 动态交互式用户界面
-permalink: docs/interactivity-and-dynamic-uis-zh-CN.html
-prev: jsx-gotchas-zh-CN.html
-next: multiple-components-zh-CN.html
----
-
-我们已经学习如何使用 React [显示数据](/react/docs/displaying-data-zh-CN.html)。现在让我们来学习如何创建交互式界面。
-
-## 简单例子
-
-```javascript
-var LikeButton = React.createClass({
- getInitialState: function() {
- return {liked: false};
- },
- handleClick: function(event) {
- this.setState({liked: !this.state.liked});
- },
- render: function() {
- var text = this.state.liked ? 'liked' : 'haven\'t liked';
- return (
-
- You {text} this. Click to toggle.
-
- );
- }
-});
-
-ReactDOM.render(
- ,
- document.getElementById('example')
-);
-```
-
-## 事件处理与合成事件(Synthetic Events)
-
-React 里只需把事件处理器(event handler)以骆峰命名(camelCased)形式当作组件的 props 传入即可,就像使用普通 HTML 那样。React 内部创建一套合成事件系统来使所有事件在 IE8 和以上浏览器表现一致。也就是说,React 知道如何冒泡和捕获事件,而且你的事件处理器接收到的 events 参数与 [W3C 规范](http://www.w3.org/TR/DOM-Level-3-Events/) 一致,无论你使用哪种浏览器。
-
-## 幕后原理:自动绑定(Autobinding)和事件代理(Event Delegation)
-
-在幕后,React 做了一些操作来让代码高效运行且易于理解。
-
-**自动绑定:** 在 JavaScript 里创建回调的时候,为了保证 `this` 的正确性,一般都需要显式地绑定方法到它的实例上。在 React 中,所有方法被自动绑定到了它的组件实例上([除非使用ES6的class符号](/react/docs/reusable-components.html#no-autobinding))。React 还缓存这些绑定方法,所以 CPU 和内存都是非常高效。而且还能减少打字!
-
-**事件代理:** React 实际并没有把事件处理器绑定到节点本身。当 React 启动的时候,它在最外层使用唯一一个事件监听器处理所有事件。当组件被加载和卸载时,只是在内部映射里添加或删除事件处理器。当事件触发,React 根据映射来决定如何分发。当映射里没有事件处理函数时,会当作空操作处理。参考 [David Walsh 很棒的文章](http://davidwalsh.name/event-delegate) 了解这样做高效的原因。
-
-## 组件其实是状态机(State Machines)
-
-React 把用户界面当作简单状态机。把用户界面想像成拥有不同状态然后渲染这些状态,可以轻松让用户界面和数据保持一致。
-
-React 里,只需更新组件的 state,然后根据新的 state 重新渲染用户界面(不要操作 DOM)。React 来决定如何最高效地更新 DOM。
-
-## State 工作原理
-
-常用的通知 React 数据变化的方法是调用 `setState(data, callback)`。这个方法会合并(merge) `data` 到 `this.state`,并重新渲染组件。重新渲染完成后,调用可选的 `callback` 回调。大部分情况下不需要提供 `callback`,因为 React 会负责把界面更新到最新状态。
-
-## 哪些组件应该有 State?
-
-大部分组件的工作应该是从 `props` 里取数据并渲染出来。但是,有时需要对用户输入、服务器请求或者时间变化等作出响应,这时才需要使用 State。
-
-**尝试把尽可能多的组件无状态化。** 这样做能隔离 state,把它放到最合理的地方,也能减少冗余,同时易于解释程序运作过程。
-
-常用的模式是创建多个只负责渲染数据的无状态(stateless)组件,在它们的上层创建一个有状态(stateful)组件并把它的状态通过 `props` 传给子级。这个有状态的组件封装了所有用户的交互逻辑,而这些无状态组件则负责声明式地渲染数据。
-
-## 哪些 *应该* 作为 State?
-
-**State 应该包括那些可能被组件的事件处理器改变并触发用户界面更新的数据。** 真实的应用中这种数据一般都很小且能被 JSON 序列化。当创建一个状态化的组件时,思考一下表示它的状态最少需要哪些数据,并只把这些数据存入 `this.state`。在 `render()` 里再根据 state 来计算你需要的其它数据。你会发现以这种方式思考和开发程序最终往往是正确的,因为如果在 state 里添加冗余数据或计算所得数据,那么你就需要经常手动保持数据同步,而不能让 React 来帮你处理。
-
-## 哪些 *不应该* 作为 State?
-
-`this.state` 应该仅包括能表示用户界面状态所需的最少数据。因此,它不应该包括:
-
-* **计算所得数据:** 不要担心根据 state 来预先计算数据 —— 把所有的计算都放到 `render()` 里更容易保证用户界面和数据的一致性。例如,在 state 里有一个数组(listItems),我们要把数组长度渲染成字符串, 直接在 `render()` 里使用 `this.state.listItems.length + ' list items'` 比把它放到 state 里好的多。
-* **React 组件:** 在 `render()` 里使用当前 props 和 state 来创建它。
-* **基于 props 的重复数据:** 尽可能使用 props 来作为实际状态的源。把 props 保存到 state 的一个有效的场景是需要知道它以前值的时候,因为 props 可能因为父组件的重绘而变化。
diff --git a/docs/docs/04-multiple-components.it-IT.md b/docs/docs/04-multiple-components.it-IT.md
deleted file mode 100644
index 91a1b9f432..0000000000
--- a/docs/docs/04-multiple-components.it-IT.md
+++ /dev/null
@@ -1,190 +0,0 @@
----
-id: multiple-components-it-IT
-title: Componenti Multipli
-permalink: docs/multiple-components-it-IT.html
-prev: interactivity-and-dynamic-uis-it-IT.html
-next: reusable-components-it-IT.html
----
-
-Finora abbiamo visto come scrivere un singolo componente per mostrare dati e gestire l'input dell'itente. Adesso esaminiamo una delle migliori caratteristiche di React: la componibilità.
-
-
-## Motivazione: Separazione dei Concetti
-
-Costruendo componenti modulari che riutilizzano altri componenti con interfacce ben definite, ottieni gli stessi benefici che otterresti usando funzioni o classi. Nello specifico, puoi *separare i diversi concetti* della tua applicazione nel modo che preferisci semplicemente costruendo nuovi componenti. Costruendo una libreria di componenti personalizzati per la tua applicazione, stai esprimendo la tua UI in una maniera che si adatta meglio al tuo dominio.
-
-
-## Esepmio di Composizione
-
-Creiamo un semplice componente Avatar che mostra una foto del profilo e un nome utente usando la Graph API di Facebook.
-
-```javascript
-var Avatar = React.createClass({
- render: function() {
- return (
-
-
-
-
- );
- }
-});
-
-var ProfilePic = React.createClass({
- render: function() {
- return (
-
- );
- }
-});
-
-var ProfileLink = React.createClass({
- render: function() {
- return (
-
- {this.props.username}
-
- );
- }
-});
-
-ReactDOM.render(
- ,
- document.getElementById('example')
-);
-```
-
-
-## Possesso
-
-Nell'esempio precedente, le istanze di `Avatar` *posseggono* instanze di `ProfilePic` e `ProfileLink`. In React, **un proprietario è il componente che imposta le `props` di altri componenti**. Più formalmente, se un componente `X` è creato nel metodo `render()` del componente `Y`, si dice che `X` è *di proprietà di* `Y`. Come discusso in precedenza, un componente non può mutare le sue `props` — sono sempre consistenti con il valore che il suo proprietario ha impostato. Questa invariante fondamentale porta a UI la cui consistenza può essere garantita.
-
-È importante distinguere tra la relazione di proprietario-proprietà e la relazione genitore-figlio. La relazione proprietario-proprietà è specifica di React, mentre la relazione genitore-figlio è semplicemente quella che conosci e ami del DOM. Nell'esempio precedente, `Avatar` possiede il `div`, le istanze di `ProfilePic` e `ProfileLink`, e `div` è il **genitore** (ma non il proprietario) delle istanze di `ProfilePic` e `ProfileLink`.
-
-
-## Figli
-
-Quando crei un'istanza di un componente React, puoi includere componenti React aggiuntivi o espressioni JavaScript tra i tag di apertura e chiusura come segue:
-
-```javascript
-
-```
-
-`Parent` può accedere ai propri figli leggendo la speciale proprietà `this.props.children`. **`this.props.children` è una struttura dati opaca:** usa le [utilità React.Children](/react/docs/top-level-api.html#react.children) per manipolare i figli.
-
-
-### Riconciliazione dei Figli
-
-**La riconciliazione è il processo per il quale React aggiorna il DOM ad ogni passata di rendering.** In generale, i figli sono riconciliati secondo l'ordine in cui sono mostrati. Per esempio, supponiamo che due passate di rendering generino rispettivamente il markup seguente:
-
-```html
-// Prima passata di rendering
-
-
Paragrafo 1
-
Paragrafo 2
-
-// Seconda passata di rendering
-
-
Paragrafo 2
-
-```
-
-Intuitivamente, `
Paragrafo 1
` è stato rimosso. Invece, React riconcilierà il DOM cambiando il testo contenuto nel primo figlio e distruggerà l'ultimo figlio. React reconcilia secondo l'*ordine* dei figli.
-
-
-### Figli Dotati di Stato
-
-Per molti componenti, questo non è un grande problema. Tuttavia, per i componenti dotati di stato che mantengono dati in `this.state` attraverso le diverse passate di rendering, questo può essere problematico.
-
-In molti casi, questo problema può essere aggirato nascondendo gli elementi anziché distruggendoli:
-
-```html
-// Prima passata di rendering
-
-
Paragrafo 1
-
Paragrafo 2
-
-// Seconda passata di rendering
-
-
Paragrafo 1
-
Paragrafo 2
-
-```
-
-
-### Figli Dinamici
-
-La situazione si complica quando i figli sono rimescolati (come nei risultati della ricerca) o se nuovi componenti sono aggiunti all'inizio della lista (come negli stream). In questi casi quando l'identità e lo stato di ogni figlio deve essere preservato attraverso passate di rendering, puoi unicamente identificare ciascun figlio assegnandogli una proprietà `key`:
-
-```javascript
- render: function() {
- var results = this.props.results;
- return (
-
- {results.map(function(result) {
- return
{result.text}
;
- })}
-
- );
- }
-```
-
-Quando React riconcilia i figli dotati di `key`, si assicurerà che ciascun figlio con la proprietà `key` sia riordinato (anziché clobbered) o distrutto (anziché riutilizzato).
-
-La proprietà `key` dovrebbe *sempre* essere fornita direttamente all'elemento del componente nell'array, non al contenitore HTML di ciascun componente dell'array:
-
-```javascript
-// SBAGLIATO!
-var ListItemWrapper = React.createClass({
- render: function() {
- return
- );
- }
-});
-```
-
-Puoi anche assegnare chiavi ai figli passandogli un oggetto ReactFragment. Leggi [Frammenti con Chiave](create-fragment.html) per maggiori dettagli.
-
-## Flusso dei Dati
-
-In React, i dati fluiscono dal proprietario al componente posseduto attraverso le `props` come discusso in precedenza. Questo è a tutti gli effetti un binding di dati unidirezionale: i proprietari legano le proprietà dei componenti di loro proprietà a dei valori che il proprietario stesso ha calcolato in base ai propri `props` o `state`. Dal momento che questo processo avviene ricorsivamente, i cambiamenti dei dati vengono riflessi automaticamente ovunque vengano usati.
-
-
-## Una Nota sulle Prestazioni
-
-Ti starai chiedendo che cambiare i dati sia un'operazione costosa in presenza di un gran numero di nodi sotto un proprietario. La buona notizia è che JavaScript è veloce e i metodi `render()` tendono ad essere molto semplici, quindi in molte applicazioni questo è un processo estremamente veloce. Inoltre, il collo di bottiglia è quasi sempre la mutazione del DOM e non l'esecuzione di JS. React ottimizzerà tutto per te usando il raggruppamento e osservando i cambiamenti.
-
-Tuttavia, a volte vorrai avere un controllo più raffinato sulle tue prestazioni. In tal caso, ridefinisci il metodo `shouldComponentUpdate()` per restituire false quando vuoi che React salti il trattamento di un sottoalbero. Consulta [la documentazione di riferimento di React](/react/docs/component-specs.html) per maggiori informazioni.
-
-> Nota:
->
-> Se `shouldComponentUpdate()` restituisce false quando i dati sono effettivamente cambiati, React non è in grado di mantenere la tua UI in sincronia. Assicurati di usare questa tecnica con cognizione di causa, e soltanto in presenza di problemi percettibili di prestazioni. Non sottovalutare l'estrema velocità di esecuzione di JavaScript se paragonata a quella del DOM.
diff --git a/docs/docs/04-multiple-components.ja-JP.md b/docs/docs/04-multiple-components.ja-JP.md
deleted file mode 100644
index 39b5dfe848..0000000000
--- a/docs/docs/04-multiple-components.ja-JP.md
+++ /dev/null
@@ -1,186 +0,0 @@
----
-id: multiple-components
-title: 複数のコンポーネント
-permalink: docs/multiple-components-ja-JP.html
-prev: interactivity-and-dynamic-uis-ja-JP.html
-next: reusable-components-ja-JP.html
----
-
-今まで、データを表示したりユーザの入力をハンドルするための1つのコンポーネントの書き方を見てきました。次に、 Reactの最も面白い特徴であるコンポーザビリティについて見ていきましょう。
-
-## 動機: 関心の分離
-
-うまく定義されたインターフェースとともに他のコンポーネントを再利用するモジュールのコンポーネントを構築することによって、関数やクラスを使う場合と同じ利益を得ることができます。特に、アプリの *異なった関心を分離* できるにも関わらず、新しいコンポーネントを単純に構築することで満足する場合には。アプリケーションにカスタムコンポーネントライブラリを構築することによって、あなたがやりたいことに最も合う方法でUIを表現することができます。
-
-## 構成例
-
-FacebookのグラフAPIを使って、プロフィール画像とユーザー名を表示する単純なアバターのコンポーネントを作ってみましょう。
-
-```javascript
-var Avatar = React.createClass({
- render: function() {
- return (
-
- );
- }
-});
-```
-
-Reactのフラグのオブジェクトを渡すことで子要素をキー付けすることもできます。詳細は、[キー付けされたフラグ](create-fragment.html)をご覧ください。
-
-## データフロー
-
-Reactの、 `props` を通した所有者から所有されるコンポーネントへのデータフローは今までに記述してきました。これは実際には一方向のデータバインディングです。所有者は所有しているコンポーネントのpropsを、所有者が `props` か `state` に基づいて計算したいくつかの値にバインドします。このプロセスが何度も行われるので、データの変更は彼らが使われるところは自動的にどこでも反映されます。
-
-## パフォーマンスの注意
-
-みなさんは所有者の下にたくさんのノードがあるときには、データの変更には多くのコストがかかると考えるでしょう。良いニュースとして、JavaScriptは早く、 `render()` メソッドはとても単純になりやすいので、多くのアプリケーションにおいて、こういったことは非常に早くなります。加えて、ボトルネックとなるものの多くは、JSの実行ではなく、DOMの変更です。Reactは変更の一括処理と検知を使うことによって、それを最適化しています。
-
-しかし、パフォーマンスについて、よりよい制御を持つことを求める時もあるでしょう。こういったケースで、Reactがサブツリーの処理をスキップすることを求めるなら、 `shouldComponentUpdate()` が単純にfalseを返すようにオーバーライドしてください。更に情報を得たい場合には、[Reactのリファレンス文書](/react/docs/component-specs.html)を読んでください。
-
-> 注意:
-> `shouldComponentUpdate()` がデータが実際に変わった時にfalseを返したならば、ReactはUIを同期的に保つことができません。このメソッドを使う際には、何を行っているか理解してください。そして、顕著なパフォーマンスの問題がある時にだけ、この関数を使ってください。DOMと比較して、JavaScriptが速いことを過小評価しないでください。
diff --git a/docs/docs/04-multiple-components.ko-KR.md b/docs/docs/04-multiple-components.ko-KR.md
deleted file mode 100644
index d566a93e6f..0000000000
--- a/docs/docs/04-multiple-components.ko-KR.md
+++ /dev/null
@@ -1,182 +0,0 @@
----
-id: multiple-components-ko-KR
-title: 복합 컴포넌트
-permalink: docs/multiple-components-ko-KR.html
-prev: interactivity-and-dynamic-uis-ko-KR.html
-next: reusable-components-ko-KR.html
----
-
-지금까지, 단일 컴포넌트에서 데이터를 표시하고 유저 입력을 다루는 것을 살펴보았습니다. 다음엔 React의 최고의 기능 중 하나인 조합가능성(composability)을 살펴봅시다.
-
-## 동기: 관심의 분리
-
-명확히 정의된 인터페이스와 다른 컴포넌트를 재사용해 모듈러 컴포넌트를 구축하면, 함수와 클래스를 이용했을 때 얻을 수 있는 이점 대부분을 얻을 수 있습니다. 특히 앱에서 *다른 관심을 분리*할 수 있습니다.아무리 간단히 새 컴포넌트를 만들었다고 해도 말이죠. 당신의 애플리케이션에서 쓸 커스텀 컴포넌트 라이브러리를 만들어서, 당신의 도메인에 최적화된 방법으로 UI를 표현할 수 있게 됩니다.
-
-## 조합(Composition) 예제
-
-간단히 페이스북 그래프 API를 사용해 프로필 사진과 유저이름을 보여주는 아바타 컴포넌트를 만든다고 합시다.
-
-```javascript
-var Avatar = React.createClass({
- render: function() {
- return (
-
-
-
-
- );
- }
-});
-
-var ProfilePic = React.createClass({
- render: function() {
- return (
-
- );
- }
-});
-
-var ProfileLink = React.createClass({
- render: function() {
- return (
-
- {this.props.username}
-
- );
- }
-});
-
-ReactDOM.render(
- ,
- document.getElementById('example')
-);
-```
-
-## 소유권(Ownership)
-
-위의 예제에서, `Avatar` 인스턴스는 `ProfilePic`과 `ProfileLink`인스턴스를 *가지고* 있습니다. React에서 **소유자는 다른 컴포넌트의 `props`를 설정하는 컴포넌트입니다**. 더 정식으로 말하면, `X` 컴포넌트가 `Y` 컴포넌트의 `render()` 메소드 안에서 만들어졌다면, `Y`가 `X`를 *소유하고* 있다고 합니다. 앞에서 설명한 바와 같이, 컴포넌트는 자신의 `props`를 변경할 수 없습니다. `props`는 언제나 소유자가 설정한 것과 일치합니다. 이와 같은 근본적인 불변성은 UI가 일관성 있도록 해줍니다.
-
-소유(owner-ownee)관계와 부모·자식 관계를 구별하는 것은 중요합니다. 부모·자식 관계가 DOM에서부터 쓰던 익숙하고 이미 알고있던 단순한 것인 한편, 소유관계는 React 고유의 것입니다. 위의 예제에서, `Avatar`는 `div`, `ProfilePic`, `ProfileLink`인스턴스를 소유하고, `div`는 `ProfilePic`과 `ProfileLink`인스턴스의 (소유자가 아닌) **부모**입니다.
-
-## 자식
-
-React 컴포넌트 인스턴스를 만들 때, 추가적인 React 컴포넌트나 JavaScript 표현식을 시작과 끝 태그 사이에 넣을 수 있습니다. 이렇게 말이죠.
-
-```javascript
-
-```
-
-`Parent`는 `this.props.children`라는 특수 prop으로 자식들을 읽을 수 있습니다. **`this.props.children` 는 불투명한 데이터 구조이며,** [React.Children 유틸리티](/react/docs/top-level-api-ko-KR.html#react.children)를 사용해 자식들을 관리합니다.
-
-### 자식 Reconciliation (비교조정)
-
-**Reconciliation은 React가 DOM을 각각 새로운 렌더 패스에 업데이트하는 과정입니다.** 일반적으로, 자식은 렌더하는 순서에 따라 비교조정됩니다. 예를 들어, 각각의 마크업을 생성하는 두 개의 렌더 패스가 있다고 해봅시다.
-
-```html
-// Render Pass 1
-
-
Paragraph 1
-
Paragraph 2
-
-// Render Pass 2
-
-
Paragraph 2
-
-```
-
-직관적으로 보면, `
Paragraph 1
`가 없어졌습니다만 그러는 대신에, React는 첫 번째 자식의 텍스트를 비교조정하고 마지막 자식을 파괴하도록 DOM을 비교조정할 것입니다. React는 자식들의 *순서*에 따라 비교조정합니다.
-
-### 상태기반(Stateful) 자식
-
-대부분의 컴포넌트에서는, 이것은 큰 문제가 아닙니다. 하지만 렌더 패스 간에 `this.state`를 유지하는 상태기반의 컴포넌트에서는 매우 문제가 될 수 있습니다.
-
-대부분의 경우, 이 문제는 엘리먼트를 파괴하지 않고 숨김으로써 피해갈 수 있습니다.
-
-```html
-// Render Pass 1
-
-
Paragraph 1
-
Paragraph 2
-
-// Render Pass 2
-
-
Paragraph 1
-
Paragraph 2
-
-```
-
-### 동적 자식
-
-자식들이 섞이거나(검색의 결과같은 경우) 새로운 컴포넌트가 목록의 앞에 추가(스트림같은 경우)된다면 상황은 점점 더 까다로워집니다. 이런 때에의 동일성과 각 자식의 상태는 반드시 렌더 패스 간에 유지돼야 합니다. 각 자식에 `key`를 할당 함으로써 독자적으로 식별할 수 있습니다.
-
-```javascript
- render: function() {
- var results = this.props.results;
- return (
-
- {results.map(function(result) {
- return
{result.text}
;
- })}
-
- );
- }
-```
-
-React가 키가 있는 자식들을 비교조정할 때, React는 `key`가 있는 자식이 (오염(clobbered)되는 대신) 재배치되고 (재사용되는 대신) 파괴되도록 보장할 것입니다.
-
-`key`는 *항상* 배열 안의 각 컴포넌트의 컨테이너 HTML 자식이 아닌 컴포넌트에게 직접 주어져야 합니다.
-
-```javascript
-// 틀림!
-var ListItemWrapper = React.createClass({
- render: function() {
- return
- );
- }
-});
-```
-
-ReactFragment 객체를 넘기는 것으로 자식에 키를 할당할 수도 있습니다. 자세한 내용은 [키가 할당된 프래그먼트](create-fragment-ko-KR.html)를 참고하세요.
-
-## 데이터 흐름
-
-React에서 데이터는 위에서 말한 것처럼 `props`를 통해 소유자로부터 소유한 컴포넌트로 흐릅니다. 이것은 사실상 단방향 데이터 바인딩입니다. 소유자는 `props`나 `state`를 기준으로 계산한 어떤 값으로 소유한 컴포넌트의 props를 바인드합니다. 이 과정은 재귀적으로 발생하므로, 데이터의 변경은 자동으로 모든 곳에 반영됩니다.
-
-## 성능의 주의점
-
-소유자가 가지고 있는 노드의 수가 많아지면 데이터가 변화하는 비용이 증가할 것으로 생각할 수도 있습니다. 좋은 소식은 JavaScript의 속도는 빠르고 `render()` 메소드는 꽤 간단한 경향이 있어, 대부분 애플리케이션에서 매우 빠르다는 점입니다. 덧붙여, 대부분의 병목 현상은 JS 실행이 아닌 DOM 변경에서 일어나고, React는 배치와 탐지 변경을 이용해 최적화해 줍니다.
-
-하지만, 가끔 성능을 위해 정교하게 제어해야 할 때도 있습니다. 이런 경우, React가 서브트리의 처리를 건너 뛰도록 간단히 `shouldComponentUpdate()`를 오버라이드해 false를 리턴하게 할 수 있습니다. 좀 더 자세한 정보는 [React 참조 문서](/react/docs/component-specs-ko-KR.html)를 보세요.
-
-> 주의:
->
-> 데이터가 실제로는 변경되었지만 `shouldComponentUpdate()`가 false를 리턴한다면 React는 UI를 싱크시킬수 없습니다. 이 기능을 사용할 때에는 자신이 지금 무엇을 하고 있는지 알고 있고, 눈에 띄는 성능 문제가 있을 경우에만 사용하세요. JavaScript는 DOM에 비해 빠릅니다. 과소평가하지 마세요.
diff --git a/docs/docs/04-multiple-components.md b/docs/docs/04-multiple-components.md
deleted file mode 100644
index c74476779a..0000000000
--- a/docs/docs/04-multiple-components.md
+++ /dev/null
@@ -1,181 +0,0 @@
----
-id: multiple-components
-title: Multiple Components
-permalink: docs/multiple-components.html
-prev: interactivity-and-dynamic-uis.html
-next: reusable-components.html
----
-
-So far, we've looked at how to write a single component to display data and handle user input. Next let's examine one of React's finest features: composability.
-
-## Motivation: Separation of Concerns
-
-By building modular components that reuse other components with well-defined interfaces, you get much of the same benefits that you get by using functions or classes. Specifically you can *separate the different concerns* of your app however you please simply by building new components. By building a custom component library for your application, you are expressing your UI in a way that best fits your domain.
-
-## Composition Example
-
-Let's create a simple Avatar component which shows a Facebook page picture and name using the Facebook Graph API.
-
-```javascript
-class Avatar extends React.Component {
- render() {
- return (
-
-
-
-
- );
- }
-}
-
-class PagePic extends React.Component {
- render() {
- return (
-
- );
- }
-}
-
-class PageLink extends React.Component {
- render() {
- return (
-
- {this.props.pagename}
-
- );
- }
-}
-
-ReactDOM.render(
- ,
- document.getElementById('example')
-);
-```
-
-## Ownership
-
-In the above example, instances of `Avatar` *own* instances of `PagePic` and `PageLink`. In React, **an owner is the component that sets the `props` of other components**. More formally, if a component `X` is created in component `Y`'s `render()` method, it is said that `X` is *owned by* `Y`. As discussed earlier, a component cannot mutate its `props` — they are always consistent with what its owner sets them to. This fundamental invariant leads to UIs that are guaranteed to be consistent.
-
-It's important to draw a distinction between the owner-ownee relationship and the parent-child relationship. The owner-ownee relationship is specific to React, while the parent-child relationship is simply the one you know and love from the DOM. In the example above, `Avatar` owns the `div`, `PagePic` and `PageLink` instances, and `div` is the **parent** (but not owner) of the `PagePic` and `PageLink` instances.
-
-## Children
-
-When you create a React component instance, you can include additional React components or JavaScript expressions between the opening and closing tags like this:
-
-```javascript
-
-```
-
-`Parent` can read its children by accessing the special `this.props.children` prop. **`this.props.children` is an opaque data structure:** use the [React.Children utilities](/react/docs/top-level-api.html#react.children) to manipulate them.
-
-### Child Reconciliation
-
-**Reconciliation is the process by which React updates the DOM with each new render pass.** In general, children are reconciled according to the order in which they are rendered. For example, suppose two render passes generate the following respective markup:
-
-```html
-// Render Pass 1
-
-
Paragraph 1
-
Paragraph 2
-
-// Render Pass 2
-
-
Paragraph 2
-
-```
-
-Intuitively, `
Paragraph 1
` was removed. Instead, React will reconcile the DOM by changing the text content of the first child and destroying the last child. React reconciles according to the *order* of the children.
-
-### Stateful Children
-
-For most components, this is not a big deal. However, for stateful components that maintain data in `this.state` across render passes, this can be very problematic.
-
-In most cases, this can be sidestepped by hiding elements instead of destroying them:
-
-```html
-// Render Pass 1
-
-
Paragraph 1
-
Paragraph 2
-
-// Render Pass 2
-
-
Paragraph 1
-
Paragraph 2
-
-```
-
-### Dynamic Children
-
-The situation gets more complicated when the children are shuffled around (as in search results) or if new components are added onto the front of the list (as in streams). In these cases where the identity and state of each child must be maintained across render passes, you can uniquely identify each child by assigning it a `key`:
-
-```javascript
- render() {
- return (
-
- {this.props.results.map((result) => (
-
{result.text}
- ))}
-
- );
- }
-```
-
-When React reconciles the keyed children, it will ensure that any child with `key` will be reordered (instead of clobbered) or destroyed (instead of reused).
-
-The `key` should *always* be supplied directly to the components in the array, not to the container HTML child of each component in the array:
-
-```javascript
-// WRONG!
-class ListItemWrapper extends React.Component {
- render() {
- return
- );
- }
-}
-```
-
-You can also key children by passing a ReactFragment object. See [Keyed Fragments](create-fragment.html) for more details.
-
-## Data Flow
-
-In React, data flows from owner to owned component through `props` as discussed above. This is effectively one-way data binding: owners bind their owned component's props to some value the owner has computed based on its `props` or `state`. Since this process happens recursively, data changes are automatically reflected everywhere they are used.
-
-## A Note on Performance
-
-You may be thinking that it's expensive to change data if there are a large number of nodes under an owner. The good news is that JavaScript is fast and `render()` methods tend to be quite simple, so in most applications this is extremely fast. Additionally, the bottleneck is almost always the DOM mutation and not JS execution. React will optimize this for you by using batching and change detection.
-
-However, sometimes you really want to have fine-grained control over your performance. In that case, simply override `shouldComponentUpdate()` to return false when you want React to skip processing of a subtree. See [the React reference docs](/react/docs/component-specs.html) for more information.
-
-> Note:
->
-> If `shouldComponentUpdate()` returns false when data has actually changed, React can't keep your UI in sync. Be sure you know what you're doing while using it, and only use this function when you have a noticeable performance problem. Don't underestimate how fast JavaScript is relative to the DOM.
diff --git a/docs/docs/04-multiple-components.zh-CN.md b/docs/docs/04-multiple-components.zh-CN.md
deleted file mode 100644
index 84e2e47959..0000000000
--- a/docs/docs/04-multiple-components.zh-CN.md
+++ /dev/null
@@ -1,183 +0,0 @@
----
-id: multiple-components-zh-CN
-title: 复合组件
-permalink: docs/multiple-components-zh-CN.html
-prev: interactivity-and-dynamic-uis-zh-CN.html
-next: reusable-components-zh-CN.html
----
-
-目前为止,我们已经学了如何用单个组件来展示数据和处理用户输入。下一步让我们来体验 React 最激动人心的特性之一:可组合性(composability)。
-
-## 动机:关注分离
-
-通过复用那些接口定义良好的组件来开发新的模块化组件,我们得到了与使用函数和类相似的好处。具体来说就是能够通过开发简单的组件把程序的*不同关注面分离*。如果为程序开发一套自定义的组件库,那么就能以最适合业务场景的方式来展示你的用户界面。
-
-## 组合实例
-
-让我们用 Facebook Graph API 来开发一个显示 Facebook 页面图片和用户名的简单 Avatar 组件吧。
-
-```javascript
-var Avatar = React.createClass({
- render: function() {
- return (
-
- );
- }
-});
-```
-
-也可以传递 ReactFragment 对象来做有 key 的子级。详见[Keyed Fragments](create-fragment.html)
-
-## 数据流
-
-React 里,数据通过上面介绍过的 `props` 从拥有者流向归属者。这就是高效的单向数据绑定(one-way data binding):拥有者们通过它们的 `props` 或 `state` 计算出一些值,并把这些值绑定到它们拥有的组件的 props 上。因为这个过程会递归地调用,所以数据变化会自动在所有它们被使用的地方反映出来。
-
-
-## 性能提醒
-
-你或许会担心如果一个拥有者有大量子级时,对于数据变化做出响应非常耗费性能。值得庆幸的是执行 JavaScript 非常的快,而且 `render()` 方法一般比较简单,所以在大部分应用里这样做速度极快。此外,性能的瓶颈大多是因为 DOM 更新,而非 JS 执行,而且 React 会通过批量更新和变化检测来优化性能。
-
-但是,有时候需要做细粒度的性能控制。这种情况下,可以重写 `shouldComponentUpdate()` 方法返回 false 来让 React 跳过对子树的处理。参考 [React reference docs](/react/docs/component-specs.html) 了解更多。
-
-> 注意:
->
-> 如果在数据变化时让 `shouldComponentUpdate()` 返回 false,React 就不能保证用户界面同步。当使用它的时候一定确保你清楚到底做了什么,并且只在遇到明显性能问题的时候才使用它。不要低估 JavaScript 的速度,DOM 操作通常才是慢的原因。
diff --git a/docs/docs/05-reusable-components.it-IT.md b/docs/docs/05-reusable-components.it-IT.md
deleted file mode 100644
index 976f43d655..0000000000
--- a/docs/docs/05-reusable-components.it-IT.md
+++ /dev/null
@@ -1,264 +0,0 @@
----
-id: reusable-components-it-IT
-title: Componenti Riutilizzabili
-permalink: docs/reusable-components-it-IT.html
-prev: multiple-components-it-IT.html
-next: transferring-props-it-IT.html
----
-
-Quando disegni interfacce, separa gli elementi comuni di design (bottoni, campi dei moduli, componenti di layout, etc.) in componenti riutilizzabili con interfacce ben definite. In questo modo, la prossima volta che dovrai costruire una nuova UI, puoi scrivere molto meno codice. Ciò significa tempi di sviluppo più brevi, meno bachi, e meno byte trasferiti sulla rete.
-
-
-## Validazione delle Proprietà
-
-Mentre la tua applicazione cresce, è utile assicurarsi che i tuoi componenti vengano usati correttamente. Ciò viene fatto permettendoti di specificare i `propTypes`. `React.PropTypes` esporta una gamma di validatori che possono essere usati per assicurarsi che i dati che ricevi siano validi. Quando ad una proprietà è assegnato un valore non valido, sarà mostrato un avvertimento nella console JavaScript. Nota che per motivi di prestazioni, `propTypes` è utilizzato soltanto nella modalità di sviluppo. Di seguito trovi un esempio che documenta i diversi validatori che vengono forniti:
-
-```javascript
-React.createClass({
- propTypes: {
- // Puoi dichiarare che una proprietà è uno specifico tipo primitivo JS. In
- // maniera predefinita, questi sono tutti opzionali.
- optionalArray: React.PropTypes.array,
- optionalBool: React.PropTypes.bool,
- optionalFunc: React.PropTypes.func,
- optionalNumber: React.PropTypes.number,
- optionalObject: React.PropTypes.object,
- optionalString: React.PropTypes.string,
- optionalSymbol: React.PropTypes.symbol,
-
- // Tutto ciò che può essere mostrato: numeri, stringhe, elementi, o un array
- // (o frammento) contenente questi tipi.
- optionalNode: React.PropTypes.node,
-
- // Un elemento React.
- optionalElement: React.PropTypes.element,
-
- // Puoi anche dichiarare che una proprietà è un'istanza di una classe. Questo
- // validatore usa l'operatore instanceof di JS.
- optionalMessage: React.PropTypes.instanceOf(Message),
-
- // Puoi assicurarti che la tua proprietà sia ristretta a valori specifici
- // trattandoli come una enumerazione.
- optionalEnum: React.PropTypes.oneOf(['News', 'Photos']),
-
- // Un oggetto che può essere di uno tra diversi tipi
- optionalUnion: React.PropTypes.oneOfType([
- React.PropTypes.string,
- React.PropTypes.number,
- React.PropTypes.instanceOf(Message)
- ]),
-
- // Un array di un tipo specificato
- optionalArrayOf: React.PropTypes.arrayOf(React.PropTypes.number),
-
- // Un oggetto con proprietà dai valori di un tipo specificato
- optionalObjectOf: React.PropTypes.objectOf(React.PropTypes.number),
-
- // Un oggetto che accetta una forma particolare
- optionalObjectWithShape: React.PropTypes.shape({
- color: React.PropTypes.string,
- fontSize: React.PropTypes.number
- }),
-
- // Puoi concatenare ciascuna delle precedenti con `isRequired` per assicurarti
- // che venga mostrato un avvertimento se la proprietà non viene impostata.
- requiredFunc: React.PropTypes.func.isRequired,
-
- // Un valore di un tipo qualsiasi
- requiredAny: React.PropTypes.any.isRequired,
-
- // Puoi inoltre specificare un validatore personalizzato. Deve restituire un
- // oggetto di tipo Error se la validazione fallisce. Non lanciare eccezioni
- // o utilizzare `console.warn`, in quanto non funzionerebbe all'interno di
- // `oneOfType`.
- customProp: function(props, propName, componentName) {
- if (!/matchme/.test(props[propName])) {
- return new Error('Validazione fallita!');
- }
- }
- },
- /* ... */
-});
-```
-
-
-## Valori Predefiniti delle Proprietà
-
-React ti permette di definire valori predefiniti per le tue `props` in una maniera molto dichiarativa:
-
-```javascript
-var ComponentWithDefaultProps = React.createClass({
- getDefaultProps: function() {
- return {
- value: 'valore predefinito'
- };
- }
- /* ... */
-});
-```
-
-Il risultato di `getDefaultProps()` sarà conservato e usato per assicurarsi che `this.props.value` avrà sempre un valore se non è stato specificato dal componente proprietario. Ciò ti permette di utilizzare in sicurezza le tue proprietà senza dover scrivere codice fragile e ripetitivo per gestirlo da te.
-
-
-## Trasferire le Proprietà: Una Scorciatoia
-
-Un tipo comune di componente React è uno che estende un elemento basico HTML in maniera semplice. Spesso vorrai copiare qualsiasi attributo HTML passato al tuo componente all'elemento HTML sottostante per risparmiare del codice. Puoi usare la sintassi _spread_ di JSX per ottenerlo:
-
-```javascript
-var CheckLink = React.createClass({
- render: function() {
- // Questo prende ciascuna proprietà passata a CheckLink e la copia su
- return {'√ '}{this.props.children};
- }
-});
-
-ReactDOM.render(
-
- Clicca qui!
- ,
- document.getElementById('example')
-);
-```
-
-## Figlio Singolo
-
-Con `React.PropTypes.element` puoi specificare che solo un figlio unico possa essere passato come figli ad un componente.
-
-```javascript
-var MyComponent = React.createClass({
- propTypes: {
- children: React.PropTypes.element.isRequired
- },
-
- render: function() {
- return (
-
- {this.props.children} // Questo deve essere esattamente un elemento oppure lancerà un'eccezione.
-
- );
- }
-
-});
-```
-
-## Mixin
-
-I componenti sono la maniera migliore di riutilizzare il codice in React, ma a volte componenti molto diversi possono condividere funzionalità comune. Questi sono a volte chiamate [responsabilità trasversali](https://en.wikipedia.org/wiki/Cross-cutting_concern). React fornisce i `mixin` per risolvere questo problema.
-
-Un caso d'uso comune è un componente che desidera aggiornarsi ad intervalli di tempo. È facile usare `setInterval()`, ma è anche importante cancellare la chiamata ripetuta quando non è più necessaria per liberare memoria. React fornisce dei [metodi del ciclo di vita](/react/docs/working-with-the-browser.html#component-lifecycle) che ti permettono di sapere quando un componente sta per essere creato o distrutto. Creiamo un semplice mixin che usa questi metodi per fornire una facile funzione `setInterval()` che sarà automaticamente rimossa quando il tuo componente viene distrutto.
-
-```javascript
-var SetIntervalMixin = {
- componentWillMount: function() {
- this.intervals = [];
- },
- setInterval: function() {
- this.intervals.push(setInterval.apply(null, arguments));
- },
- componentWillUnmount: function() {
- this.intervals.forEach(clearInterval);
- }
-};
-
-var TickTock = React.createClass({
- mixins: [SetIntervalMixin], // Usa il mixin
- getInitialState: function() {
- return {seconds: 0};
- },
- componentDidMount: function() {
- this.setInterval(this.tick, 1000); // Chiama un metodo del mixin
- },
- tick: function() {
- this.setState({seconds: this.state.seconds + 1});
- },
- render: function() {
- return (
-
- React has been running for {this.state.seconds} seconds.
-
- );
- }
-});
-
-ReactDOM.render(
- ,
- document.getElementById('example')
-);
-```
-
-Una caratteristica interessante dei mixin è che, se un componente usa molteplici mixin e diversi mixin definiscono lo stesso metodo del ciclo di vita (cioè diversi mixin desiderano effettuare una pulizia quando il componente viene distrutto), viene garantito che tutti i metodi del ciclo di vita verranno chiamati. I metodi definiti nei mixin vengono eseguiti nell'ordine in cui i mixin sono elencati, seguiti da una chiamata al metodo definito nel componente.
-
-## Classi ES6
-
-Puoi anche definire le tue classi React come pure classi JavaScript. Per esempio, usando la sintassi delle classi ES6:
-
-```javascript
-class HelloMessage extends React.Component {
- render() {
- return
Ciao {this.props.name}
;
- }
-}
-ReactDOM.render(, mountNode);
-```
-
-L'API è simile a `React.createClass` con l'eccezione del metodo `getInitialState`. Anziché fornire un metodo `getInitialState` a parte, imposti la tua proprietà `state` nel costruttore.
-
-Un'altra differenza è che `propTypes` e `defaultProps` sono definite come proprietà del costruttore anziché nel corpo della classe.
-
-```javascript
-export class Counter extends React.Component {
- constructor(props) {
- super(props);
- this.state = {count: props.initialCount};
- }
- tick() {
- this.setState({count: this.state.count + 1});
- }
- render() {
- return (
-
- Click: {this.state.count}
-
- );
- }
-}
-Counter.propTypes = { initialCount: React.PropTypes.number };
-Counter.defaultProps = { initialCount: 0 };
-```
-
-### Niente Binding Automatico
-
-I metodi seguono la stessa semantica delle classi ES6 regolari, ciò significa che non effettuano il binding automatico di `this` all'istanza. Dovrai pertanto usare esplicitamente `.bind(this)` oppure [le funzioni freccia](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions) `=>`.
-
-### Niente Mixin
-
-Sfortunatamente, ES6 è stato lanciato senza alcun supporto per i mixin. Di conseguenza non vi è alcun supporto per i mixin quando usi React con le classi ES6. Stiamo lavorando per rendere più semplice il supporto dei relativi casi d'uso senza ricorrere ai mixin.
-
-
-
-## Funzioni Prive di Stato
-
-Puoi anche definire le tue classi React come semplici funzioni JavaScript. Ad esempio usando la sintassi della funzione priva di stato:
-
-```javascript
-function HelloMessage(props) {
- return
Ciao {props.name}
;
-}
-ReactDOM.render(, mountNode);
-```
-
-Oppure usando la nuova sintassi freccia di ES6:
-
-```javascript
-const HelloMessage = (props) =>
Ciao {props.name}
;
-ReactDOM.render(, mountNode);
-```
-
-
-Questa API semplificata dei componenti è intesa per i componenti che sono pure funzioni dele proprietà. Questi componenti non devono trattenere stato interno, non hanno istanze di supporto, e non posseggono metodi di ciclo di vita. Sono pure trasformate funzionali del loro input, con zero codice boilerplate.
-
-> NOTA:
->
-> Poiché le funzioni prive di stato non hanno un'istanza di supporto, non puoi assegnare un ref a un componente creato con una funzione priva di stato. Normalmente questo non è un problema, poiché le funzioni prive di stato non forniscono un'API imperativa. Senza un'API imperativa, non puoi comunque fare molto con un'istanza. Tuttavia, se un utente desidera trovare il nodo DOM di un componente creato con una funzione priva di stato, occorre avvolgere il componente in un altro componente dotato di stato (ad es. un componente classe ES6) e assegnare il ref al componente dotato di stato.
-
-In un mondo ideale, la maggior parte dei tuoi componenti sarebbero funzioni prive di stato poiché questi componenti privi di stato seguono un percorso più rapido all'interno del core di React. Questo è un pattern raccomandato, quando possibile.
diff --git a/docs/docs/05-reusable-components.ja-JP.md b/docs/docs/05-reusable-components.ja-JP.md
deleted file mode 100644
index 4c86bbb436..0000000000
--- a/docs/docs/05-reusable-components.ja-JP.md
+++ /dev/null
@@ -1,231 +0,0 @@
----
-id: reusable-components
-title: 再利用可能なコンポーネント
-permalink: docs/reusable-components-ja-JP.html
-prev: multiple-components-ja-JP.html
-next: transferring-props-ja-JP.html
----
-
-インターフェースをデザインするとき、明確に定義されたインターフェースでは共通のデザイン要素(ボタン、フォームフィールド、レイアウトコンポーネントなど)を再利用可能なコンポーネントにブレークダウンします。そのような方法をとることで、次にUIを作成する必要があるときに、書くコードが少なくて済みます。これは、開発速度を上げ、バグを減らし、導線を減らすことを意味します。
-
-## Propのバリデーション
-
-アプリが大きくなっていくにつれて、コンポーネントが正しく使われていることを保証することが役に立つようになります。`propTypes` を指定することでそういったことができるようになります。`React.PropTypes` はあなたが受け取ったデータが正しいことを認識するのに使われるバリデータを出力します。不正な値がpropに渡されたときは、警告がJavaScriptコンソールに表示されます。パフォーマンスの点で、 `propTypes` は開発モードでのみチェックされることに注意してください。異なるバリデータが提供された際の例を表すドキュメントは以下の通りです。
-
-```javascript
-React.createClass({
- propTypes: {
- // propがJSのプリミティブ型であると宣言できます。
- // デフォルトで、以下は全てオプションです。
- optionalArray: React.PropTypes.array,
- optionalBool: React.PropTypes.bool,
- optionalFunc: React.PropTypes.func,
- optionalNumber: React.PropTypes.number,
- optionalObject: React.PropTypes.object,
- optionalString: React.PropTypes.string,
- optionalSymbol: React.PropTypes.symbol,
-
- // 何でもレンダリングできます。number、string、要素やそれらを含む配列など。
- optionalNode: React.PropTypes.node,
-
- // Reactの要素。
- optionalElement: React.PropTypes.element,
-
- // propがクラスのインスタンスであるとの宣言もできます。
- // JSのinstanceofオペレータを使用しています。
- optionalMessage: React.PropTypes.instanceOf(Message),
-
- // 以下をenumとして扱うことで、propがある値であると保証できます。
- optionalEnum: React.PropTypes.oneOf(['News', 'Photos']),
-
- // たくさんの型のうちのひとつになりうるオブジェクト
- optionalUnion: React.PropTypes.oneOfType([
- React.PropTypes.string,
- React.PropTypes.number,
- React.PropTypes.instanceOf(Message)
- ]),
-
- // ある型の配列
- optionalArrayOf: React.PropTypes.arrayOf(React.PropTypes.number),
-
- // プロパティの値がある型のものであるオブジェクト
- optionalObjectOf: React.PropTypes.objectOf(React.PropTypes.number),
-
- // 特定の形をとるオブジェクト
- optionalObjectWithShape: React.PropTypes.shape({
- color: React.PropTypes.string,
- fontSize: React.PropTypes.number
- }),
-
- // `isRequired` は上記のどの値にも繋げることができますが、
- // propが提供されなかったときには警告が出ることに注意してください。
- requiredFunc: React.PropTypes.func.isRequired,
-
- // どのようなデータ型の値でも大丈夫です
- requiredAny: React.PropTypes.any.isRequired,
-
- // バリデータをカスタマイズすることもできます。
- // 以下はバリデーションが落ちた時にはエラーを返します。
- // `oneOfType` の中で動かなくなるので、 `console.warn` や throw はしないでください。
- customProp: function(props, propName, componentName) {
- if (!/matchme/.test(props[propName])) {
- return new Error('Validation failed!');
- }
- }
- },
- /* ... */
-});
-```
-
-
-## デフォルトのPropの値
-
-Reactは以下のように、とても宣言的な方法で `props` のデフォルト値を定義できます。
-
-```javascript
-var ComponentWithDefaultProps = React.createClass({
- getDefaultProps: function() {
- return {
- value: 'default value'
- };
- }
- /* ... */
-});
-```
-
-`getDefaultProps()` の結果は `this.props.value` が親コンポーネントで制限されなかった場合に値を保証するためにキャッシュされて使われます。これによって、自分自身でハンドルするための壊れやすいコードを何度も書くことなくpropsをただ安全に使うことができます。
-
-## Propsの移動: ショートカット
-
-Reactのコンポーネントに共通しているのは、単純な方法で基本的なHTML要素を拡張していることです。よく、
-コンポーネントに渡されるHTML属性を、型付けを守るために、基本的なHTML要素にコピーしたいと考える人もいます。このようなことを行うために、JSXの _拡張された_ シンタックスを使うことができます。
-
-```javascript
-var CheckLink = React.createClass({
- render: function() {
- // 以下はCheckLinkに渡されたどんなpropsをとることができ、タグにコピーすることもできます。
- return {'√ '}{this.props.children};
- }
-});
-
-ReactDOM.render(
-
- Click here!
- ,
- document.getElementById('example')
-);
-```
-
-## 単一の子要素
-
-`React.PropTypes.element` を使って、childrenとしてコンポーネントにただ一つの子要素が渡されるよう制限できます。
-
-```javascript
-var MyComponent = React.createClass({
- propTypes: {
- children: React.PropTypes.element.isRequired
- },
-
- render: function() {
- return (
-
- );
- }
-}
-Counter.propTypes = { initialCount: React.PropTypes.number };
-Counter.defaultProps = { initialCount: 0 };
-```
-
-### オートバインディングしません
-
-メソッドは標準のES6のクラスと同じ仕様です。それは、 `this` をインスタンスに自動的にバインドしないことを意味します。明確に `.bind(this)` を使うか [アロー関数](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/) `=>` を使ってください。
-
-### ミックスインはありません
-
-不幸なことに、ES6はミックスインのサポートを行いません。それゆえ、ReactをES6のクラスと一緒に使う際にはミックスインのサポートはありません。代わりに、ミックスインに頼ることなくそれらのユースケースをサポートするのが簡単になるよう努力しています。
diff --git a/docs/docs/05-reusable-components.ko-KR.md b/docs/docs/05-reusable-components.ko-KR.md
deleted file mode 100644
index 3f6bba4212..0000000000
--- a/docs/docs/05-reusable-components.ko-KR.md
+++ /dev/null
@@ -1,256 +0,0 @@
----
-id: reusable-components-ko-KR
-title: 재사용가능한 컴포넌트
-permalink: docs/reusable-components-ko-KR.html
-prev: multiple-components-ko-KR.html
-next: transferring-props-ko-KR.html
----
-
-인터페이스를 설계할 때, 공통적으로 사용되는 디자인 요소들(버튼, 폼 필드, 레이아웃 컴포넌트 등.)을 잘 정의된 인터페이스의 재사용 가능한 컴포넌트로 분해합니다. 이런 방법으로 다음에 UI를 구축할 때에는 훨씬 적은 코드로 만들 수 있습니다. 이 말은 더 빠른 개발 시간, 더 적은 버그, 더 적은 용량으로 할 수 있다는 뜻이죠.
-
-## Prop 검증
-
-앱의 규모가 커지면 컴포넌트들이 바르게 사용되었는지 확인하는게 도움이 됩니다. 확인은 `propTypes`를 명시해서 할 수 있습니다. `React.PropTypes`는 받은 데이터가 적절한지(valid) 확인하는데 사용할 수 있는 다양한 검증자(validator)를 제공합니다. prop에 부적절한 값을 명시한다면 JavaScript 콘솔에 경고가 보일 것입니다. 성능상의 문제로 `propTypes`는 개발 모드에서만 검사됩니다. 다음은 제공되는 검증자를 설명하는 예제입니다.
-
-```javascript
-React.createClass({
- propTypes: {
- // 특정 JavaScript 프리미티브 타입에 대한 prop을 명시할 수 있습니다.
- // 기본적으로 이것들은 모두 선택적입니다.
- optionalArray: React.PropTypes.array,
- optionalBool: React.PropTypes.bool,
- optionalFunc: React.PropTypes.func,
- optionalNumber: React.PropTypes.number,
- optionalObject: React.PropTypes.object,
- optionalString: React.PropTypes.string,
- optionalSymbol: React.PropTypes.symbol,
-
- // 렌더링될 수 있는 모든 것: 숫자, 문자열, 요소
- // 이것들을 포함하는 배열(이나 프래그먼트)
- optionalNode: React.PropTypes.node,
-
- // React 엘리먼트
- optionalElement: React.PropTypes.element,
-
- // 클래스의 인스턴스 또한 prop으로 명시할 수 있습니다. JavaScript의 instanceof
- // 연산자를 사용합니다.
- optionalMessage: React.PropTypes.instanceOf(Message),
-
- // 열거형처럼 특정 값들로만 prop을 제한해서 사용할 수 있습니다.
- optionalEnum: React.PropTypes.oneOf(['News', 'Photos']),
-
- // 많은 타입들 중 하나로 사용할 수 있는 객체가 될 수도 있습니다.
- optionalUnion: React.PropTypes.oneOfType([
- React.PropTypes.string,
- React.PropTypes.number,
- React.PropTypes.instanceOf(Message)
- ]),
-
- // 특정 타입의 배열
- optionalArrayOf: React.PropTypes.arrayOf(React.PropTypes.number),
-
- // 특정 타입의 속성값을 갖는 객체
- optionalObjectOf: React.PropTypes.objectOf(React.PropTypes.number),
-
- // 특정한 형태(shape)의 객체
- optionalObjectWithShape: React.PropTypes.shape({
- color: React.PropTypes.string,
- fontSize: React.PropTypes.number
- }),
-
- // 위에 언급된 것들을 `isRequired`로 연결해서 prop이 제공되지 않을 때 경고를
- // 띄우도록 할 수도 있습니다.
- requiredFunc: React.PropTypes.func.isRequired,
-
- // 어떤 데이터 타입도 가능
- requiredAny: React.PropTypes.any.isRequired,
-
- // 물론 사용자 정의 검증자도 지정할 수 있습니다. 이는 검증이 실패했을 때
- // Error 객체를 리턴해야합니다. `console.warn`을 이나 throw를 하면 안됩니다.
- // 그렇게하면 `oneOfType` 안에서 작동하지 않습니다.
- customProp: function(props, propName, componentName) {
- if (!/matchme/.test(props[propName])) {
- return new Error('Validation failed!');
- }
- }
- },
- /* ... */
-});
-```
-
-## 기본 Prop 값
-
-React는 매우 선언적(declarative)인 방법으로 `props`의 기본값을 정의할 수 있게 해줍니다.
-
-```javascript
-var ComponentWithDefaultProps = React.createClass({
- getDefaultProps: function() {
- return {
- value: 'default value'
- };
- }
- /* ... */
-});
-```
-
-`getDefaultProps()`의 결과값은 캐시가 되며, 부모 컴포넌트에서 명시되지 않았을 때 `this.props.value`가 값을 가질 수 있도록 해주는데 사용됩니다.`getDefaultProps()`를 사용하면 반복적이고 깨지기 쉬운 코드를 짤 필요없이 그냥 안전하게 prop을 사용할 수 있습니다.
-
-## Prop 전달하기: 단축
-
-React 컴포넌트의 흔히 그냥 기본 HTML 엘리먼트를 확장해서 씁니다. 타이핑을 아끼기 위해 기저의 HTML 엘리먼트에 HTML 속성들을 단순히 복사하는 컴포넌트가 필요할 수도 있습니다. JSX의 _spread_ 문법을 사용하면 이렇게 할 수 있습니다.
-
-```javascript
-var CheckLink = React.createClass({
- render: function() {
- // 모든 prop을 받아서 CheckLink에 넘기고 에 복사합니다.
- return {'√ '}{this.props.children};
- }
-});
-
-ReactDOM.render(
-
- Click here!
- ,
- document.getElementById('example')
-);
-```
-
-## 단일 자식
-
-`React.PropTypes.element`을 통해 컴포넌트에 한 자식만 보내도록 명시할 수 있습니다.
-
-```javascript
-var MyComponent = React.createClass({
- propTypes: {
- children: React.PropTypes.element.isRequired
- },
-
- render: function() {
- return (
-
- {this.props.children} // 정확히 한 엘리먼트여야만 하며, 아니면 에러가 발생합니다.
-
- );
- }
-
-});
-```
-
-## 믹스인
-
-컴포넌트는 React에서 코드를 재사용할 수 있는 최고의 방법이지만, 가끔 아주 다른 컴포넌트에서 공통 기능이 필요한 때도 있습니다. 이런 상황을 [공통된 관심사(cross-cutting concerns)](https://en.wikipedia.org/wiki/Cross-cutting_concern)라 부르며, React에서는 `mixins`으로 이 문제를 해결합니다.
-
-예를 들어, 컴포넌트가 주기적으로 업데이트되길 원할 경우가 있습니다. `setInterval()`을 사용하면 쉽지만, 필요 없어지면 메모리를 아끼기 위해 주기를 꼭 취소해야 합니다. React는 컴포넌트가 막 생성거나 없어질 때를 [생명주기 메소드](/react/docs/working-with-the-browser-ko-KR.html#컴포넌트-생명주기)를 통해 알려줍니다. 이런 메소드들을 사용해서 컴포넌트가 사라질 때 자동으로 정리해주는 `setInterval()`를 제공해주는 간단한 믹스인을 만들어보겠습니다.
-
-```javascript
-var SetIntervalMixin = {
- componentWillMount: function() {
- this.intervals = [];
- },
- setInterval: function() {
- this.intervals.push(setInterval.apply(null, arguments));
- },
- componentWillUnmount: function() {
- this.intervals.forEach(clearInterval);
- }
-};
-
-var TickTock = React.createClass({
- mixins: [SetIntervalMixin], // 믹스인 사용
- getInitialState: function() {
- return {seconds: 0};
- },
- componentDidMount: function() {
- this.setInterval(this.tick, 1000); // 믹스인에 있는 메소드를 호출
- },
- tick: function() {
- this.setState({seconds: this.state.seconds + 1});
- },
- render: function() {
- return (
-
- React has been running for {this.state.seconds} seconds.
-
- );
- }
-});
-
-ReactDOM.render(
- ,
- document.getElementById('example')
-);
-```
-
-믹스인의 괜찮은 점은 컴포넌트가 여러 믹스인을 사용하고 여러 믹스인에서 같은 생명주기 메소드를 사용할 때(예를 들어, 여러 믹스인에서 컴포넌트가 사라질 때 뭔가 정리하려 한다면) 모든 생명주기 메소드들의 실행은 보장됩니다. 믹스인에 정의된 메소드은 컴포넌트의 메소드가 호출됨에 따라 믹스인이 나열된 순서대로 실행됩니다.
-
-## ES6 클래스
-
-React 클래스를 일반적인 JavaScript 클래스로 선언할 수도 있습니다. 다음의 예제는 ES6 클래스 문법을 사용합니다:
-
-```javascript
-class HelloMessage extends React.Component {
- render() {
- return
Hello {this.props.name}
;
- }
-}
-ReactDOM.render(, mountNode);
-```
-
-API는 `getInitialState`를 제외하고 `React.createClass`와 유사합니다. 별도의 `getInitialState` 메소드 대신에, 필요한 `state` 프로퍼티를 생성자에서 설정할 수 있습니다.
-
-또다른 차이점은 `propTypes`와 `defaultProps`가 클래스의 내부가 아니라 생성자의 프로퍼티로 정의되어 있다는 것입니다.
-
-```javascript
-export class Counter extends React.Component {
- constructor(props) {
- super(props);
- this.state = {count: props.initialCount};
- }
- tick() {
- this.setState({count: this.state.count + 1});
- }
- render() {
- return (
-
- Clicks: {this.state.count}
-
- );
- }
-}
-Counter.propTypes = { initialCount: React.PropTypes.number };
-Counter.defaultProps = { initialCount: 0 };
-```
-
-### 자동 바인딩 안됨
-
-메소드는 일반 ES6 클래스와 동일한 시멘틱을 따릅니다. `this`를 인스턴스에 자동으로 바인딩하지 않는다는 이야기입니다. 명시적으로 `.bind(this)`나 [화살표 함수(arrow function)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions) `=>`를 사용하세요.
-
-### 믹스인 안됨
-
-불행하게도 ES6는 믹스인에 대한 지원이 없이 출시되었기 때문에, React에서 ES6 클래스를 사용한다면 믹스인을 사용할 방법이 없습니다. 대신, 우리는 믹스인에 의존하지 않고도 동작하도록 만들기 위해 열심히 노력하고 있습니다.
-
-## 상태를 가지지 않는 함수
-
-React 클래스를 일반 JavaScript 함수로 작성할 수도 있습니다. 상태를 가지지 않는 함수 문법을 사용하는 예제입니다.
-
-```javascript
-function HelloMessage(props) {
- return
Hello {props.name}
;
-}
-ReactDOM.render(, mountNode);
-```
-
-아니면 ES6의 화살표 문법을 사용할 수 있습니다.
-
-```javascript
-const HelloMessage = (props) =>
Hello {props.name}
;
-ReactDOM.render(, mountNode);
-```
-
-이 단순화된 컴포넌트 API는 prop의 순수 함수인 컴포넌트를 나타냅니다. 이 컴포넌트는 내부 상태가 없어야 하고, 내부 인스턴스가 없어야 하고, 컴포넌트 생명주기 메소드가 없어야 합니다. 아무런 준비 과정없이 입력에 대한 순수한 기능적 변환이어야 합니다.
-
-> 주의:
->
-> 상태를 가지지 않는 함수는 내부 인스턴스가 없기 때문에, ref를 상태를 가지지않는 함수에 넣을 수 없습니다. 상태를 가지지 않는 함수는 명령형(imperative) API를 제공하지 않기 때문에 일반적으로 이것은 문제가 되지 않습니다. 명령형 API없이 인스턴스에 할 수 있는 것이 많지 않기도 하죠. 하지만 상태를 가지지 않는 컴포넌트의 DOM 노드를 검색하길 원한다면, 반드시 상태 기반 컴포넌트(예. ES6 클래스 컴포넌트)로 컴포넌트를 감싸고 상태 기반 래퍼 컴포넌트에 ref를 붙여야 합니다.
-
-이상적으로는, 대부분의 컴포넌트는 상태를 가지지 않는 함수여야 합니다. 왜냐 하면 이런 상태를 가지지 않는 컴포넌트는 React 코어 안에서 더 빠른 코드 경로를 거치기 때문입니다. 이는 가능한 한 추천하는 패턴입니다.
diff --git a/docs/docs/05-reusable-components.md b/docs/docs/05-reusable-components.md
deleted file mode 100644
index c9d8ca3e2d..0000000000
--- a/docs/docs/05-reusable-components.md
+++ /dev/null
@@ -1,462 +0,0 @@
----
-id: reusable-components
-title: Reusable Components
-permalink: docs/reusable-components.html
-prev: multiple-components.html
-next: transferring-props.html
----
-
-When designing interfaces, break down the common design elements (buttons, form fields, layout components, etc.) into reusable components with well-defined interfaces. That way, the next time you need to build some UI, you can write much less code. This means faster development time, fewer bugs, and fewer bytes down the wire.
-
-## Prop Validation
-
-As your app grows it's helpful to ensure that your components are used correctly. We do this by allowing you to specify `propTypes`. `React.PropTypes` exports a range of validators that can be used to make sure the data you receive is valid. When an invalid value is provided for a prop, a warning will be shown in the JavaScript console. Note that for performance reasons `propTypes` is only checked in development mode.
-
-You can assign a special property to a component to declare its `propTypes`:
-
-```javascript
-class Greeting extends React.Component {
- render() {
- return (
-
Hello, {this.props.name}
- );
- }
-}
-
-Greeting.propTypes = {
- name: React.PropTypes.string
-};
-```
-
-Here is an example documenting the different validators provided:
-
-```javascript
-MyComponent.propTypes = {
- // You can declare that a prop is a specific JS primitive. By default, these
- // are all optional.
- optionalArray: React.PropTypes.array,
- optionalBool: React.PropTypes.bool,
- optionalFunc: React.PropTypes.func,
- optionalNumber: React.PropTypes.number,
- optionalObject: React.PropTypes.object,
- optionalString: React.PropTypes.string,
- optionalSymbol: React.PropTypes.symbol,
-
- // Anything that can be rendered: numbers, strings, elements or an array
- // (or fragment) containing these types.
- optionalNode: React.PropTypes.node,
-
- // A React element.
- optionalElement: React.PropTypes.element,
-
- // You can also declare that a prop is an instance of a class. This uses
- // JS's instanceof operator.
- optionalMessage: React.PropTypes.instanceOf(Message),
-
- // You can ensure that your prop is limited to specific values by treating
- // it as an enum.
- optionalEnum: React.PropTypes.oneOf(['News', 'Photos']),
-
- // An object that could be one of many types
- optionalUnion: React.PropTypes.oneOfType([
- React.PropTypes.string,
- React.PropTypes.number,
- React.PropTypes.instanceOf(Message)
- ]),
-
- // An array of a certain type
- optionalArrayOf: React.PropTypes.arrayOf(React.PropTypes.number),
-
- // An object with property values of a certain type
- optionalObjectOf: React.PropTypes.objectOf(React.PropTypes.number),
-
- // An object taking on a particular shape
- optionalObjectWithShape: React.PropTypes.shape({
- color: React.PropTypes.string,
- fontSize: React.PropTypes.number
- }),
-
- // You can chain any of the above with `isRequired` to make sure a warning
- // is shown if the prop isn't provided.
- requiredFunc: React.PropTypes.func.isRequired,
-
- // A value of any data type
- requiredAny: React.PropTypes.any.isRequired,
-
- // You can also specify a custom validator. It should return an Error
- // object if the validation fails. Don't `console.warn` or throw, as this
- // won't work inside `oneOfType`.
- customProp: function(props, propName, componentName) {
- if (!/matchme/.test(props[propName])) {
- return new Error(
- 'Invalid prop `' + propName + '` supplied to' +
- ' `' + componentName + '`. Validation failed.'
- );
- }
- },
-
- // You can also supply a custom validator to `arrayOf` and `objectOf`.
- // It should return an Error object if the validation fails. The validator
- // will be called for each key in the array or object. The first two
- // arguments of the validator are the array or object itself, and the
- // current item's key.
- customArrayProp: React.PropTypes.arrayOf(function(propValue, key, componentName, location, propFullName) {
- if (!/matchme/.test(propValue[key])) {
- return new Error(
- 'Invalid prop `' + propFullName + '` supplied to' +
- ' `' + componentName + '`. Validation failed.'
- );
- }
- })
-};
-```
-
-### Single Child
-
-With `React.PropTypes.element` you can specify that only a single child can be passed to a component as children.
-
-```javascript
-class MyComponent extends React.Component {
- render() {
- // This must be exactly one element or it will warn.
- var children = this.props.children;
- return (
-
- {children}
-
- );
- }
-}
-
-MyComponent.propTypes = {
- children: React.PropTypes.element.isRequired
-};
-```
-
-## Default Prop Values
-
-React lets you define default values for your `props` in a very declarative way:
-
-```javascript
-class Greeting extends React.Component {
- render() {
- return (
-
Hello, {this.props.name}
- );
- }
-}
-
-// Specifies the default values for props:
-Greeting.defaultProps = {
- name: 'Stranger'
-};
-
-// Renders "Hello, Stranger":
-ReactDOM.render(
- ,
- document.getElementById('example')
-);
-```
-
-The `defaultProps` will be used to ensure that `this.props.name` will have a value if it was not specified by the parent component. This allows you to safely just use your props without having to write repetitive and fragile code to handle that yourself.
-
-## Transferring Props: A Shortcut
-
-A common type of React component is one that extends a basic HTML element in a simple way. Often you'll want to copy any HTML attributes passed to your component to the underlying HTML element. To save typing, you can use the JSX _spread_ syntax to achieve this:
-
-```javascript
-class CheckLink extends React.Component {
- render() {
- // This takes any props passed to CheckLink and copies them to
- return (
- {'√ '}{this.props.children}
- );
- }
-}
-
-ReactDOM.render(
-
- Click here!
- ,
- document.getElementById('example')
-);
-```
-
-## Stateless Functions
-
-If a component doesn't use local state or lifecycle hooks, you can define it as a function instead of a class:
-
-```javascript
-function Greeting(props) {
- return
Hello, {props.name}
;
-}
-
-ReactDOM.render(
- ,
- document.getElementById('example')
-);
-```
-
-Or using the new ES6 arrow syntax:
-
-```javascript
-const Greeting = (props) => (
-
Hello, {props.name}
-);
-
-ReactDOM.render(
- ,
- document.getElementById('example')
-);
-```
-
-This simplified component API is intended for components that are pure functions of their props. These components must not retain internal state, do not have backing instances, and do not have the component lifecycle methods. They are pure functional transforms of their input, with zero boilerplate.
-
-However, you may still specify `.propTypes` and `.defaultProps` by setting them as properties on the function, just as you would set them on an ES6 class:
-
-```javascript
-function Greeting(props) {
- return (
-
Hello, {props.name}
- );
-}
-
-Greeting.propTypes = {
- name: React.PropTypes.string
-};
-
-Greeting.defaultProps = {
- name: 'John Doe'
-};
-
-ReactDOM.render(
- ,
- document.getElementById('example')
-);
-```
-
->**Note:**
->
-> Because stateless functions don't have a backing instance, you can't attach a ref to a stateless function component. Normally this isn't an issue, since stateless functions do not provide an imperative API. Without an imperative API, there isn't much you could do with an instance anyway. However, if a user wants to find the DOM node of a stateless function component, they must wrap the component in a stateful component (eg. ES6 class component) and attach the ref to the stateful wrapper component.
-
-In an ideal world, many of your components would be stateless functions. In the future we plan to make performance optimizations specific to these components by avoiding unnecessary checks and memory allocations.
-
-When you don't need local state or lifecycle hooks in a component, we recommend declaring it with a function. Otherwise, we recommend to use the ES6 class syntax.
-
-## ES6 Classes and React.createClass()
-
-Normally you would define a React component as a plain JavaScript class:
-
-```javascript
-class Greeting extends React.Component {
- render() {
- return
Hello, {this.props.name}
;
- }
-}
-```
-
-If you don't use ES6 yet, you may use [`React.createClass`](/react/docs/top-level-api.html#react.createclass) helper instead:
-
-
-```javascript
-var Greeting = React.createClass({
- render: function() {
- return
Hello, {this.props.name}
;
- }
-});
-```
-
-The API of ES6 classes is similar to [`React.createClass`](/react/docs/top-level-api.html#react.createclass) with a few exceptions.
-
-### Declaring Prop Types and Default Props
-
-With functions and ES6 classes, `propTypes` and `defaultProps` are defined as properties on the components themselves:
-
-```javascript
-class Greeting extends React.Component {
- // ...
-}
-
-Greeting.propTypes = {
- name: React.PropTypes.string
-};
-
-Greeting.defaultProps = {
- name: 'Mary'
-};
-```
-
-With `React.createClass()`, you need to define `propTypes` as a property on the passed object, and `getDefaultProps()` as a function on it:
-
-```javascript
-var Greeting = React.createClass({
- propTypes: {
- name: React.PropTypes.string
- },
-
- getDefaultProps: function() {
- return {
- name: 'Mary'
- };
- },
-
- // ...
-
-});
-```
-
-### Setting the Initial State
-
-In ES6 classes, you can define the initial state by assigning `this.state` in the constructor:
-
-```javascript
-class Counter extends React.Component {
- constructor(props) {
- super(props);
- this.state = {count: props.initialCount};
- }
- // ...
-}
-```
-
-With `React.createClass()`, you have to provide a separate `getInitialState` method that returns the initial state:
-
-```javascript
-var Counter = React.createClass({
- getInitialState: function() {
- return {count: props.initialCount};
- },
- // ...
-});
-```
-
-### Autobinding
-
-In React components declared as ES6 classes, methods follow the same semantics as regular ES6 classes. This means that they don't automatically bind `this` to the instance. You'll have to explicitly use `.bind(this)` in the constructor:
-
-```javascript
-class SayHello extends React.Component {
- constructor(props) {
- super(props);
- // This line is important!
- this.handleClick = this.handleClick.bind(this);
- }
-
- handleClick() {
- alert('Hello!');
- }
-
- render() {
- // Because we `this.tick` is bound, we can use it as an event handler.
- return (
-
- );
- }
-}
-```
-
-With `React.createClass()`, this is not necessary because it binds all methods:
-
-```javascript
-var SayHello = React.createClass({
- handleClick: function() {
- alert('Hello!');
- },
-
- render: function() {
- return (
-
- );
- }
-});
-```
-
-This means writing ES6 classes comes with a little more boilerplate code for event handlers, but the upside is slightly better performance in large applications.
-
-If the boilerplate code is too unattractive to you, you may enable the **experimental** [Class Properties](https://babeljs.io/docs/plugins/transform-class-properties/) syntax proposal with Babel:
-
-
-```javascript
-class SayHello extends React.Component {
- // WARNING: this syntax is experimental!
- // Using an arrow here binds the method:
- handleClick = () => {
- alert('Hello!');
- }
-
- render() {
- return (
-
- );
- }
-}
-```
-
-Please note that the syntax above is **experimental** and the syntax may change, or the proposal might not make it into the language.
-
-If you'd rather play it safe, you have a few options:
-
-* Bind methods in the constructor.
-* Use arrow functions, e.g. `onClick={(e) => this.handleClick(e)})`.
-* Keep using `React.createClass()`.
-
-### Mixins
-
->**Note:**
->
->ES6 launched without any mixin support. Therefore, there is no support for mixins when you use React with ES6 classes.
->
->**We also found numerous issues in codebases using mixins, [and don't recommend using them in the new code](/react/blog/2016/07/13/mixins-considered-harmful.html).**
->
->This section exists only for the reference.
-
-Sometimes very different components may share some common functionality. These are sometimes called [cross-cutting concerns](https://en.wikipedia.org/wiki/Cross-cutting_concern). [`React.createClass`](/react/docs/top-level-api.html#react.createclass) lets you use a legacy `mixins` system for that.
-
-One common use case is a component wanting to update itself on a time interval. It's easy to use `setInterval()`, but it's important to cancel your interval when you don't need it anymore to save memory. React provides [lifecycle methods](/react/docs/working-with-the-browser.html#component-lifecycle) that let you know when a component is about to be created or destroyed. Let's create a simple mixin that uses these methods to provide an easy `setInterval()` function that will automatically get cleaned up when your component is destroyed.
-
-```javascript
-var SetIntervalMixin = {
- componentWillMount: function() {
- this.intervals = [];
- },
- setInterval: function() {
- this.intervals.push(setInterval.apply(null, arguments));
- },
- componentWillUnmount: function() {
- this.intervals.forEach(clearInterval);
- }
-};
-
-var TickTock = React.createClass({
- mixins: [SetIntervalMixin], // Use the mixin
- getInitialState: function() {
- return {seconds: 0};
- },
- componentDidMount: function() {
- this.setInterval(this.tick, 1000); // Call a method on the mixin
- },
- tick: function() {
- this.setState({seconds: this.state.seconds + 1});
- },
- render: function() {
- return (
-
- React has been running for {this.state.seconds} seconds.
-
- );
- }
-});
-
-ReactDOM.render(
- ,
- document.getElementById('example')
-);
-```
-
-If a component is using multiple mixins and several mixins define the same lifecycle method (i.e. several mixins want to do some cleanup when the component is destroyed), all of the lifecycle methods are guaranteed to be called. Methods defined on mixins run in the order mixins were listed, followed by a method call on the component.
diff --git a/docs/docs/05-reusable-components.zh-CN.md b/docs/docs/05-reusable-components.zh-CN.md
deleted file mode 100644
index 8c31b75a99..0000000000
--- a/docs/docs/05-reusable-components.zh-CN.md
+++ /dev/null
@@ -1,285 +0,0 @@
----
-id: reusable-components-zh-CN
-title: 可复用组件
-permalink: docs/reusable-components-zh-CN.html
-prev: multiple-components-zh-CN.html
-next: transferring-props-zh-CN.html
----
-
-设计接口的时候,把通用的设计元素(按钮,表单框,布局组件等)拆成接口良好定义的可复用的组件。这样,下次开发相同界面程序时就可以写更少的代码,也意义着更高的开发效率,更少的 Bug 和更少的程序体积。
-
-## Prop 验证
-
-随着应用不断变大,保证组件被正确使用变得非常有用。为此我们引入 `propTypes`。`React.PropTypes` 提供很多验证器 (validator) 来验证传入数据的有效性。当向 props 传入无效数据时,JavaScript 控制台会抛出警告。注意为了性能考虑,只在开发环境验证 `propTypes`。下面用例子来说明不同验证器的区别:
-
-```javascript
-React.createClass({
- propTypes: {
- // 可以声明 prop 为指定的 JS 基本类型。默认
- // 情况下,这些 prop 都是可传可不传的。
- optionalArray: React.PropTypes.array,
- optionalBool: React.PropTypes.bool,
- optionalFunc: React.PropTypes.func,
- optionalNumber: React.PropTypes.number,
- optionalObject: React.PropTypes.object,
- optionalString: React.PropTypes.string,
- optionalSymbol: React.PropTypes.symbol,
-
- // 所有可以被渲染的对象:数字,
- // 字符串,DOM 元素或包含这些类型的数组(or fragment) 。
- optionalNode: React.PropTypes.node,
-
- // React 元素
- optionalElement: React.PropTypes.element,
-
- // 你同样可以断言一个 prop 是一个类的实例。
- // 用 JS 的 instanceof 操作符声明 prop 为类的实例。
- optionalMessage: React.PropTypes.instanceOf(Message),
-
- // 你可以用 enum 的方式
- // 确保你的 prop 被限定为指定值。
- optionalEnum: React.PropTypes.oneOf(['News', 'Photos']),
-
- // 指定的多个对象类型中的一个
- optionalUnion: React.PropTypes.oneOfType([
- React.PropTypes.string,
- React.PropTypes.number,
- React.PropTypes.instanceOf(Message)
- ]),
-
- // 指定类型组成的数组
- optionalArrayOf: React.PropTypes.arrayOf(React.PropTypes.number),
-
- // 指定类型的属性构成的对象
- optionalObjectOf: React.PropTypes.objectOf(React.PropTypes.number),
-
- // 特定形状参数的对象
- optionalObjectWithShape: React.PropTypes.shape({
- color: React.PropTypes.string,
- fontSize: React.PropTypes.number
- }),
-
- // 你可以在任意东西后面加上 `isRequired`
- // 来确保 如果 prop 没有提供 就会显示一个警告。
- requiredFunc: React.PropTypes.func.isRequired,
-
- // 不可空的任意类型
- requiredAny: React.PropTypes.any.isRequired,
-
- // 你可以自定义一个验证器。如果验证失败需要返回一个 Error 对象。
- // 不要直接使用 `console.warn` 或抛异常,
- // 因为这在 `oneOfType` 里不起作用。
- customProp: function(props, propName, componentName) {
- if (!/matchme/.test(props[propName])) {
- return new Error('Validation failed!');
- }
- }
- },
- /* ... */
-});
-```
-
-### Single Child
-
-用 `React.PropTypes.element` 你可以指定仅有一个子级能被传送给组件
-
-```javascript
-var MyComponent = React.createClass({
- propTypes: {
- children: React.PropTypes.element.isRequired
- },
-
- render: function() {
- return (
-
;
-ReactDOM.render(, mountNode);
-```
-
-这个简化的组件API旨在用于那些纯函数态的组件 。这些组件必须没有保持任何内部状态,没有备份实例,也没有组件生命周期方法。他们纯粹的函数式的转化他们的输入,没有引用。
-然而,你仍然可以以设置函数 properties 的方式来指定 `.propTypes` 和 `.defaultProps`,就像你在ES6类里设置他们那样。
-
-> 注意:
->
-> 因为无状态函数没有备份实例,你不能附加一个引用到一个无状态函数组件。 通常这不是问题,因为无状态函数不提供一个命令式的API。没有命令式的API,你就没有任何需要实例来做的事。然而,如果用户想查找无状态函数组件的DOM节点,他们必须把这个组件包装在一个有状态组件里(比如,ES6 类组件) 并且连接一个引用到有状态的包装组件。
-
-在理想世界里,你的大多数组件都应该是无状态函数,因为将来我们可能会用避免不必要的检查和内存分配的方式来对这些组件进行优化。 如果可能,这是推荐的模式。
diff --git a/docs/docs/06-transferring-props.it-IT.md b/docs/docs/06-transferring-props.it-IT.md
deleted file mode 100644
index 0eda8733c1..0000000000
--- a/docs/docs/06-transferring-props.it-IT.md
+++ /dev/null
@@ -1,153 +0,0 @@
----
-id: transferring-props-it-IT
-title: Trasferimento delle Proprietà
-permalink: docs/transferring-props-it-IT.html
-prev: reusable-components-it-IT.html
-next: forms-it-IT.html
----
-
-Un pattern comune in React è l'uso di un'astrazione per esporre un componente. Il componente esterno espone una semplice proprietà per effettuare un'azione che può richiedere un'implementazione più complessa.
-
-Puoi usare gli [attributi spread di JSX](/react/docs/jsx-spread.html) per unire le vecchie props con valori aggiuntivi:
-
-```javascript
-
-```
-
-Se non usi JSX, puoi usare qualsiasi helper come l'API `Object.assign` di ES6, o il metodo `_.extend` di Underscore:
-
-```javascript
-React.createElement(Component, Object.assign({}, this.props, { more: 'values' }));
-```
-
-Nel resto di questo tutorial vengono illustrate le best practices, usando JSX e sintassi sperimentale di ES7.
-
-## Trasferimento Manuale
-
-Nella maggior parte dei casi dovresti esplicitamente passare le proprietà. Ciò assicura che venga esposto soltanto un sottoinsieme dell'API interna, del cui funzionamento si è certi.
-
-```javascript
-function FancyCheckbox(props) {
- var fancyClass = props.checked ? 'FancyChecked' : 'FancyUnchecked';
- return (
-
- {props.children}
-
- );
-}
-ReactDOM.render(
-
- Ciao mondo!
- ,
- document.getElementById('example')
-);
-```
-
-E se aggiungessimo una proprietà `name`? O una proprietà `title`? O `onMouseOver`?
-
-## Trasferire con `...` in JSX
-
-> NOTA:
->
-> La sintassi `...` fa parte della proposta Object Rest Spread. Questa proposta è in processo di diventare uno standard. Consulta la sezione [Proprietà Rest e Spread ...](/react/docs/transferring-props.html#rest-and-spread-properties-...) di seguito per maggiori dettagli.
-
-A volte passare manualmente ciascuna proprietà può essere noioso e fragile. In quei casi puoi usare l'[assegnamento destrutturante](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment) con le proprietà residue per estrarre un insieme di proprietà sconosciute.
-
-Elenca tutte le proprietà che desideri consumare, seguite da `...other`.
-
-```javascript
-var { checked, ...other } = props;
-```
-
-Ciò assicura che vengano passate tutte le proprietà TRANNE quelle che stai consumando tu stesso.
-
-```javascript
-function FancyCheckbox(props) {
- var { checked, ...other } = props;
- var fancyClass = checked ? 'FancyChecked' : 'FancyUnchecked';
- // `other` contiene { onClick: console.log } ma non la proprietà checked
- return (
-
- );
-}
-ReactDOM.render(
-
- Ciao mondo!
- ,
- document.getElementById('example')
-);
-```
-
-> NOTA:
->
-> Nell'esempio precedente, la proprietà `checked` è anche un attributo DOM valido. Se non utilizzassi la destrutturazione in questo modo, potresti inavvertitamente assegnarlo al `div`.
-
-Usa sempre il pattern di destrutturazione quando trasferisci altre proprietà sconosciute in `other`.
-
-```javascript
-function FancyCheckbox(props) {
- var fancyClass = props.checked ? 'FancyChecked' : 'FancyUnchecked';
- // ANTI-PATTERN: `checked` sarebbe passato al componente interno
- return (
-
- );
-}
-```
-
-## Consumare e Trasferire la Stessa Proprietà
-
-Se il tuo componente desidera consumare una proprietà, ma anche passarla ad altri, puoi passarla esplicitamente mediante `checked={checked}`. Questo è preferibile a passare l'intero oggetto `this.props` dal momento che è più facile effettuarne il linting e il refactoring.
-
-```javascript
-function FancyCheckbox(props) {
- var { checked, title, ...other } = props;
- var fancyClass = checked ? 'FancyChecked' : 'FancyUnchecked';
- var fancyTitle = checked ? 'X ' + title : 'O ' + title;
- return (
-
- );
-}
-```
-
-> NOTA:
->
-> L'ordine è importante. Mettendo il `{...other}` prima delle tue proprietà JSX ti assicuri che il consumatore del tuo componente non possa ridefinirle. Nell'esempio precedente, abbiamo garantito che l'elemento input sarà del tipo `"checkbox"`.
-
-## Proprietà Rest e Spread `...`
-
-Le proprietà Rest ti permettono di estrarre le proprietà residue di un oggetto in un nuovo oggetto. Vengono escluse tutte le altre proprietà elencate nel pattern di destrutturazione.
-
-Questa è un'implementazione sperimentale di una [proposta ES7](https://github.com/sebmarkbage/ecmascript-rest-spread).
-
-```javascript
-var { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
-x; // 1
-y; // 2
-z; // { a: 3, b: 4 }
-```
-
-> Nota:
->
-> Questa proposta ha raggiunto lo stadio 2 ed è attivata in modo predefinito in Babel. Vecchie versioni di Babel potrebbero richiedere l'abilitazione esplicita di questa trasformazione con `babel --optional es7.objectRestSpread`
-
-## Trasferire con Underscore
-
-Se non usi JSX, puoi usare una libreria per ottenere il medesimo pattern. Underscore supporta `_.omit` per omettere delle proprietà ed `_.extend` per copiare le proprietà in un nuovo oggetto.
-
-```javascript
-function FancyCheckbox(props) {
- var checked = props.checked;
- var other = _.omit(props, 'checked');
- var fancyClass = checked ? 'FancyChecked' : 'FancyUnchecked';
- return (
- React.DOM.div(_.extend({}, other, { className: fancyClass }))
- );
-}
-```
diff --git a/docs/docs/06-transferring-props.ja-JP.md b/docs/docs/06-transferring-props.ja-JP.md
deleted file mode 100644
index 3ea4055d63..0000000000
--- a/docs/docs/06-transferring-props.ja-JP.md
+++ /dev/null
@@ -1,151 +0,0 @@
----
-id: transferring-props
-title: propsの移譲
-permalink: docs/transferring-props-ja-JP.html
-prev: reusable-components-ja-JP.html
-next: forms-ja-JP.html
-
----
-
-
-コンポーネントを抽象的にラップすることはReactにおいて共通のパターンです。外のコンポーネントは単純なプロパティを表示し、中ではさらに複雑なインプリメンテーションの詳細を持つようになっています。
-
-以下のように、古いpropsと追加の値を[JSXの拡張属性](/react/docs/jsx-spread-ja-JP.html)を使ってマージすることができます。
-
-```javascript
-
-```
-
-JSXを使わない場合は、以下のように、ES6の `Object.assign` か Underscore の `_.extend` といったオブジェクトヘルパーを使うことができます。
-
-```javascript
-React.createElement(Component, Object.assign({}, this.props, { more: 'values' }));
-```
-
-以下のチュートリアルはベストプラクティスを提示しています。JSXや試験的なES7のシンタックスを使っています。
-
-## 手動での移動
-
-ほとんどの場合、プロパティを明確に子要素に渡すべきです。それは、内部のAPIのサブセットだけを外に出していることと、認識しているプロパティが動作することを保証します。
-
-```javascript
-function FancyCheckbox(props) {
- var fancyClass = props.checked ? 'FancyChecked' : 'FancyUnchecked';
- return (
-