diff --git a/docs/addons-ja-JP.html b/docs/addons-ja-JP.html new file mode 100644 index 0000000000..5b5dfc09e0 --- /dev/null +++ b/docs/addons-ja-JP.html @@ -0,0 +1,470 @@ + + + +
+ + +React.addons はReactのアプリケーションを作成する上で便利なユーティリティを置いておくための場所です。 それらは実験的なものであると考えられるべきです。 しかし、ゆくゆくはコアに入ってくるか、以下のような承認されたユーティリティとなるでしょう。
TransitionGroup や CSSTransitionGroupは多くの場合実行するのが簡単ではありません。例えば、コンポーネントの削除の前などは。LinkedStateMixinはユーザのフォームの入力データとコンポーネントのstateの間の調整を単純化します。cloneWithPropsはReactのコンポーネントのシャローコピーを作成したり、それらのpropsを変更したりします。createFragmentは外部のキー化された子要素のセットを作成します。updateはJavaScriptでイミュータブルなデータを扱うことを簡単にするヘルパーの関数です。PureRenderMixinは特定のシチュエーションでパフォーマンスを改善します。
+以下のアドオンはReactだけの開発版(縮小されていない版)です。
TestUtilsはテストケースを記述する単純なヘルパーです(縮小されていないビルドのみ)。
Perfはパフォーマンスを測り、どこを最適化するかのヒントを与えます。
アドオンを使うには、共通の react.js を使うよりも react-with-addons.js (とその縮小されたもの)を使ってください。
npmからReactのパッケージを使う際には、Reactと全てのアドオンを使うために require('react') を使う代わりに、単純に require('react/addons') を使ってください。
ReactはアニメーションのためにローレベルAPIとして ReactTransitionGroup アドオンコンポーネントと、基本的なCSSアニメーションとトランジションを簡単に実行するために ReactCSSTransitionGroup を提供しています。
ReactCSSTransitionGroup #ReactCSSTransitionGroup は ReactTransitionGroup に基づいており、ReactコンポーネントがDOMを作成したり、削除したりする際に、CSSのトランジションとアニメーションを行う簡単な方法です。これは、素晴らしいng-animateライブラリにインスパイアされています。
ReactCSSTransitionGroup は ReactTransitions のインターフェースです。アニメーションに関心がある全てのコンポーネントをラップする単純な要素です。以下が、リストのアイテムをフェードインやフェードアウトさせる例です。
var ReactCSSTransitionGroup = React.addons.CSSTransitionGroup;
+
+var TodoList = React.createClass({
+ getInitialState: function() {
+ return {items: ['hello', 'world', 'click', 'me']};
+ },
+ handleAdd: function() {
+ var newItems =
+ this.state.items.concat([prompt('Enter some text')]);
+ this.setState({items: newItems});
+ },
+ handleRemove: function(i) {
+ var newItems = this.state.items;
+ newItems.splice(i, 1);
+ this.setState({items: newItems});
+ },
+ render: function() {
+ var items = this.state.items.map(function(item, i) {
+ return (
+ <div key={item} onClick={this.handleRemove.bind(this, i)}>
+ {item}
+ </div>
+ );
+ }.bind(this));
+ return (
+ <div>
+ <button onClick={this.handleAdd}>Add Item</button>
+ <ReactCSSTransitionGroup transitionName="example">
+ {items}
+ </ReactCSSTransitionGroup>
+ </div>
+ );
+ }
+});
+++ +注意: +もし子要素を1つだけレンダリングするとしても、
+ReactCSSTransitionGroupの全ての子要素に提供しなければなりません。これが、Reactが、子要素が作成されているか、削除されたか、あるいはそのままであるか判断する方法です。
このコンポーネントでは、 ReactCSSTransitionGroup に新しいアイテムが追加された次の瞬間に、 example-enter CSSクラスと example-enter-active CSSクラスを得ます。これは、 transitionName propに基づく習慣です。
これらのクラスはCSSアニメーションやトランジションのトリガーとして使うことができます。例えば、以下のようにして、このCSSを加え、新しいリストアイテムを加えてみましょう。
+.example-enter {
+ opacity: 0.01;
+ transition: opacity .5s ease-in;
+}
+
+.example-enter.example-enter-active {
+ opacity: 1;
+}
+アイテムを削除しようとしたときに、 ReactCSSTransitionGroup がDOMの中にそれを保持していることに気づくでしょう。縮小化されていないReactのビルドとアドオンを使っているならば、Reactがアニメーションやトランジションが起こることを予期しているという警告が出るでしょう。これは、 ReactCSSTransitionGroup がアニメーションが終わるまでDOM要素をページに保持し続けるからです。以下のCSSを加えてみましょう。
.example-leave {
+ opacity: 1;
+ transition: opacity .5s ease-in;
+}
+
+.example-leave.example-leave-active {
+ opacity: 0.01;
+}
+ReactCSSTransitionGroup は transitionAppear というオプションのプロパティを提供します。コンポーネントの最初のマウントの際に、更なるトランジションのフェーズを加えるためです。一般的には、 transitionAppear が false である最初のマウントの際にはトランジションのフェーズはありません。 transitionAppear プロパティを値が true である状態で渡す以下の例を見てみましょう。
render: function() {
+ return (
+ <ReactCSSTransitionGroup transitionName="example" transitionAppear={true}>
+ <h1>Fading at Initial Mount</h1>
+ </ReactCSSTransitionGroup>
+ );
+ }
+最初のマウントの間、 ReactCSSTransitionGroup は example-appear CSSクラスを得て、次の瞬間に example-appear-active CSSクラスを加えます。
.example-appear {
+ opacity: 0.01;
+ transition: opacity .5s ease-in;
+}
+
+.example-appear.example-appear-active {
+ opacity: 1;
+}
+最初のマウントの際には、 ReactCSSTransitionGroup の全ての子要素は appear しますが、 enter はしません。一方、存在する ReactCSSTransitionGroup に後から加えられた子要素は全て enter しますが、 appear はしません。
++注意: +
+transitionAppearプロパティはバージョン0.13でReactCSSTransitionGroupに加えられました。後方互換性を維持するために、デフォルトの値はfalseに指定されています。
子要素にトランジションを適用するためには、 ReactCSSTransitionGroup はすでにDOMにマウントされているか、 transitionAppear プロパティに true がセットされている必要があります。以下の例は動きません。 ReactCSSTransitionGroup が新しいアイテムとともにマウントされており、新しいマウントがマウントされていないからです。これと上のはじめに とで違いを比較してみてください。
render: function() {
+ var items = this.state.items.map(function(item, i) {
+ return (
+ <div key={item} onClick={this.handleRemove.bind(this, i)}>
+ <ReactCSSTransitionGroup transitionName="example">
+ {item}
+ </ReactCSSTransitionGroup>
+ </div>
+ );
+ }, this);
+ return (
+ <div>
+ <button onClick={this.handleAdd}>Add Item</button>
+ {items}
+ </div>
+ );
+ }
+上の例では、 ReactCSSTransitionGroup にアイテムのリストをレンダリングしました。しかし、 ReactCSSTransitionGroup の子要素は1個や0個のアイテムになり得ます。単一の要素が作成や削除のアニメーションを可能にします。同様に、現在の要素を置き換える新しい要素をアニメーションできます。例えば、以下のように、1つの画像でカルーセルを実行できます。
var ReactCSSTransitionGroup = React.addons.CSSTransitionGroup;
+
+var ImageCarousel = React.createClass({
+ propTypes: {
+ imageSrc: React.PropTypes.string.isRequired
+ },
+ render: function() {
+ return (
+ <div>
+ <ReactCSSTransitionGroup transitionName="carousel">
+ <img src={this.props.imageSrc} key={this.props.imageSrc} />
+ </ReactCSSTransitionGroup>
+ </div>
+ );
+ }
+});
+もししたいならば、 enter や leave のアニメーションを無効にすることもできます。例えば、 enter アニメーションは行いたいが、 leave のアニメーションは行いたくない場合があるでしょう。しかし、 ReactCSSTransitionGroup はDOMのノードが削除される前にアニメーションが終わるのを待ちます。ReactCSSTransitionGroup がそれらのアニメーションを無効化するために、 transitionEnter={false} や transitionLeave={false} といったプロパティを追加することができます。
++注意: +
+ReactCSSTransitionGroupを使う際には、コンポーネントがトランジションが終わったことを検知したり、アニメーション関連でさらに複雑なロジックを実行するといったことはできません。更に細かな制御を求める場合は、トランジションをカスタムするために必要なフックを提供するローレベルのReactTransitionGroupAPIを使用できます。
ReactTransitionGroup #ReactTransitionGroup はアニメーションの基盤です。 React.addons.TransitionGroup と同じくらい簡単に使用できます。これによって(上記の例のように)、宣言的に子要素が追加されたり削除されたりするときに、それらの上で特別なライフサイクルのフックが呼ばれます。
componentWillAppear(callback) #このメソッドは TransitionGroup の中で最初にマウントされるコンポーネントのために componentDidMount() と同時に呼ばれます。これは、 callback が呼ばれるまで、他のアニメーションが発生するのをブロックします。これは、 TransitionGroup の最初のレンダリングのときにのみ呼ばれます。
componentDidAppear() #componentWillAppear が呼ばれて渡される callback 関数の後に呼ばれます。
componentWillEnter(callback) #これは、存在する TransitionGroup に追加されるコンポーネントのために、 componentDidMount() と同時に呼ばれます。これは、 callback が呼ばれるまで、他のアニメーションが発生するのをブロックします。これは、 TransitionGroup の最初のレンダリングのときには呼ばれません。
componentDidEnter() #componentWillEnter が呼ばれて渡される callback 関数の後に呼ばれます。
componentWillLeave(callback) #これは、 ReactTransitionGroup から子要素が削除されたときに呼ばれます。子要素が削除されても、 ReactTransitionGroup は callback が呼ばれるまでDOMの中に子要素を保持し続けます。
componentDidLeave() #これは、 willLeave の callback が呼ばれた際に呼ばれます( componentWillUnmount と同時です)。
デフォルトで、 ReactTransitionGroup は span としてレンダリングされます。この動きは、 component プロパティによって変更できます。例えば、 <ul> をレンダリングしたい場合は以下のようになります。
<ReactTransitionGroup component="ul">
+ ...
+</ReactTransitionGroup>
+Reactがレンダリングできる全てのDOMコンポーネントが使用できます。しかし、 component はDOMコンポーネントである必要はありません。あなたが求めているどんなReactのコンポーネントにもなり得ます。あなた自身が記述したものにもです!
++ +注意: +v0.12以前では、DOMのコンポーネントを使用する際には、
+componentプロパティがReact.DOM.*を参照している必要がありました。コンポーネントが単純にReact.createElementから渡されていたからです。これは今は文字列である必要があります。複合的なコンポーネントは複合的なものを渡す必要があります。
全ての付加的な、ユーザー定義のプロパティはレンダリングされたコンポーネントのプロパティになります。例えば、以下はCSSクラスとともに <ul> をレンダリングする方法です。
<ReactTransitionGroup component="ul" className="animated-list">
+ ...
+</ReactTransitionGroup>
+You can use these classes to trigger a CSS animation or transition. For example, try adding this CSS and adding a new list item:
.example-enter {
opacity: 0.01;
- transition: opacity .5s ease-in;
}
.example-enter.example-enter-active {
opacity: 1;
+ transition: opacity .5s ease-in;
}
You'll notice that when you try to remove an item ReactCSSTransitionGroup keeps it in the DOM. If you're using an unminified build of React with add-ons you'll see a warning that React was expecting an animation or transition to occur. That's because ReactCSSTransitionGroup keeps your DOM elements on the page until the animation completes. Try adding this CSS:
.example-leave {
opacity: 1;
- transition: opacity .5s ease-in;
}
.example-leave.example-leave-active {
opacity: 0.01;
+ transition: opacity .5s ease-in;
}
ReactCSSTransitionGroup provides the optional prop transitionAppear, to add an extra transition phase at the initial mount of the component. There is generally no transition phase at the initial mount as the default value of transitionAppear is false. Following an example which passes the prop transitionAppear with the value true.
Prior to v0.12, when using DOM components, the component prop needed to be a reference to React.DOM.*. Since the component is simply passed to React.createElement, it must now be a string. Composite components must pass the factory.
Any additional, user-defined, properties will become properties of the rendered component. For example, here's how you would render a <ul> with css class:
Any additional, user-defined, properties will become properties of the rendered component. For example, here's how you would render a <ul> with CSS class:
<ReactTransitionGroup component="ul" className="animated-list">
...
</ReactTransitionGroup>
diff --git a/docs/class-name-manipulation-ja-JP.html b/docs/class-name-manipulation-ja-JP.html
new file mode 100644
index 0000000000..ee3fe34616
--- /dev/null
+++ b/docs/class-name-manipulation-ja-JP.html
@@ -0,0 +1,499 @@
+
+
+
+
+
+
+ クラス名の操作 | React
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ クラス名の操作
+ Edit on GitHub
+
+
+
+
+注意:
+このモジュールは現在JedWatson/classnamesに独立して存在しており、Reactは変更を検知していません。したがって、こちらは将来削除される予定です。
+
+
+classSet() はDOMの class 文字列を簡単に操作するすっきりとしたユーティリティです。
+
+以下は、 classSet() を使用しない共通なシナリオと解決策です。
+// `<Message />` などの中のReactコンポーネント
+render: function() {
+ var classString = 'message';
+ if (this.props.isImportant) {
+ classString += ' message-important';
+ }
+ if (this.props.isRead) {
+ classString += ' message-read';
+ }
+ // 'message message-important message-read'
+ return <div className={classString}>Great, I'll be there.</div>;
+}
+
+上記は、クラス名を文字列として渡しているので、面倒で、読みにくく、エラーが発生しやすくなります。以下のように、 classSet() を使用するとこの問題が解決します。
+render: function() {
+ var cx = React.addons.classSet;
+ var classes = cx({
+ 'message': true,
+ 'message-important': this.props.isImportant,
+ 'message-read': this.props.isRead
+ });
+ // 同様に最終的には文字列になりますが、クリアにはなります
+ return <div className={classes}>Great, I'll be there.</div>;
+}
+
+classSet() を使用する際には、キーと、必要であったり、必要でないCSSのクラス名をオブジェクトとして渡してください。値が真であるものはキーとなり、最終的には文字列の一部になります。
+
+classSet() もまた、以下のように連結した文字列の引数としてクラス名を渡します。
+render: function() {
+ var cx = React.addons.classSet;
+ var importantModifier = 'message-important';
+ var readModifier = 'message-read';
+ var classes = cx('message', importantModifier, readModifier);
+ // 最終的な文字列は 'message message-important message-read'
+ return <div className={classes}>Great, I'll be there.</div>;
+}
+
+文字列の連結を手で書くのはやめましょう!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/displaying-data-ja-JP.html b/docs/displaying-data-ja-JP.html
index bd49b72cc2..ab433c87e4 100644
--- a/docs/displaying-data-ja-JP.html
+++ b/docs/displaying-data-ja-JP.html
@@ -410,6 +410,7 @@
<!DOCTYPE html>
<html>
<head>
+ <meta charset="UTF-8" />
<title>Hello React</title>
<script src="https://fb.me/react-0.13.3.js"></script>
<script src="https://fb.me/JSXTransformer-0.13.3.js"></script>
@@ -443,7 +444,7 @@
);
}, 500);
リアクティブなアップデート #
-hello-react.html をウェブブラウザで開き、テキストフィールドにあなたの名前を入力してください。ReactはUIのうち、時間の文字列しか変更しないことに注意してください。あなたがテキストフィールドに入力したものは残っています。あなたはそういったコードを書いていないのにも関わらずです。Reactはあなたのことを理解しており、正しいことを行います。
+hello-react.html をウェブブラウザで開き、テキストフィールドにあなたの名前を入力してください。ReactはUIのうち、時間の文字列しか変更しないことに注意してください。あなたがテキストフィールドに入力したものは残っています。あなたはそういったコードを書いていないのにも関わらずです。Reactはあなたのことを理解しており、正しいことを行います。
このことについて私たちが理解できる方法は、Reactは必要になるまで、DOMの操作を行わないということです。 Reactは、DOMの変化を表現し、あなたにもっとも効率的なDOMの変化を見積もるために早い、内部のモックのDOMを使っています。
@@ -463,7 +464,7 @@
上記のことを簡単に行うために、私たちはReactのツリーノードを構築するためのとても単純で、 オプショナルな HTMLに似たシンタックスを加えました。
-JSXはHTMLのシンタックスを使ってJavaScriptのオブジェクトを構築するのを可能にします。 純粋にJavaScriptを使ってReactでリンクを構築するには、以下のように書きます。
+JSXはHTMLのシンタックスを使ってJavaScriptのオブジェクトを構築するのを可能にします。 純粋にJavaScriptを使ってReactでリンクを構築するには、以下のように書きます。
React.createElement('a', {href: 'https://facebook.github.io/react/'}, 'Hello!')
diff --git a/docs/displaying-data-ko-KR.html b/docs/displaying-data-ko-KR.html
index 6c7472f707..84900d11d5 100644
--- a/docs/displaying-data-ko-KR.html
+++ b/docs/displaying-data-ko-KR.html
@@ -410,6 +410,7 @@
<!DOCTYPE html>
<html>
<head>
+ <meta charset="UTF-8" />
<title>Hello React</title>
<script src="https://fb.me/react-0.13.3.js"></script>
<script src="https://fb.me/JSXTransformer-0.13.3.js"></script>
diff --git a/docs/displaying-data-zh-CN.html b/docs/displaying-data-zh-CN.html
index 06b27b115b..087d5abfed 100644
--- a/docs/displaying-data-zh-CN.html
+++ b/docs/displaying-data-zh-CN.html
@@ -410,6 +410,7 @@
<!DOCTYPE html>
<html>
<head>
+ <meta charset="UTF-8" />
<title>Hello React</title>
<script src="https://fb.me/react-0.13.3.js"></script>
<script src="https://fb.me/JSXTransformer-0.13.3.js"></script>
@@ -461,7 +462,7 @@
我们得出解决这个问题最好的方案是通过 JavaScript 直接生成模板,这样你就可以用一个真正语言的所有表达能力去构建用户界面。为了使这变得更简单,我们做了一个非常简单、可选类似 HTML 语法 ,通过函数调用即可生成模板的编译器,称为 JSX。
-JSX 让你可以用 HTML 语法去写 JavaScript 函数调用 为了在 React 生成一个链接,通过纯 JavaScript 你可以这么写:
+JSX 让你可以用 HTML 语法去写 JavaScript 函数调用 为了在 React 生成一个链接,通过纯 JavaScript 你可以这么写:
React.createElement('a', {href: 'https://facebook.github.io/react/'}, 'Hello React!')。
diff --git a/docs/displaying-data.html b/docs/displaying-data.html
index 2cd9af65ae..3ac549d1e3 100644
--- a/docs/displaying-data.html
+++ b/docs/displaying-data.html
@@ -410,6 +410,7 @@
<!DOCTYPE html>
<html>
<head>
+ <meta charset="UTF-8" />
<title>Hello React</title>
<script src="https://fb.me/react-0.13.3.js"></script>
<script src="https://fb.me/JSXTransformer-0.13.3.js"></script>
diff --git a/docs/forms-ja-JP.html b/docs/forms-ja-JP.html
index 13ee8c614a..b7a2ecaa57 100644
--- a/docs/forms-ja-JP.html
+++ b/docs/forms-ja-JP.html
@@ -462,7 +462,7 @@
return <input type="text" />;
}
-上記は、空の値で最初は始まるinputをレンダリングします。どのようなユーザのinputも即座にレンダリングされた要素によって反映されます。値の更新を検知したいなら、 onChange イベントを、制御されたコンポーネントと同様に使用することができます。
+上記は、空の値で最初は始まるinputをレンダリングします。どのようなユーザのinputも即座にレンダリングされた要素によって反映されます。値の更新を検知したいなら、 onChange イベントを、制御されたコンポーネントと同様に使用することができます。
コンポーネントを空ではない値で初期化したいなら、 defaultValue propを提供することができます。例えば、
render: function() {
diff --git a/docs/forms.html b/docs/forms.html
index 0e0681afc1..b2830b062a 100644
--- a/docs/forms.html
+++ b/docs/forms.html
@@ -464,7 +464,7 @@
}
This will render an input that starts off with an empty value. Any user input will be immediately reflected by the rendered element. If you wanted to listen to updates to the value, you could use the onChange event just like you can with controlled components.
-
+Default Value #
If you want to initialize the component with a non-empty value, you can supply a defaultValue prop. For example:
render: function() {
return <input type="text" defaultValue="Hello!" />;
@@ -473,6 +473,12 @@
This example will function much like the Controlled Components example above.
Likewise, <input> supports defaultChecked and <select> supports defaultValue.
+
+
+Note:
+
+The defaultValue and defaultChecked props are only used during initial render. If you need to update the value in a subsequent render, you will need to use a controlled component.
+
Advanced Topics #
Why Controlled Components? #
Using form components such as <input> in React presents a challenge that is absent when writing traditional form HTML. For example, in HTML:
<input type="text" name="title" value="Untitled" />
diff --git a/docs/getting-started-ja-JP.html b/docs/getting-started-ja-JP.html
index dab7451ff6..a09e760dba 100644
--- a/docs/getting-started-ja-JP.html
+++ b/docs/getting-started-ja-JP.html
@@ -424,6 +424,7 @@
<!DOCTYPE html>
<html>
<head>
+ <meta charset="UTF-8" />
<title>Hello React!</title>
<script src="build/react.js"></script>
<script src="build/JSXTransformer.js"></script>
@@ -466,6 +467,7 @@
<!DOCTYPE html>
<html>
<head>
+ <meta charset="UTF-8" />
<title>Hello React!</title>
<script src="build/react.js"></script>
<!-- JSXTransformer は必要ありません! -->
diff --git a/docs/getting-started-ko-KR.html b/docs/getting-started-ko-KR.html
index 40f1434a85..d3f6f2c154 100644
--- a/docs/getting-started-ko-KR.html
+++ b/docs/getting-started-ko-KR.html
@@ -424,6 +424,7 @@
<!DOCTYPE html>
<html>
<head>
+ <meta charset="UTF-8" />
<title>Hello React!</title>
<script src="build/react.js"></script>
<script src="build/JSXTransformer.js"></script>
@@ -466,6 +467,7 @@
<!DOCTYPE html>
<html>
<head>
+ <meta charset="UTF-8" />
<title>Hello React!</title>
<script src="build/react.js"></script>
<!-- JSXTransformer는 이제 불필요합니다! -->
diff --git a/docs/getting-started-zh-CN.html b/docs/getting-started-zh-CN.html
index b4d1a725a9..e64256e4de 100644
--- a/docs/getting-started-zh-CN.html
+++ b/docs/getting-started-zh-CN.html
@@ -424,6 +424,7 @@
<!DOCTYPE html>
<html>
<head>
+ <meta charset="UTF-8" />
<title>Hello React!</title>
<script src="build/react.js"></script>
<script src="build/JSXTransformer.js"></script>
@@ -466,6 +467,7 @@
<!DOCTYPE html>
<html>
<head>
+ <meta charset="UTF-8" />
<title>Hello React!</title>
<script src="build/react.js"></script>
<!-- 不需要 JSXTransformer! -->
diff --git a/docs/getting-started.html b/docs/getting-started.html
index c5f667efb7..49bbfd3232 100644
--- a/docs/getting-started.html
+++ b/docs/getting-started.html
@@ -424,6 +424,7 @@
<!DOCTYPE html>
<html>
<head>
+ <meta charset="UTF-8" />
<title>Hello React!</title>
<script src="build/react.js"></script>
<script src="build/JSXTransformer.js"></script>
@@ -449,7 +450,9 @@
Then reference it from helloworld.html:
<script type="text/jsx" src="src/helloworld.js"></script>
-
Offline Transform #
+
+Note that some browsers (Chrome, e.g.) will fail to load the file unless it's served via HTTP.
+Offline Transform #
First install the command-line tools (requires npm):
npm install -g react-tools
@@ -466,6 +469,7 @@
<!DOCTYPE html>
<html>
<head>
+ <meta charset="UTF-8" />
<title>Hello React!</title>
<script src="build/react.js"></script>
<!-- No need for JSXTransformer! -->
@@ -478,7 +482,7 @@
Want CommonJS? #
If you want to use React with browserify, webpack, or another CommonJS-compatible module system, just use the react npm package. In addition, the jsx build tool can be integrated into most packaging systems (not just CommonJS) quite easily.
Next Steps #
-Check out the tutorial and the other examples in the starter kit's examples directory to learn more.
+Check out the tutorial and the other examples in the starter kit's examples directory to learn more.
We also have a wiki where the community contributes with workflows, UI-components, routing, data management etc.
diff --git a/docs/interactivity-and-dynamic-uis-ja-JP.html b/docs/interactivity-and-dynamic-uis-ja-JP.html
index 43736b3baf..1a2bf7dbad 100644
--- a/docs/interactivity-and-dynamic-uis-ja-JP.html
+++ b/docs/interactivity-and-dynamic-uis-ja-JP.html
@@ -434,7 +434,7 @@
オートバインディング: JavaScriptでコールバックを作成するときには、普通は this の値が正しくなるように、インスタンスにメソッドをはっきりとバインドする必要があります。
Reactでは、全てのメソッドが自動でコンポーネントのインスタンスにバインドされます。ReactはCPUとメモリを効率的に使えるように、バインドするメソッドを持っています。これによって、タイピングの量を少なくすることもできます!
-イベントの委譲: Reactは実際はノード自体にイベントハンドラをアタッチはしません。Reactを立ち上げる時、1つのイベントリスナを使って最上位で全てのイベントをリスニングし始めます。コンポーネントがマウントされたり、アンマウントされた時は、イベントハンドラは内部のマッピングを単純に加えたり減らしたりします。イベントが起こった時には、Reactはこのマッピングを使ってどのようにディスパッチするかを知っています。マッピングの中にイベントハンドラが無い場合は、Reactのイベントハンドラは何も行いません。なぜこれの速度が早いかについて詳しく知るためには、David Walshの素晴らしいブログの投稿をご覧ください。
+イベントの委譲: Reactは実際はノード自体にイベントハンドラをアタッチはしません。Reactを立ち上げる時、1つのイベントリスナを使って最上位で全てのイベントをリスニングし始めます。コンポーネントがマウントされたり、アンマウントされた時は、イベントハンドラは内部のマッピングを単純に加えたり減らしたりします。イベントが起こった時には、Reactはこのマッピングを使ってどのようにディスパッチするかを知っています。マッピングの中にイベントハンドラが無い場合は、Reactのイベントハンドラは何も行いません。なぜこれの速度が速いかについて詳しく知るためには、David Walshの素晴らしいブログの投稿をご覧ください。
コンポーネントは静的なマシーンに過ぎない #
ReactはUIをただの静的なマシーンと考えます。UIがたくさんのstateの中にあり、それらのstateをレンダリングするものだと考えることで、UIの一貫性を保ちやすくなります。
diff --git a/docs/more-about-refs-ja-JP.html b/docs/more-about-refs-ja-JP.html
new file mode 100644
index 0000000000..4e8bfcb531
--- /dev/null
+++ b/docs/more-about-refs-ja-JP.html
@@ -0,0 +1,571 @@
+
+
+
+
+
+
+ 参照についての詳細 | React
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 参照についての詳細
+ Edit on GitHub
+
+
+
+ renderメソッドからUIの構成をリターンした後、あなたは「リーチアウト」を見て、renderから返ってきたコンポーネントのインスタンスの上でメソッドを実行するでしょう。多くの場合、アプリケーションにおいて、データフローを作成することは必要ではありません。リアクティブなデータフローは常に最新の props が render() から出力されたそれぞれの子要素に送られたことを保証するからです。しかし、まだ必要であったり、利益をもたらすケースもあります。
+
+'' という空の文字列でその値をアップデートした後にフォーカスするということを <input /> 要素(インスタンスのサブ階層に存在します)に伝えたいという場合を考えましょう。
+ var App = React.createClass({
+ getInitialState: function() {
+ return {userInput: ''};
+ },
+ handleChange: function(e) {
+ this.setState({userInput: e.target.value});
+ },
+ clearAndFocusInput: function() {
+ this.setState({userInput: ''}); // inputをクリアします
+ // ここで、<input /> にフォーカスさせたいです!
+ },
+ render: function() {
+ return (
+ <div>
+ <div onClick={this.clearAndFocusInput}>
+ Click to Focus and Reset
+ </div>
+ <input
+ value={this.state.userInput}
+ onChange={this.handleChange}
+ />
+ </div>
+ );
+ }
+ });
+
+この例では、どうにかしてinputに何かを「伝え」たいということに着目してください。何かというのは、propsから推測できるものではありません。このケースでは、inputが今フォーカスされるべきであるということを「伝え」たいのです。しかし、いくつか問題があります。render() で返されるものは実際の「子供の」要素ではありません。しかし、特別なインスタンスにおいて子要素の 説明 を行うよりかは、スナップショットを見ていったほうがいいでしょう。
+
+
+注意:
+render() からリターンされるものは 実際に レンダリングされた子要素のインスタンスではないと覚えておいてください。 render() からリターンされるものは、ある特定の時点においてのコンポーネントの副階層にある単なる子要素のインスタンスの 説明 に過ぎません。
+
+
+これは、 render() からリターンされる何かを「保持し続ける」ことはできないことを意味します。そして、それは何かしら意味のあることであると予測できます。
+ // 反例: このようには記述しないでください!
+ render: function() {
+ var myInput = <input />; // このinputの上にあるメソッドを未来のいつかの
+ this.rememberThisInput = myInput; // タイミングで呼ぼうとしています!いえいっ!
+ return (
+ <div>
+ <div>...</div>
+ {myInput}
+ </div>
+ );
+ }
+
+この反例では、 <input /> は単に <input /> の 説明 に過ぎず、この説明は <input /> の 現実の バッキングインスタンス を作るために使われます。
+
+では、inputの 現実の バッキングインスタンスについて、どのように話していきましょうか?
+参照の文字列属性 #
+Reactは render() からの出力であるコンポーネントであれば何でもアタッチできるとても特別なプロパティをサポートしています。この特別なプロパティは render() からのリターンである バッキングインスタンス に対応したものに参照することを許可します。これはどのタイミングにおいても、固有のインスタンスであることを保証されています。
+
+これは以下のように単純です。
+
+
+- 以下のように、
render からのリターンであれば何でも ref 属性をアサインする。
+
+ <input ref="myInput" />
+
+
+- いくつかの他のコードは(一般的にイベントハンドラのコード)、以下にあるように
this.refs を通して バッキングインスタンス にアクセスします。
+
+ this.refs.myInput
+
+React.findDOMNode(this.refs.myInput) を呼ぶことで、コンポーネントのDOMノードに直接アクセスできる。
+参照のコールバック属性 #
+ref 属性は名前の代わりのコールバック関数になり得ます。このコールバックはコンポーネントがマウントされた直後に実行されます。参照されたコンポーネントはパラメータとして渡され、コールバック関数はコンポーネントを即座に使用するか、または将来使用するために参照を保存します(またはその両方を行います)。
+
+これは、以下のように、 render でリターンされてきたものに ref 属性をアサインするのと同じくらい簡単です。
+ <input ref={ function(component){ React.findDOMNode(component).focus();} } />
+
完全な例 #
var App = React.createClass({
+ getInitialState: function() {
+ return {userInput: ''};
+ },
+ handleChange: function(e) {
+ this.setState({userInput: e.target.value});
+ },
+ clearAndFocusInput: function() {
+ // inputをクリアする
+ this.setState({userInput: ''}, function() {
+ // このコードはコンポーネントが再度レンダリングされた後に実行されます。
+ React.findDOMNode(this.refs.theInput).focus(); // どーん!フォーカスされました!
+ });
+ },
+ render: function() {
+ return (
+ <div>
+ <div onClick={this.clearAndFocusInput}>
+ Click to Focus and Reset
+ </div>
+ <input
+ ref="theInput"
+ value={this.state.userInput}
+ onChange={this.handleChange}
+ />
+ </div>
+ );
+ }
+ });
+
+この例では、レンダリング関数は <input /> インスタンスの説明をリターンします。しかし、実際のインスタンスは this.refs.theInput を通してアクセスされます。 ref="theInput" を持つ子要素のコンポーネントが render からリターンされる限り、 this.refs.theInput は固有のインスタンスにアクセスするでしょう。これは <Typeahead ref="myTypeahead" /> のような高階層の(DOMでない)コンポーネントでも同様に動きます。
+要約 #
+リアクティブな props と state を通してのストリーミングのアクセスは便利とは言えないため、参照は特定の子要素のインスタンスにメッセージを送るための素晴らしい方法です。しかし、それらは、アプリケーションを通したデータフローの抽象化につながるわけではありません。デフォルトで、リアクティブなデータフローを使ってください。そして、ユースケースのために ref を保存するのは本質的にはリアクティブではありません。
+利益: #
+
+- コンポーネントクラス(例えば、Typeaheadのリセットメソッドのようなもの)にパブリックなメソッドを定義できる。また、参照(例えば、
this.refs.myTypeahead.reset() のように)を通してそれらのパブリックなメソッドを呼べる。
+- DOMの計測を行うことは大体いつも
<input /> のような「ネイティブの」コンポーネントや React.findDOMNode(this.refs.myInput) を通した根本のDOMノードにアクセスすることを必要とします。参照は、こういったことを期待通りに行う唯一の実用的な方法です。
+- 参照は自動的に管理されます!もし子要素が削除されたら、その参照もまた削除されます。メモリに関しての心配は要りません(あなた自身が参照を維持するために何かおかしなことを行っていなければ)。
+
+警告: #
+
+- 決して コンポーネントのレンダリングメソッドの中の参照にアクセスしてはいけません。たとえコンポーネントのレンダリングメソッドのいずれかがコールスタックの中のどこかで動いているとしても。
+- もしGoogle Closure Compilerのクラッシュからの回復を守りたいなら、文字列として指定されたプロパティとしてアクセスしてはいけないことに気をつけてください。これは、
ref="myRefString" として参照が定義されている場合は、 this.refs['myRefString'] を使ってアクセスしなければいけないことを意味します。
+- まだReactでプログラムを書いたことがない場合は、アプリケーションで「何かを起こす」ために参照を使おうとするでしょう。もしそのケースだった場合は、時間をかけて
state がコンポーネントの階層のどこで保持されるべきか批評的に考えてください。多くの場合は、そのstateを「保持する」ための固有の場所が階層の高いレベルにあることがクリアになります。そのstateをその場所に配置することはよく「何かを起こす」ために ref を使うための願望を排除します。代わりに、データフローは普通、目標を達成します。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/more-about-refs.html b/docs/more-about-refs.html
index 3362966ae2..62ef45c7b9 100644
--- a/docs/more-about-refs.html
+++ b/docs/more-about-refs.html
@@ -508,7 +508,7 @@
}
});
-In this example, our render function returns a description of an <input /> instance. But the true instance is accessed via this.refs.theInput. As long as a child component with ref="theInput" is returned from render, this.refs.theInput will access the proper instance. This even works on higher level (non-DOM) components such as <Typeahead ref="myTypeahead" />.
+In this example, our render function returns a description of an <input /> instance. But the true instance is accessed via this.refs.theInput. As long as a child component with ref="theInput" is returned from render, this.refs.theInput will access the proper instance. This even works on higher level (non-DOM) components such as <Typeahead ref="myTypeahead" />.
Summary #
Refs are a great way to send a message to a particular child instance in a way that would be inconvenient to do via streaming Reactive props and state. They should, however, not be your go-to abstraction for flowing data through your application. By default, use the Reactive data flow and save refs for use cases that are inherently non-reactive.
Benefits: #
diff --git a/docs/multiple-components.html b/docs/multiple-components.html
index 5bb2869fe2..87976b0963 100644
--- a/docs/multiple-components.html
+++ b/docs/multiple-components.html
@@ -511,8 +511,7 @@
);
}
});
-
-// Correct :)
+
// Correct :)
var ListItemWrapper = React.createClass({
render: function() {
return <li>{this.props.data.text}</li>;
diff --git a/docs/tooling-integration-ja-JP.html b/docs/tooling-integration-ja-JP.html
new file mode 100644
index 0000000000..b0ded5a435
--- /dev/null
+++ b/docs/tooling-integration-ja-JP.html
@@ -0,0 +1,473 @@
+
+
+
+
+
+
+ インテグレーションツール | React
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ インテグレーションツール
+ Edit on GitHub
+
+
+
+ 全てのプロジェクトがJavaScriptをビルドしたりデプロイするのに様々なシステムを使用しています。私たちはReactをできるだけ環境不問にしようとしています。
+React #
CDNにホストされたReact #
+ダウンロードページでCDNにホストされたバージョンのReactが提供されています。それらの、事前にビルドされたファイルはUMDモジュールフォーマットを使用しています。簡単な <script> タグを使ってそれらを導入することで、あなたの環境でグローバルに React を使うことができます。CommonJSの外や、AMDの環境でも、それは動作するでしょう。
+masterを使う #
+GitHubリポジトリに master からビルドする説明が書いてあります。build/modules の下にCommonJSモジュールのツリーをビルドします。それらは、どんな環境やCommonJSがサポートされているパッケージングツールでも導入できます。
+JSX #
ブラウザ上でのJSXの変換 #
+JSXを使用したい場合、ダウンロードページに開発のためにブラウザ上でのJSXトランスフォーマーを提供しています。単純に <script type="text/jsx"> をインクルードすることでJSXトランスフォーマーを使用できます。
+
+
+注意:
+ブラウザ上でのJSXトランスフォーマーをとても大きく、避けることのできるクライアントサイドの計算になりかねません。プロダクションでは使わないでください。詳細は次のセクションをご覧ください。
+
+プロダクションで使う場合:事前にコンパイルされたJSX #
+npmがインストールされている場合、コマンドラインの jsx ツールは単純に npm install -g react-tools コマンドを流せばインストールできます。このツールはJSXを使用しているファイルを直接ブラウザ上で動く生のJavaScriptファイルに変換します。また、ディレクトリをウォッチして、ファイルが変更されたら自動的に変換を行います。例えば、次のようなコマンドで。 jsx --watch src/ build/
+
+デフォルトで、拡張子が .js のJSXファイルは変換されます。拡張子が .jsx のファイルを変換するには jsx --extension jsx src/ build/ コマンドを使用してください。
+
+このツールの使用方法についての詳細の情報については、 jsx --help コマンドを使用してください。
+役に立つオープンソースのプロジェクト #
+オープンソースコミュニティがJSXをいくつかのエディタやビルドシステムで使用するためのツールを作成しました。一覧はJSXのインテグレーションを参照してください。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/tutorial-ja-JP.html b/docs/tutorial-ja-JP.html
index 07e6a60857..b708809f9a 100644
--- a/docs/tutorial-ja-JP.html
+++ b/docs/tutorial-ja-JP.html
@@ -433,6 +433,7 @@
<!DOCTYPE html>
<html>
<head>
+ <meta charset="UTF-8" />
<title>Hello React</title>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/0.13.3/react.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/0.13.3/JSXTransformer.js"></script>
@@ -577,6 +578,7 @@
まず最初に、サードパーティ製の Showdown ライブラリをアプリケーションに追加します。 Showdown は Markdown テキストを生の HTML に変換する JavaScript ライブラリです。 既にある head タグの内側に script タグを書き込み、以下のように Showdown を読み込ませます。
<!-- index.html -->
<head>
+ <meta charset="UTF-8" />
<title>Hello React</title>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/0.13.3/react.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/0.13.3/JSXTransformer.js"></script>
diff --git a/docs/tutorial-ko-KR.html b/docs/tutorial-ko-KR.html
index c4fb73151d..1538604656 100644
--- a/docs/tutorial-ko-KR.html
+++ b/docs/tutorial-ko-KR.html
@@ -433,6 +433,7 @@
<!DOCTYPE html>
<html>
<head>
+ <meta charset="UTF-8" />
<title>Hello React</title>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/0.13.3/react.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/0.13.3/JSXTransformer.js"></script>
@@ -579,6 +580,7 @@
먼저 서드파티 라이브러리인 marked를 애플리케이션에 추가합니다. 이 JavaScript 라이브러리는 Markdown 텍스트를 HTML 문법으로 변환해줍니다. head 태그안에 스크립트 태그를 추가해 주세요. (React playground에는 이미 포함되어 있습니다):
<!-- index.html -->
<head>
+ <meta charset="UTF-8" />
<title>Hello React</title>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/0.13.3/react.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/0.13.3/JSXTransformer.js"></script>
diff --git a/docs/tutorial.html b/docs/tutorial.html
index a00438797a..878f64b668 100644
--- a/docs/tutorial.html
+++ b/docs/tutorial.html
@@ -433,6 +433,7 @@
<!DOCTYPE html>
<html>
<head>
+ <meta charset="UTF-8" />
<title>Hello React</title>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/0.13.3/react.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/0.13.3/JSXTransformer.js"></script>
@@ -579,6 +580,7 @@
First, add the third-party library marked to your application. This is a JavaScript library which takes Markdown text and converts it to raw HTML. This requires a script tag in your head (which we have already included in the React playground):
<!-- index.html -->
<head>
+ <meta charset="UTF-8" />
<title>Hello React</title>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/0.13.3/react.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/0.13.3/JSXTransformer.js"></script>
@@ -704,7 +706,7 @@
getInitialState() executes exactly once during the lifecycle of the component and sets up the initial state of the component.
Updating state #
-When the component is first created, we want to GET some JSON from the server and update the state to reflect the latest data. In a real application this would be a dynamic endpoint, but for this example, we will use a static JSON file to keep things simple:
+When the component is first created, we want to GET some JSON from the server and update the state to reflect the latest data. In a real application this would be a dynamic endpoint, but for this example we will keep things simple by creating a static JSON file public/comments.json containing the array of comments:
// tutorial13.json
[
{"author": "Pete Hunt", "text": "This is one comment"},
diff --git a/docs/two-way-binding-helpers-ja-JP.html b/docs/two-way-binding-helpers-ja-JP.html
new file mode 100644
index 0000000000..d77933eb12
--- /dev/null
+++ b/docs/two-way-binding-helpers-ja-JP.html
@@ -0,0 +1,539 @@
+
+
+
+
+
+
+ 2ウェイバインディングのヘルパ | React
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 2ウェイバインディングのヘルパ
+ Edit on GitHub
+
+
+
+ ReactLink はReactで2ウェイバインディングを表現する簡単な方法です。
+
+
+注意:
+もしあなたがフレームワークについてあまりよく知らないのであれば、 ReactLink は多くのアプリケーションには必要なく、慎重に使うべきであることに注意してください。
+
+
+Reactでは所有者から子要素へと、データの流れは一方向です。これはデータがVon Neumannのコンピューティングモデルによって一方向にのみ流れるからです。これを「1ウェイデータバインディング」だと考えることができます。
+
+しかし、データやプログラムに戻る流れを読む必要が有るアプリケーションもたくさんあります。例えば、フォームを作る際に、ユーザのインプットを受け取った時には、Reactの state を更新したいと思うことはよくあるでしょう。または、JavaScriptでレイアウトを形作ったり、DOM要素のサイズの変化に反応したいと思うでしょう。
+
+Reactでは、「変更」のイベントを検知し、データソース(普通はDOMです)を読み、コンポーネントのうちの1つの上で setState() を呼ぶことでこの要求を満たすことができます。「データフローのループを止めること」は理解しやすく、維持しやすいプログラムを明確に導きます。詳細な情報については、フォームのドキュメントをご覧ください。
+
+2ウェイバインディングはDOMの値が常にReactの state と一致していることを暗黙に強制しますが、簡潔で、多くの種類のアプリケーションをサポートします。上で説明されているような共通のデータフローループパターンのセットアップや、データソースをReactの state に「接続する」ための糖衣構文である ReactLink が提供されています。
+
+
+注意:
+ReactLink は薄いラッパーであり、 onChange/setState() パターンにおける習慣です。Reactアプリケーションのデータフローの方法を根本から変えるようなものではありません。
+
+ReactLink: ビフォーアフター #
+以下が、 ReactLink を使用しない単純なフォームの例です。
+var NoLink = React.createClass({
+ getInitialState: function() {
+ return {message: 'Hello!'};
+ },
+ handleChange: function(event) {
+ this.setState({message: event.target.value});
+ },
+ render: function() {
+ var message = this.state.message;
+ return <input type="text" value={message} onChange={this.handleChange} />;
+ }
+});
+
+これはとてもよく動き、データがどう流れているかとても明確です。しかし、たくさんのフォームのフィールドがあった場合、少し冗長になります。以下のように、 ReactLink を使うことでタイピング量が少なくて済みます。
+var WithLink = React.createClass({
+ mixins: [React.addons.LinkedStateMixin],
+ getInitialState: function() {
+ return {message: 'Hello!'};
+ },
+ render: function() {
+ return <input type="text" valueLink={this.linkState('message')} />;
+ }
+});
+
+LinkedStateMixin は linkState() と呼ばれるReactコンポーネントにメソッドを追加します。
+linkState() はReactのステータスの現在の値と、それを変更するコールバックを持った ReactLink オブジェクトを返します。
+
+ReactLink オブジェクトはプロパティとして、木構造の上や下に渡される可能性があります。だから、階層の深い位置にいるコンポーネントと階層の高い位置にいるステータスの間の2ウェイバインディングをセットアップすることは簡単(で、明確)です。
+
+チェックボックスはその value 属性に対しての特別な態度を持っていることに注意してください。それは、チェックボックスがチェックされている(デフォルトで on )場合にフォームのサブミットで送信される値です。 value 属性はチェックボックスがチェックされていても、チェックされていなくても、更新されません。チェックボックスについては、valueLink の代わりに、 checkedLink を使うべきです。以下のように。
+<input type="checkbox" checkedLink={this.linkState('booleanValue')} />
+
フードの下 #
+ReactLink には2つの側面があります。 ReactLink のインスタンスを作成する場所と、それを使う場所です。 ReactLink がどれだけ単純か証明するために、それぞれの側面を分けて、明確に再度記述してみましょう。
+LinkedStateMixinを使わないReactLink #
var WithoutMixin = React.createClass({
+ getInitialState: function() {
+ return {message: 'Hello!'};
+ },
+ handleChange: function(newValue) {
+ this.setState({message: newValue});
+ },
+ render: function() {
+ var valueLink = {
+ value: this.state.message,
+ requestChange: this.handleChange
+ };
+ return <input type="text" valueLink={valueLink} />;
+ }
+});
+
+今まで見てきたように ReactLink オブジェクトは value と requestChange プロパティだけを持ったとても単純なオブジェクトです。そして、 LinkedStateMixin も同様に単純です。それらのフィールドを this.state の値と、 this.setState() を呼ぶコールバックで満たします。
+valueLinkを使わないReactLink #
var WithoutLink = React.createClass({
+ mixins: [React.addons.LinkedStateMixin],
+ getInitialState: function() {
+ return {message: 'Hello!'};
+ },
+ render: function() {
+ var valueLink = this.linkState('message');
+ var handleChange = function(e) {
+ valueLink.requestChange(e.target.value);
+ };
+ return <input type="text" value={valueLink.value} onChange={handleChange} />;
+ }
+});
+
+valueLink プロパティも同様にとても単純です。単純に onChange イベントをハンドルし、 this.props.valueLink.requestChange() を呼び、 this.props.value の代わりに this.props.valueLink.value を使用します。それだけです!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/two-way-binding-helpers.html b/docs/two-way-binding-helpers.html
index 76a5d426dc..a1068e1642 100644
--- a/docs/two-way-binding-helpers.html
+++ b/docs/two-way-binding-helpers.html
@@ -423,7 +423,7 @@
Note:
-ReactLink is just a thin wrapper and convention around the onChange/setState() pattern. It doesn't fundamentally change how data flows in your React application.
+ReactLink is just a thin wrapper and convention around the onChange/setState() pattern. It doesn't fundamentally change how data flows in your React application.
ReactLink: Before and After #
Here's a simple form example without using ReactLink:
diff --git a/tips/if-else-in-JSX.html b/tips/if-else-in-JSX.html
index 4ac448a4d8..304d1b3817 100644
--- a/tips/if-else-in-JSX.html
+++ b/tips/if-else-in-JSX.html
@@ -417,8 +417,7 @@
That's not valid JS. You probably want to make use of a ternary expression:
React.render(<div id={condition ? 'msg' : ''}>Hello World!</div>, mountNode);
-If a ternary expression isn't robust enough, you can use if statements to determine which
-components should be used.
+If a ternary expression isn't robust enough, you can use if statements outside of your JSX to determine which components should be used:
var loginButton;
if (loggedIn) {
loginButton = <LogoutButton />;
@@ -431,8 +430,34 @@ components should be used.
<Home />
{loginButton}
</nav>
-)
+);
+Or if you prefer a more "inline" aesthetic, define immediately-invoked function expressions inside your JSX:
+return (
+ <section>
+ <h1>Color</h1>
+ <h3>Name</h3>
+ <p>{this.state.color || "white"}</p>
+ <h3>Hex</h3>
+ <p>
+ {() => {
+ switch (this.state.color) {
+ case "red": return "#FF0000";
+ case "green": return "#00FF00";
+ case "blue": return "#0000FF";
+ default: return "#FFFFFF";
+ }
+ }()}
+ </p>
+ </section>
+);
+
+
+Note:
+
+In the example above, an ES6 arrow function is utilized to lexically bind the value of this.
+
+
Try using it today with the JSX compiler.
diff --git a/tips/self-closing-tag-ja-JP.html b/tips/self-closing-tag-ja-JP.html
new file mode 100644
index 0000000000..828a1e0549
--- /dev/null
+++ b/tips/self-closing-tag-ja-JP.html
@@ -0,0 +1,456 @@
+
+
+
+
+
+
+ 自己終了タグ | React
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+