Reactの状態と小道具の違いは何ですか?


559

私はReactのPluralsightコースを見ていて、インストラクターは小道具を変更しないでくださいと言いました。私は今読んでいます、小道具対状態に関する記事(uberVU / react-guide)それは言う

小道具と状態変化の両方がレンダー更新をトリガーします。

記事の後半でそれは言う:

小道具(プロパティの略)はコンポーネントの構成であり、必要に応じてそのオプションです。それらは上から受け取られ、不変です。

  • 小道具は変更できますが、不変でなければなりませんか?
  • いつプロップを使用し、いつステートを使用する必要がありますか?
  • Reactコンポーネントが必要とするデータがある場合、それを介してReactコンポーネントのプロップまたはセットアップを介して渡す必要がありますgetInitialStateか?


7
これは非常に良い質問です。実際には、誰も簡単な答えを出していないようです:/
Thomas Decaux

回答:


670

小道具と状態は関連しています。1つのコンポーネントの状態は、多くの場合、子コンポーネントの小道具になります。小道具は、2番目の引数として親のrenderメソッド内の子に渡されReact.createElement()ます。JSXを使用している場合は、より馴染みのあるタグ属性です。

<MyChild name={this.state.childsName} />

の親の状態値がchildsName子のになりthis.props.nameます。子供の観点から見ると、名前プロップは不変です。変更する必要がある場合、親は内部状態を変更するだけです。

this.setState({ childsName: 'New name' });

そしてReactはそれをあなたの子供に伝えます。当然のことですが、子供が名前の小道具を変更する必要がある場合はどうでしょうか。これは通常、子イベントと親コールバックを通じて行われます。子は、などのイベントを公開する場合がありonNameChangedます。次に、親はコールバックハンドラーを渡すことによってイベントをサブスクライブします。

<MyChild name={this.state.childsName} onNameChanged={this.handleName} />

子は、要求された新しい名前を引数としてイベントコールバックに渡しますthis.props.onNameChanged('New name')

handleName: function(newName) {
   this.setState({ childsName: newName });
}

2
ありがとう!では、さらにいくつか質問をします。1.なぜ人々は小道具を変更すべきではないと言っているのですか?2.データのブートストラップはどこに置きますか?getInitialStateのようなコンポーネントの初期化で、またはコンポーネントの外側に配置して、データが利用可能なときにコンポーネントをレンダリングしますか?
skaterdav85、2015年

37
1.これがReactの「機能的」側面です。すべてのデータは(ほとんど)下方向に流れます。プロップは親が所有しているため、親のみが変更する必要があります。理想的には、子供は無国籍である必要があります。これは実際には不可能です(Reactサイトのフォームドキュメントを参照してください)。2.推奨される方法である上部にフィードするか、別のオブジェクトに保存することができます。人気のあるアプローチの1つはFluxで、これはStoresと呼ばれるシングルトンオブジェクトを使用します。これは、より大きな建築パターンの一部です。また、Facebookからオープンソースで提供され、Reactと連携するように設計されています。
Todd

2
ストアは大きなグローバル変数のようなものですか?
SuperUberDuper 2015年

3
はい、Fluxストアはクライアント側のキャッシュです。Facebookから最近リリースされたRelayやReduxなどの他のパタ​​ーンもあります。
トッド

6
状態内から管理されるコンポーネントデータであり、小道具は、上記から管理とに渡されるコンポーネントデータである:ビットダウンこれを沸騰させる。
マーク

221

親子のコミュニケーションのために、単に小道具を渡します。

使用状態を、現在のページに必要なデータをコントローラービューに保存します。

小道具を使用するデータとイベントハンドラーを子コンポーネントに渡すには、をします。

これらのリストは、コンポーネント内のデータを操作するときに役立ちます。

小道具

  • 不変です
    • これにより、Reactは高速な参照チェックを行うことができます
  • ビューコントローラーからデータを渡すために使用されます
    • トップレベルのコンポーネント
  • より良いパフォーマンスを持っている
    • これを使用して、データを子コンポーネントに渡します

状態

  • ビューコントローラで管理する必要があります
    • トップレベルのコンポーネント
  • 変更可能です
  • パフォーマンスが悪い
  • 子コンポーネントからアクセスしないでください
    • 代わりに小道具でそれを伝えます

親子関係を持たない2つのコンポーネント間の通信では、独自のグローバルイベントシステムをセットアップできます。イベントを受け取ったら、componentDidMount()でイベントをサブスクライブし、componentWillUnmount()でサブスクライブを解除し、setState()を呼び出します。磁束パターンは、これを調整するための可能な方法の1つです。- https://facebook.github.io/react/tips/communicate-between-components.html

どのコンポーネントに状態が必要ですか?

ほとんどのコンポーネントは、小道具からいくつかのデータを取得してレンダリングするだけです。ただし、ユーザー入力、サーバー要求、または時間の経過に応答する必要がある場合があります。これには状態を使用します。

できるだけ多くのコンポーネントをステートレスに保つようにしてください。これを行うことにより、状態を最も論理的な場所に分離し、冗長性を最小限に抑えて、アプリケーションを推論しやすくします。

一般的なパターンは、データをレンダリングするだけのいくつかのステートレスコンポーネントを作成し、その上に、プロパティを介してその状態を子に渡すステートフルコンポーネントを階層に配置することです。ステートフルコンポーネントはすべての対話ロジックをカプセル化し、ステートレスコンポーネントは宣言的な方法でデータのレンダリングを処理します。- https://facebook.github.io/react/docs/interactivity-and-dynamic-uis.html#what-c​​omponents-should-have-state

何が州に行くべきですか?

状態には、UIの更新をトリガーするためにコンポーネントのイベントハンドラーが変更する可能性のあるデータが含まれている必要があります。実際のアプリでは、このデータは非常に小さく、JSONでシリアル化できます。ステートフルコンポーネントを構築するときは、その状態の最小限の表現について考え、これらのプロパティのみをthis.stateに格納します。render()の内部では、この状態に基づいて、必要な他の情報を計算するだけです。この方法でアプリケーションを考えて作成すると、最も正確なアプリケーションにつながる傾向があります。状態に冗長な値または計算された値を追加することは、Reactの計算に依存するのではなく、明示的に同期を保つ必要があるためです。- https://facebook.github.io/react/docs/interactivity-and-dynamic-uis.html#what-should-go-in-state


2
同意しない、すべての小道具を行くことは実際にはデータを渡すためのパフォーマンスが低いです。子コンポーネントのストアを設定するだけで、混乱した小道具を扱う必要がなくなり、小道具が変更されたときにコンポーネントを更新する必要があります。ストアを更新し、コンポーネントがストアからデータを取得できるようにするだけです。
PositiveGuy

プロップが州よりもパフォーマンスが高い理由を教えてください。ありがとう。
hqt 2017

@hqt不変なので、値を変更するための内部比較の方が高速です
Gaspar

@BentOnCoding、良い一日、助けてください。そのような状態を想像できますか?USER INTERACTIONのコンポーネント内で変更されるデータがあるときはいつでも、ここで状態が使用されますか?
ディケンズ

72

プレーンなJS関数に関連付けると、最もよく理解できます。

簡単に言えば、

状態アクセス及びコンポーネントの外側を変更することができない成分の局所的な状態です。これは関数のローカル変数に相当します。

プレーンJS関数

const DummyFunction = () => {
  let name = 'Manoj';
  console.log(`Hey ${name}`)
}

Reactコンポーネント

class DummyComponent extends React.Component {
  state = {
    name: 'Manoj'
  }
  render() {
    return <div>Hello {this.state.name}</div>;
  }

小道具一方、、コンポーネントが親コンポーネントから小道具の形でデータを受信できるようにすることで、コンポーネントを再利用可能にします。これらは関数パラメーターと同等です。

プレーンJS関数

const DummyFunction = (name) => {
  console.log(`Hey ${name}`)
}

// when using the function
DummyFunction('Manoj');
DummyFunction('Ajay');

Reactコンポーネント

class DummyComponent extends React.Component {
  render() {
    return <div>Hello {this.props.name}</div>;
  }

}

// when using the component
<DummyComponent name="Manoj" />
<DummyComponent name="Ajay" />

クレジット:Manoj Singh Negi

記事のリンク:反応状態とプロップの説明


16
これは実際には非常に役立つ回答です。これを読んだ後、私はより完全な答えを理解することができます。ありがとう。
アーロン

1
Reactコンポーネント=単純なJS関数は、これを明確に説明する優れた方法です。そして、Reactがますます機能的なコンポーネントに向かっているので、これは文字通りさらに事実になっています。
JD Sandifer

1
私が読んだ最高の説明、ありがとう
iWizard

48

私が一番好きな小道具vs状態の要約はここにあります:反応ガイドそれらの人への大きな帽子の先端。以下はそのページの編集されたバージョンです:


小道具対状態

tl; drコンポーネントがある時点でその属性の1つを変更する必要がある場合、その属性はその状態の一部である必要があります。それ以外の場合は、コンポーネントの小道具でなければなりません。


小道具

小道具(プロパティの略)は、コンポーネントの構成です。それらは上から受信され、それらを受信するコンポーネントに関する限り不変です。コンポーネントはその小道具を変更することはできませんが、その子コンポーネントの小道具をまとめる責任があります。小道具は単なるデータである必要はありません-コールバック関数は小道具として渡されるかもしれません。

状態

状態は、コンポーネントのマウント時にデフォルト値で始まるデータ構造です。主にユーザーイベントの結果として、時間の経過とともに変化する可能性があります。

コンポーネントは自身の状態を内部で管理します。初期状態を設定する以外に、子の状態をいじるビジネスはありません。状態をそのコンポーネントのプライベートとして概念化できます。

小道具と状態の変更

                                                   小道具の状態
    親コンポーネントから初期値を取得できますか?はいはい
    親コンポーネントによって変更できますか?はい・いいえ
    コンポーネント内にデフォルト値を設定できますか?*はいはい
    コンポーネント内で変更できますか?いいえはい
    子コンポーネントの初期値を設定できますか?はいはい
    子コンポーネントで変更できますか?はい・いいえ
  • 親から受け取ったプロパティと状態の初期値は、コンポーネント内で定義されたデフォルト値をオーバーライドすることに注意してください。

このコンポーネントには状態がありますか?

状態はオプションです。状態は複雑さを増し、予測可能性を低下させるため、状態のないコンポーネントが望ましいです。対話型アプリでは状態なしでは明らかにできないことですが、ステートフルコンポーネントが多すぎることは避けてください。

コンポーネントタイプ

ステートレスコンポーネントプロップのみ、ステートなし。render()関数以外はあまりありません。彼らの論理は、彼らが受け取る小道具を中心に展開します。これにより、追跡とテストが非常に簡単になります。

ステートフルコンポーネントプロップと状態の両方。これらは、コンポーネントが何らかの状態を保持する必要がある場合に使用されます。これは、クライアントサーバー通信(XHR、Webソケットなど)、データの処理、およびユーザーイベントへの応答に適しています。これらの種類のロジスティクスは、適度な数のステートフルコンポーネントにカプセル化する必要がありますが、すべての視覚化およびフォーマットロジックは、多くのステートレスコンポーネントにダウンストリームで移動する必要があります。

ソース


1
「親から受け取った状態の初期値」とはどういう意味ですか?私の知る限り、状態は単一のコンポーネントのスコープ内でのみ定義されており、外部から直接変更することはできません。
Maxim Kuzmin 2017

@MaximKuzminこれは、「initialColor」のようなプロップを取り込み、「color」のような状態を初期化する一般的なパターンへの参照だと思います。状態には最初にプロップから値が与えられ(親から受信)、その後通常の状態のように動作し続けます。これを状態と小道具の概要に含めるのは少し混乱するかもしれませんが、知っておくべき重要なパターンです。
JD Sandifer

18

小道具(「プロパティ」の略)と状態は、どちらも単純なJavaScriptオブジェクトです。どちらもレンダリングの出力に影響を与える情報を保持しますが、それらは1つの重要な点で異なります。プロップはコンポーネントに渡され(関数パラメーターと同様)、状態はコンポーネント内で管理されます(関数内で宣言された変数と同様)。

したがって、単に状態は現在のコンポーネントに限定されますが、プロップは任意のコンポーネントに渡すことができます... 現在のコンポーネントの状態を他のコンポーネントにプロップとして渡すことができます...

また、Reactでは、内部状態ではなく小道具のみを持つステートレスコンポーネントがあります...

以下の例は、アプリでどのように機能するかを示しています。

ステートフルコンポーネント):

class SuperClock extends React.Component {

  constructor(props) {
    super(props);
    this.state = {name: "Alireza", date: new Date().toLocaleTimeString()};
  }

  render() {
    return (
      <div>
        <Clock name={this.state.name} date={this.state.date} />
      </div>
    );
  }
}

(ステートレスコンポーネント):

const Clock = ({name}, {date}) => (
    <div>
      <h1>{`Hi ${name}`}.</h1>
      <h2>{`It is ${date}`}.</h2>
    </div>
);

11

プロップと状態の主な違いは、状態は内部でコンポーネント自体によって制御されるのに対し、プロップは外部であり、コンポーネントをレンダリングするものによって制御されることです。

function A(props) {
  return <h1>{props.message}</h1>
}

render(<A message=”hello />,document.getElementById(“root”));


class A extends React.Component{  
  constructor(props) {  
    super(props)  
    this.state={data:"Sample Data"}  
  }  
  render() {
    return(<h2>Class State data: {this.state.data}</h2>)  
  } 
}

render(<A />, document.getElementById("root"));

州VS小道具

  • 状態を変更できます(変更可能)
  • 小道具はできない(不変)

7

基本的に、違いは、状態がOOPの属性のようなものであるということです。これは、クラス(コンポーネント)に対してローカルなものであり、よりよく説明するために使用されます。小道具はパラメーターのようなものです。それらはコンポーネントの呼び出し元(親)からコンポーネントに渡されます。あるパラメーターを指定して関数を呼び出した場合と同じです。


5

反応中の状態プロップの両方を使用して、コンポーネントへのデータを制御します。通常、プロップは親によって設定され、子コンポーネントに渡され、コンポーネント全体で固定されます。以下のために変更する予定ですデータ、我々は状態を使用する必要があります。また、状態が変更可能ある一方でプロップは不変です。プロップを変更したい場合は、親コンポーネントから実行して子コンポーネントに渡すことができます。


4

リアクションで作業しながら学んだように。

  • propsは、コンポーネントが外部環境からデータを取得するために使用します。つまり、別のコンポーネント(純粋、機能、またはクラス)または一般的なクラスまたはjavascript / typescriptコード

  • 状態、コンポーネントの内部環境を管理するために使用さコンポーネント内のデータの変更を意味します


3

小道具:小道具はコンポーネントのプロパティにすぎず、コンポーネントの反応はJavaScript関数にすぎません。

  class Welcome extends React.Component {
    render() {
      return <h1>Hello {this.props.name}</h1>;
    }
  }

const要素=;

ここに <Welcome name="Sara" />は、ウェルカムコンポーネントのプロップとしてオブジェクト{name: 'Sara'}を渡します。1つの親コンポーネントから子コンポーネントにデータを渡すには、propsを使用します。小道具は不変です。コンポーネントのライフサイクル中、プロップは変更されません(不変と見なしてください)。

状態:状態はコンポーネント内でのみアクセスできます。コンポーネント内のデータを追跡するには、状態を使用します。setStateで状態を変更できます。状態を子供に渡す必要がある場合は、小道具として渡す必要があります。

class Button extends React.Component {
  constructor() {
    super();
    this.state = {
      count: 0,
    };
  }

  updateCount() {
    this.setState((prevState, props) => {
      return { count: prevState.count + 1 }
    });
  }

  render() {
    return (<button
              onClick={() => this.updateCount()}
            >
              Clicked {this.state.count} times
            </button>);
  }
}

3

状態:

  1. 状態は変更可能です。
  2. 状態は個々のコンポーネントに関連付けられており、他のコンポーネントでは使用できません。
  3. 状態はコンポーネントのマウント時に初期化されます。
  4. 状態は、コンポーネント内の動的な変更をレンダリングするために使用されます。

小道具:

  1. 小道具は不変です。
  2. コンポーネント間で小道具を渡すことができます。
  3. プロップは、主にコンポーネント間の通信に使用されます。親から子に直接渡すことができます。子から親に渡すには、状態を持ち上げるという概念を使用する必要があります。

class Parent extends React.Component{
  render()
  {
     return(
        <div>
            <Child name = {"ron"}/>
        </div>
      );
  }
}

class Child extends React.Component{
{
    render(){
      return(
         <div>
              {this.props.name}
        </div>
      );
     }
}


{"message": "Uncaught SyntaxError:Unexpected token <"、 "filename": " stacksnippets.net/js "、 "lineno":17、 "colno":9}
Niko Jojo

2

基本的に、propsとstateは、コンポーネントが何をどのようにレンダリングするかを知るための2つの方法です。アプリケーションの状態のどの部分が状態に属し、どのトップレベルストアに属しているかは、Reactの動作よりもアプリの設計に関連しています。IMOを決定する最も簡単な方法は、この特定のデータが全体としてアプリケーションに役立つのか、それともローカル情報なのかを考えることです。また、状態を複製しないことが重要です。そのため、一部のデータを小道具から計算できる場合は、小道具から計算する必要があります。

たとえば、いくつかのドロップダウンコントロール(カスタムスタイルの標準HTML選択をラップする)があるとします。これは、a)リストから値を選択し、b)開いたり閉じたり(つまり、オプションリストの表示または非表示)できます。ここで、アプリが何らかのアイテムのリストを表示し、ドロップダウンコントロールがリストエントリをフィルター処理するとします。次に、アクティブなフィルター値を小道具として渡し、開いた状態と閉じた状態をローカルに保つのが最善です。また、機能させるには、ドロップダウン要素内で呼び出される親コンポーネントからonChangeハンドラーを渡し、更新された情報(新しく選択されたフィルター)をすぐにストアに送信します。一方、アプリケーションの残りの部分は、ユーザーが実際にコントロールの値を変更するまで、コントロールが開かれているかどうかを気にしないため、開いた状態または閉じた状態をドロップダウンコンポーネント内に保持できます。

次のコードは完全には機能していません。CSSとドロップダウンクリック/ぼかし/変更イベントを処理する必要がありますが、例を最小限に抑えたかったのです。それが違いを理解するのに役立つことを願っています。

const _store = {
    items: [
    { id: 1, label: 'One' },
    { id: 2, label: 'Two' },
    { id: 3, label: 'Three', new: true },
    { id: 4, label: 'Four', new: true },
    { id: 5, label: 'Five', important: true },
    { id: 6, label: 'Six' },
    { id: 7, label: 'Seven', important: true },
    ],
  activeFilter: 'important',
  possibleFilters: [
    { key: 'all', label: 'All' },
    { key: 'new', label: 'New' },
    { key: 'important', label: 'Important' }
  ]
}

function getFilteredItems(items, filter) {
    switch (filter) {
    case 'all':
        return items;

    case 'new':
        return items.filter(function(item) { return Boolean(item.new); });

    case 'important':
        return items.filter(function(item) { return Boolean(item.important); });

    default:
        return items;
  }
}

const App = React.createClass({
  render: function() {
    return (
            <div>
            My list:

            <ItemList   items={this.props.listItems} />
          <div>
            <Dropdown 
              onFilterChange={function(e) {
                _store.activeFilter = e.currentTarget.value;
                console.log(_store); // in real life, some action would be dispatched here
              }}
              filterOptions={this.props.filterOptions}
              value={this.props.activeFilter}
              />
          </div>
        </div>
      );
  }
});

const ItemList = React.createClass({
  render: function() {
    return (
      <div>
        {this.props.items.map(function(item) {
          return <div key={item.id}>{item.id}: {item.label}</div>;
        })}
      </div>
    );
  }
});

const Dropdown = React.createClass({
    getInitialState: function() {
    return {
        isOpen: false
    };
  },

  render: function() {
    return (
        <div>
            <select 
            className="hidden-select" 
          onChange={this.props.onFilterChange}
          value={this.props.value}>
            {this.props.filterOptions.map(function(option) {
            return <option value={option.key} key={option.key}>{option.label}</option>
          })}
        </select>

        <div className={'custom-select' + (this.state.isOpen ? ' open' : '')} onClick={this.onClick}>
            <div className="selected-value">{this.props.activeFilter}</div>
          {this.props.filterOptions.map(function(option) {
            return <div data-value={option.key} key={option.key}>{option.label}</div>
          })}
        </div>
      </div>
    );
  },

  onClick: function(e) {
    this.setState({
        isOpen: !this.state.isOpen
    });
  }
});

ReactDOM.render(
  <App 
    listItems={getFilteredItems(_store.items, _store.activeFilter)} 
    filterOptions={_store.possibleFilters}
    activeFilter={_store.activeFilter}
    />,
  document.getElementById('root')
);

2

状態は、コンポーネントが保持する情報を処理する方法です。

サーバーからデータをフェッチする必要があるコンポーネントがあるとします。通常、リクエストが処理中か、失敗したかなどをユーザーに通知します。これは、特定のコンポーネントにのみ関連する情報です。これは、状態がゲームに入る場所です。

通常、状態を定義する最良の方法は次のとおりです。

class MyComponent extends React.Component {
  constructor() {
    super();
    this.state = { key1: value1, key2: value2 }    
  }
}

しかし、最新のreactネイティブの実装では、次のことができます。

class MyComponent extends React.Component {
  state = { key1: value1, key2: value2 }    
}

これらの2つの例はまったく同じ方法で実行されます。これは構文の改善にすぎません。

では、オブジェクト指向属性を使用するだけと何が違うのでしょうか?通常、状態に保持されている情報は静的である必要はなく、時間の経過とともに変化し、ビューはこの変更を反映するために更新する必要があります。Stateはこの機能を簡単な方法で提供します。

州は、傷つけられることを意味します!そして、私はこれに十分なストレスをかけることができません。これはどういう意味ですか?つまり、このようなことは絶対に行わないでください。

 state.key2 = newValue;

それを行う適切な方法は次のとおりです。

this.setState({ key2: newValue });

this.setStateを使用すると、コンポーネントが更新サイクルを実行し、状態の一部が変更されると、コンポーネントのレンダリングメソッドが再度呼び出され、この変更が反映されます。

さらに詳細な説明については、反応ドキュメントを確認してください:https : //facebook.github.io/react/docs/state-and-lifecycle.html


2

小道具は単にプロパティの省略形です。小道具は、コンポーネントが互いに対話する方法です。Reactにまったく慣れている場合は、プロップが親コンポーネントから下方向に流れることを知っておく必要があります。

親コンポーネントが小道具を渡さなくても小道具が設定されるように、デフォルトの小道具を持つことができる場合もあります。

これが、人々がReactを単一方向のデータフローを持つと呼ぶ理由です。これは少し頭を動かす必要があり、おそらくこれについては後でブログで説明しますが、ここでは、データが親から子に流れることを覚えておいてください。小道具は不変です(そのための変わった言葉は変わりません)

だから私たちは幸せです。コンポーネントは親からデータを受け取ります。すべてソートされましたよね?

まあ、かなり。コンポーネントが親以外の誰かからデータを受信するとどうなりますか?ユーザーがコンポーネントに直接データを入力するとどうなりますか?

まあ、これが私たちが状態を持っている理由です。

状態

小道具は変更すべきではないので、州はステップアップします。通常、コンポーネントには状態がないため、ステートレスと呼ばれます。状態を使用するコンポーネントは、ステートフルと呼ばれます。パーティーにその小さな一口を置いて、人々があなたから遠ざかるのを見てください。

したがって、コンポーネントが実行するレンダリング間でコンポーネントが情報を追跡できるように、状態が使用されます。setStateを実行すると、状態オブジェクトが更新され、コンポーネントが再レンダリングされます。これは、Reactがハードワークを処理し、非常に高速であることを意味するため、非常にクールです。

状態の小さな例として、検索バーのスニペットを以下に示します(Reactについて詳しく知りたい場合は、このコースをチェックする価値があります)

Class SearchBar extends Component {
 constructor(props) {
  super(props);
this.state = { term: '' };
 }
render() {
  return (
   <div className="search-bar">
   <input 
   value={this.state.term}
   onChange={event => this.onInputChange(event.target.value)} />
   </div>
   );
 }
onInputChange(term) {
  this.setState({term});
  this.props.onSearchTermChange(term);
 }
}

概要

小道具と状態は同様のことを行いますが、使用方法は異なります。コンポーネントの大部分はおそらくステートレスです。

プロップは、親から子へ、またはコンポーネント自体によってデータを渡すために使用されます。これらは不変であるため、変更されません。

状態は、変更可能なデータ、または変更されるデータに使用されます。これは特にユーザー入力に役立ちます。たとえば、検索バーを考えてみてください。ユーザーがデータを入力すると、表示される内容が更新されます。


2

要するに。

小道具の値は変更できません[不変]

状態値はsetStateメソッドを使用して変更できます[可変]


1

状態 -コンポーネントデータを保持する特別な可変プロパティです。Componetのマウント時はデフォルト値になります。

props-これは本質的に不変であり、親から子への値渡しの場合に使用される特別なプロパティです。小道具はコンポーネント間の単なるコミュニケーションチャネルであり、常にトップ(親)からボタン(子)に移動します。

以下は、州と小道具を組み合わせる完全な例です:-

<!DOCTYPE html>
    <html>
      <head>
        <meta charset="UTF-8" />
        <title>state&props example</title>

        <script src="https://unpkg.com/react@0.14.8/dist/react.min.js"></script>
        <script src="https://unpkg.com/react-dom@0.14.8/dist/react-dom.min.js"></script>
        <script src="https://unpkg.com/babel-standalone@6.15.0/babel.min.js"></script>

      </head>
      <body>
      <div id="root"></div>
        <script type="text/babel">

            var TodoList = React.createClass({
                render(){
                    return <div className='tacos-list'>
                                {
                                    this.props.list.map( ( todo, index ) => {
                                    return <p key={ `taco-${ index }` }>{ todo }</p>;
                            })}
                            </div>;
                }
            });

            var Todo = React.createClass({
                getInitialState(){
                    return {
                        list : [ 'Banana', 'Apple', 'Beans' ]       
                    }
                },
                handleReverse(){
                    this.setState({list : this.state.list.reverse()});
                },
                render(){
                    return <div className='parent-component'>
                              <h3 onClick={this.handleReverse}>List of todo:</h3>
                              <TodoList list={ this.state.list }  />
                           </div>;
                }
            });

            ReactDOM.render(
                <Todo/>,
                document.getElementById('root')
            );

        </script>
      </body>
      </html>

1

一般に、1つのコンポーネント(親)の状態は、子コンポーネントのプロップです。

  1. 状態はコンポーネント内にあり、プロップが親から子に渡されます。
  2. 小道具は一般に不変です。

    class Parent extends React.Component {
        constructor() {
            super();
            this.state = {
                name : "John",
            }
        }
        render() {
            return (
                <Child name={this.state.name}>
            )
        }
    }
    
    class Child extends React.Component {
        constructor() {
            super();
        }
    
        render() {
            return(
                {this.props.name} 
            )
        }
    }

上記のコードでは、親クラス(Parent)に状態として名前があり、子コンポーネント(Childクラス)にプロップとして渡され、子コンポーネントは{this.props.name}を使用してそれをレンダリングします。


1

アプリケーションのどこかにユーザーが入力しているデータがあります。

  1. データが入力されているコンポーネントは、データ入力中にデータを操作および変更する必要があるため、このデータをその状態にしておく必要があります。

  2. アプリケーションの他の任意の場所で、データを他のすべてのコンポーネントへの小道具として渡す必要があります

つまり、小道具は変化していますが、「ソース」で変更され、そこから単純に流れ落ちます。したがって、小道具はそれらを受け取るコンポーネントのコンテキストでは不変です。

たとえば、ユーザーがサプライヤーのリストを編集する参照データ画面では、これを状態で管理します。これにより、アクションが実行されて、AppStateの1レベル下にあるReferenceDataStateに更新されたデータが保存され、このサプライヤーリストが小道具として渡されます。それを使用する必要があるすべてのコンポーネントに。


1

Reactでは、状態はデータと小道具を格納します。後者との違いは、格納されたデータがさまざまな変更によって変更できることです。これらはフラットなJavaScriptで記述されたオブジェクトにすぎないため、データまたはコードを含めることができ、モデル化する情報を表します。あなたはより多くの詳細が必要な場合、あなたがこれらの資料を参照することをお勧めします リアクトにおける国家の利用で小道具の使用が反応を


1
  • 小道具 ---あなたはその値を変更することはできません。
  • 状態 ---コードでその値を変更できますが、レンダリングが発生するとアクティブになります。

1

反応における「状態」と「小道具」の間のいくつかの違い。

Reactは状態に基づいてDOMを制御およびレンダリングします。コンポーネントの状態には2つのタイプがあります。propsはコンポーネント間で転送される状態であり、stateはコンポーネントの内部状態です。プロップは、親コンポーネントから子コンポーネントへのデータ転送に使用されます。コンポーネントの内部にも独自の状態があります。状態はコンポーネント内でのみ変更できます。

一般に、特定のコンポーネントの状態は子コンポーネントの小道具である可能性があります。小道具は親コンポーネントのレンダリングメソッド内に記述されている子に渡されます


1

小道具

  • 子コンポーネントでデータを渡すために使用する小道具

  • 小道具はコンポーネント(子コンポーネント)の外側の値を変更します

状態

  • クラスコンポーネント内での状態の使用

  • コンポーネント内の値を変更する状態

  • ページをレンダリングする場合、setStateを呼び出してDOM(update page value)を更新します

状態は反応で重要な役割を持っています


0

小道具が不変であるという最初の質問に答えて、それらは子コンポーネントに関する限り不変であると言われますが、親で変更可能です。


0

Reactコンポーネントは、状態を使用して、たとえば次のように変更/変更できる内部変数の読み取り/書き込みを行います。

this.setState({name: 'Lila'})

Reactプロップは、プログラマーが親コンポーネントから子コンポーネントに変数とメソッドを取得できるようにする特別なオブジェクトです。

それは窓や家のドアのようなものです。小道具も不変です子コンポーネントはそれらを変更/更新できません。

親コンポーネントによって小道具が変更されたときにリッスンするのに役立ついくつかのメソッドがあります。


0

これは、国家と小道具の間の説明に関する私の現在の視点です

  1. 状態は、コンポーネント内のローカル変数のようなものです。状態の値を操作するには、set stateを使用します。次に、たとえば、stateの値を子コンポーネントに渡すことができます。

  2. 小道具は、あなたのreduxストア内に正確に位置する値です。これは、実際にはレデューサーから発生した状態に由来します。プロップから値を取得するには、コンポーネントをreduxに接続する必要があります。小道具の値を子コンポーネントに渡すこともできます


0

簡単な説明は次のとおりです。STATEは、コンポーネントのローカル状態です(例:color = "blue"またはanimation = trueなど)。this.setStateを使用して、コンポーネントの状態を変更します。PROPSは、コンポーネントが互いに通信し(親から子にデータを送信する)、コンポーネントを再利用可能にする方法です。


0

状態はデータであり、変更可能であり、必要なことは何でもできます。プロップは読み取り専用データです。通常、データをすでに処理しているプロップを渡し、それをレンダリングするために子コンポーネントが必要な場合、またはプロップが関数を呼び出してタスクを実行する


0

状態は、データが存在する真実の起源です。 状態は小道具を介してそれ自身を明示すると言うことができます。

コンポーネントに小道具を提供することで、UIをデータと同期させることができます。コンポーネントは、実際にはマークアップを返す単なる関数です。

与えられた同じ小道具(ディスプレイにそれのためのデータ)は常に生成されます同じマークアップを

つまり、プロップは、データをオリジンから機能コンポーネントに運ぶパイプラインのようなものです。


0

小道具:「読み取り専用」データを表し、不変であり、親コンポーネントの属性を参照します。

状態:変更可能なデータを表します。これは、ページにレンダリングされ、コンポーネント自体によって内部的に管理されるものに最終的に影響し、一般にユーザー入力により時間の経過とともに変化します。


1
プロは1人だけですか?と1コン?
ゼウス書

0

主な違いは、状態はコンポーネントに対してプライベートであり、そのコンポーネント内で変更できるのは、プロップが静的な値であり、親コンポーネントを介して渡され、子コンポーネント内で変更できない子コンポーネントのキーだけであるということです。

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.