Reactで要素を表示または非表示にする


532

私は初めてReact.jsをいじっていますが、クリックイベントを介してページ上の何かを表示または非表示にする方法を見つけることができません。ページに他のライブラリーをロードしていないので、Reactライブラリーを使用するネイティブな方法を探しています。これは私が今まで持っているものです。クリックイベントが発生したときに結果のdivを表示したいと思います。

var Search= React.createClass({
    handleClick: function (event) {
        console.log(this.prop);
    },
    render: function () {
        return (
            <div className="date-range">
                <input type="submit" value="Search" onClick={this.handleClick} />
            </div>
        );
    }
});

var Results = React.createClass({
    render: function () {
        return (
            <div id="results" className="search-results">
                Some Results
            </div>
        );
    }
});

React.renderComponent(<Search /> , document.body);

11
受け入れられたコメントは、新しいレベルの技術を使用して、ネイティブレベルの既存の技術がより簡単に、より速く、他の言語やライブラリと共有できることの両方を実行します。標準のCSSでこれを処理することは、ほぼ間違いなくより良い答えです。
John Haugeland、2015年

13
@ JohnHaugeland、Reactフレームワークを使用する場合の最良の答えは、すべてのReactスタイルに対応する受け入れられた答えです。これには、場合によっては実行する必要があるクリーンアップ機能があります。コンポーネントを暗闇の中に隠しておくことはお勧めできません。あなたがものを混ぜるなら、あなたはすべて他のものよりも常に速いすべてのネイティブに行く方が良いです。
Claudiu Hojda、2015年

4
いいえ、そうではありません。反応を使用してCSSを再発明することは悪い考えです。
John Haugeland、2015年

8
その上、あなたは私の言ったことのポイントを完全に逃したようです、それは物理的にそれを取り除くためにReactを使うのではなく、CSSを使って要素を隠したり表示したりすることでした。あなたは、することができます使用非表示にCSSを使用して、同じように簡単に要素を表示するように反応する:<divのスタイル= {{表示:this.props.example}} />を。
John Haugeland、2015年

5
@ClaudiuHojdaコンポーネントは暗闇の中に隠れる有するいくつかのケースでは、実際には非常に良い習慣です、私はあなたがそれらをCSSで非表示になっている場合でも、HTMLのままにするためのリンクを必要とする応答ナビゲーション、と思っています
トニ・リー

回答:


545

2020年頃の反応

ではonClick、コールバック、呼び出し状態フックの状態を更新して再描画するためにsetter関数を:

const Search = () => {
  const [showResults, setShowResults] = React.useState(false)
  const onClick = () => setShowResults(true)
  return (
    <div>
      <input type="submit" value="Search" onClick={onClick} />
      { showResults ? <Results /> : null }
    </div>
  )
}

const Results = () => (
  <div id="results" className="search-results">
    Some Results
  </div>
)

ReactDOM.render(<Search />, document.querySelector("#container"))
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/16.13.1/umd/react.production.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react-dom/16.13.1/umd/react-dom.production.min.js"></script>

<div id="container">
  <!-- This element's contents will be replaced with your component. -->
</div>

JSFiddle

2014年頃の反応

重要なのは、を使用してクリックハンドラーのコンポーネントの状態を更新することsetStateです。状態の変更が適用されると、renderメソッドは新しい状態で再度呼び出されます。

var Search = React.createClass({
    getInitialState: function() {
        return { showResults: false };
    },
    onClick: function() {
        this.setState({ showResults: true });
    },
    render: function() {
        return (
            <div>
                <input type="submit" value="Search" onClick={this.onClick} />
                { this.state.showResults ? <Results /> : null }
            </div>
        );
    }
});

var Results = React.createClass({
    render: function() {
        return (
            <div id="results" className="search-results">
                Some Results
            </div>
        );
    }
});

ReactDOM.render( <Search /> , document.getElementById('container'));
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/15.6.2/react.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react-dom/15.6.2/react-dom.min.js"></script>

<div id="container">
  <!-- This element's contents will be replaced with your component. -->
</div>

JSFiddle


3
はい、状態と小道具についての良い点。これを行うには良い方法は、検索バーと結果テーブルではなく、検索結果内を置くの兄弟で、ここのチュートリアル、のようになりwhould:facebook.github.io/react/docs/thinking-in-react.html
ダグラス

53
他の回答で述べたように、挿入/削除は単純なクラスマスキングよりもはるかに遅くなります。
John Haugeland、2015年

4
ジョンズのコメントはレビューが必要だと思います。私は意図した答えで行きましたが、それはきちんとしていて、より「反応」するように感じました。しかし、マウントされていないコンポーネントで初期状態や便利なものを設定できませんでした。代わりにcssを使用して物事を非表示にすることを検討しています。マウントされていないコンポーネントのリスナーは静かに失敗します。これにより、今日は大きな時間の損失を引き起こしています。
着陸

つまり、スタイルが変更されると、reactはコンポーネントを再レンダリングします(show / hideに設定されています)!?
アレックス、2016年

@Douglas見逃さない限り、この方法では元に戻すことができません。OPはそれを望んでいないと思いますが、これをどのように含めることができますか?
ワームは

221
<style type="text/css">
    .hidden { display:none; }
</style>
render: function() {
    return (
      <div className={this.props.shouldHide ? 'hidden' : ''}>
        This will be hidden if you set <tt>props.shouldHide</tt> 
        to something truthy.
      </div>
    );
}

// or in more modern JS and stateless react
const Example = props => <div className={props.shouldHide}/>Hello</div>

12
ダグラスの答えのように条件付きでnullを返すことをお勧めします。これにより、ReactはDOMから完全に削除できます。あなたの場合、divとそのコンテンツはDOMに残っていますが、表示されていません。これはパフォーマンスに影響を与える可能性があります。
pmont 2014

125
DOM要素の追加と削除のパフォーマンスへの影響は、DOM要素の非表示と表示よりもはるかに悪いです。私は彼のアプローチと私のアプローチの違いを認識しています、そしてあなたはこれが正確に間違っていると信じています。時間をかけて「パフォーマンスへの影響」を定義し、それを測定することを検討してください。
John Haugeland 2014

6
「リフローは追加/削除で保証されています」-絶対位置の要素ではありません。これは、Famousが驚くべきパフォーマンスを得る方法です。しかし、あなたはメトリックスに有効なポイントを作ります。
pmont 2014

9
:何それの価値があるため、これは、ここにドキュメントを反応させるのに記載されているfacebook.github.io/react/docs/...
ブラッド・パークス

85
そのため、nullを返すか、かなり大きな161のdomノードを持つ非表示クラスを設定するかをテストしました。ノードを削除するよりもクラスを使用する方がはるかに高速です。
Jonathan Rowny、2015年

120

三項演算子の代替構文は次のとおりです。

{ this.state.showMyComponent ? <MyComponent /> : null }

以下と同等です。

{ this.state.showMyComponent && <MyComponent /> }

無駄のない理由


また、代替構文 display: 'none';

<MyComponent style={this.state.showMyComponent ? {} : { display: 'none' }} />

ただし、過度に使用するとdisplay: 'none'、DOMの汚染につながり、最終的にアプリケーションの速度が低下します。


警告!'ダブルアンパーサンド(&&)'アプローチはブール値にのみ使用してください。{this.state.myComponents.length && <MyComponent />}は、myComponentsが空の配列(たとえば)の場合、0をレンダリングします
Mega Proger

57

これが私のアプローチです。

import React, { useState } from 'react';

function ToggleBox({ title, children }) {
  const [isOpened, setIsOpened] = useState(false);

  function toggle() {
    setIsOpened(wasOpened => !wasOpened);
  }

  return (
    <div className="box">
      <div className="boxTitle" onClick={toggle}>
        {title}
      </div>
      {isOpened && (
        <div className="boxContent">
          {children}
        </div>
      )}
    </div>
  );
}

上記のコードでは、これを達成するために、次のようなコードを使用しています。

{opened && <SomeElement />}

trueのSomeElement場合にのみレンダリングされopenedます。これは、JavaScriptが論理条件を解決する方法のために機能します。

true && true && 2; // will output 2
true && false && 2; // will output false
true && 'some string'; // will output 'some string'
opened && <SomeElement />; // will output SomeElement if `opened` is true, will output false otherwise (and false will be ignored by react during rendering)
// be careful with 'falsy' values eg
const someValue = 0;
someValue && <SomeElement /> // will output 0, which will be rednered by react
// it'll be better to:
!!someValue && <SomeElement /> // will render nothing as we cast the value to boolean

CSS 'display:none'の代わりにこのアプローチを使用する理由

  • CSSで要素を非表示にするのは「安上がり」かもしれませんが、そのような場合、「隠された」要素はリアクションの世界で「生きている」ままです(これにより、実際にはより高価になる可能性があります)。
    • つまり、親要素(例:)の小道具<TabView>が変更される場合-1つのタブしか表示されない場合でも、5つのタブすべてが再レンダリングされます
    • 非表示の要素はまだいくつかのライフサイクルメソッドを実行している可能性があります。表示されていない場合でも、更新のたびにサーバーからデータをフェッチする可能性があります
    • 非表示の要素は、誤ったデータを受け取るとアプリをクラッシュさせる可能性があります。状態を更新するときに非表示のノードを「忘れる」可能性があるために発生する可能性があります
    • 要素を表示するときに誤った「表示」スタイルを誤って設定する可能性があります。一部のdivはデフォルトで「display:flex」ですが、誤って「display:block」を設定display: invisible ? 'block' : 'none'すると、レイアウトが壊れる可能性があります
    • someBoolean && <SomeNode />特に何かを表示するかどうかに関連するロジックが複雑になる場合は、使用と理解が非常に簡単であり、その理由を説明します
    • 多くの場合、要素が再表示されたときに要素の状態を「リセット」する必要があります。例えば。スライダーが表示されるたびに初期位置に設定したいスライダーがあるかもしれません。(それが以前の要素の状態を維持するために望ましい動作である場合、それが非表示であっても、IMOはまれです-この状態を別の方法で記憶することが複雑になる場合は、CSSの使用を検討します)

2
これは良い例です!小さなことの1つは、boxContentはclassName = "boxContent"である必要があります
Bhetzie

5
ここにバグがあります:this.setState({isOpened: !isOpened});。状態を変更するときは、状態自体に依存しないでください。良い例は次のとおりですthis.setState( s => ({isOpened: !s.isOpened}) )。setState内の矢印関数に注意してください。
arcol 2018

これを確認するソース/ベンチマーク/例はありますか?「表示を設定した場合:なし-要素は引き続きreactによってレンダリングされ、DOMに追加されます-パフォーマンスに悪影響を与える可能性があります。」?
ニーヤ

@neiyaしません。CSSは小さな要素を使用するとパフォーマンスが向上する可能性がありますが、多くの場合、オプションでコンテンツの大きな部分をレンダリングする必要があります。タブ。また、一部の要素はCSSで非表示になっていますが、反応の世界ではまだ生きています。つまり、状態を更新したり、一部のデータをフェッチしたりするなど、コストがかかり、予期しない動作を引き起こす可能性があります。そして、IMOは実際に実装するのが非常に簡単です。
pie6k


11

これを処理する小さなコンポーネントを作成しました:react-toggle-display

これは、スタイルプロパティをまたはにdisplay: none !important基づいて設定します。hideshow

使用例:

var ToggleDisplay = require('react-toggle-display');

var Search = React.createClass({
    getInitialState: function() {
        return { showResults: false };
    },
    onClick: function() {
        this.setState({ showResults: true });
    },
    render: function() {
        return (
            <div>
                <input type="submit" value="Search" onClick={this.onClick} />
                <ToggleDisplay show={this.state.showResults}>
                    <Results />
                </ToggleDisplay>
            </div>
        );
    }
});

var Results = React.createClass({
    render: function() {
        return (
            <div id="results" className="search-results">
                Some Results
            </div>
        );
    }
});

React.renderComponent(<Search />, document.body);

10

すでにいくつかの素晴らしい答えがありますが、それらは十分に説明されていないと思います、そして与えられた方法のいくつかは人々をつまずかせるかもしれないいくつかの落とし穴を含んでいます。そのため、これを行うために3つの主要な方法(およびトピック外のオプションを1つ)を検討し、長所と短所を説明します。オプション1が多く推奨されており、正しく使用しない場合、そのオプションには多くの潜在的な問題があるので、私は主にこれを書いています。

オプション1:親での条件付きレンダリング。

コンポーネントを1回だけレンダリングしてそのままにしない限り、この方法は好きではありません。問題は、可視性を切り替えるたびにコンポーネントを最初から作成する反応が発生することです。これがその例です。LogoutButtonまたはLoginButtonは、条件付きで親LoginControlにレンダリングされます。これを実行すると、ボタンがクリックされるたびにコンストラクターが呼び出されることがわかります。https://codepen.io/Kelnor/pen/LzPdpN?editors=1111

class LoginControl extends React.Component {
  constructor(props) {
    super(props);
    this.handleLoginClick = this.handleLoginClick.bind(this);
    this.handleLogoutClick = this.handleLogoutClick.bind(this);
    this.state = {isLoggedIn: false};
  }

  handleLoginClick() {
    this.setState({isLoggedIn: true});
  }

  handleLogoutClick() {
    this.setState({isLoggedIn: false});
  }

  render() {
    const isLoggedIn = this.state.isLoggedIn;

    let button = null;
    if (isLoggedIn) {
      button = <LogoutButton onClick={this.handleLogoutClick} />;
    } else {
      button = <LoginButton onClick={this.handleLoginClick} />;
    }

    return (
      <div>
        <Greeting isLoggedIn={isLoggedIn} />
        {button}
      </div>
    );
  }
}

class LogoutButton extends React.Component{
  constructor(props, context){
    super(props, context)
    console.log('created logout button');
  }
  render(){
    return (
      <button onClick={this.props.onClick}>
        Logout
      </button>
    );
  }
}

class LoginButton extends React.Component{
  constructor(props, context){
    super(props, context)
    console.log('created login button');
  }
  render(){
    return (
      <button onClick={this.props.onClick}>
        Login
      </button>
    );
  }
}

function UserGreeting(props) {
  return <h1>Welcome back!</h1>;
}

function GuestGreeting(props) {
  return <h1>Please sign up.</h1>;
}

function Greeting(props) {
  const isLoggedIn = props.isLoggedIn;
  if (isLoggedIn) {
    return <UserGreeting />;
  }
  return <GuestGreeting />;
}

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

これで、Reactはコンポーネントを最初から作成するのがかなり速くなりました。ただし、作成時にコードを呼び出す必要があります。そのため、コンストラクタ、componentDidMount、renderなどのコードが高価な場合、コンポーネントの表示が大幅に遅くなります。これはまた、非表示のときに状態を保持したい(表示したときに復元したい)ステートフルコンポーネントではこれを使用できないことを意味します。1つの利点は、非表示のコンポーネントが選択されるまでまったく作成されないことです。したがって、非表示のコンポーネントが最初のページの読み込みを遅らせることはありません。トグルしたときにリセットするステートフルコンポーネントが必要な場合もあります。この場合、これが最良のオプションです。

オプション2:子の条件付きレンダリング

これにより、両方のコンポーネントが一度作成されます。次に、コンポーネントが非表示の場合、残りのレンダーコードを短絡します。可視プロップを使用して、他の方法で他のロジックを短絡することもできます。codepenページのconsole.logに注目してください。https://codepen.io/Kelnor/pen/YrKaWZ?editors=0011

class LoginControl extends React.Component {
  constructor(props) {
    super(props);
    this.handleLoginClick = this.handleLoginClick.bind(this);
    this.handleLogoutClick = this.handleLogoutClick.bind(this);
    this.state = {isLoggedIn: false};
  }

  handleLoginClick() {
    this.setState({isLoggedIn: true});
  }

  handleLogoutClick() {
    this.setState({isLoggedIn: false});
  }

  render() {
    const isLoggedIn = this.state.isLoggedIn;
    return (
      <div>
        <Greeting isLoggedIn={isLoggedIn} />
        <LoginButton isLoggedIn={isLoggedIn} onClick={this.handleLoginClick}/>
        <LogoutButton isLoggedIn={isLoggedIn} onClick={this.handleLogoutClick}/>
      </div>
    );
  }
}

class LogoutButton extends React.Component{
  constructor(props, context){
    super(props, context)
    console.log('created logout button');
  }
  render(){
    if(!this.props.isLoggedIn){
      return null;
    }
    return (
      <button onClick={this.props.onClick}>
        Logout
      </button>
    );
  }
}

class LoginButton extends React.Component{
  constructor(props, context){
    super(props, context)
    console.log('created login button');
  }
  render(){
    if(this.props.isLoggedIn){
      return null;
    }
    return (
      <button onClick={this.props.onClick}>
        Login
      </button>
    );
  }
}

function UserGreeting(props) {
  return <h1>Welcome back!</h1>;
}

function GuestGreeting(props) {
  return <h1>Please sign up.</h1>;
}

function Greeting(props) {
  const isLoggedIn = props.isLoggedIn;
  if (isLoggedIn) {
    return <UserGreeting />;
  }
  return <GuestGreeting />;
}

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

これで、初期化ロジックが高速で、子がステートレスである場合、パフォーマンスや機能の違いはわかりません。しかし、なぜとにかくReactがトグルのたびにまったく新しいコンポーネントを作成するようにするのですか?ただし、初期化に負荷がかかる場合は、コンポーネントを切り替えるたびにオプション1が実行され、切り替え時にページが遅くなります。オプション2は、最初のページのロード時にコンポーネントのすべての初期化を実行します。最初のロードを遅くします。再度注意する必要があります。条件に基づいてコンポーネントを1回だけ表示してトグルしない場合、またはtoggledmのときにコンポーネントをリセットしたい場合は、オプション1が適切で、おそらく最良のオプションです。

ただし、ページの読み込みが遅いことが問題である場合は、ライフサイクルメソッドに高額なコードが含まれていることを意味します。高価なコードをライフサイクルメソッドの外に移動することで、ページの遅い読み込みを解決できます。これを、ComponentDidMountによって開始された非同期関数に移動し、コールバックでsetState()を使用して状態変数に入れます。状態変数がnullでコンポーネントが表示されている場合、render関数にプレースホルダーを返させます。それ以外の場合は、データをレンダリングします。これにより、ページがすばやく読み込まれ、タブが読み込まれるときにタブが表示されます。ロジックを親に移動して、結果を小道具として子にプッシュすることもできます。これにより、最初にロードされるタブに優先順位を付けることができます。または、結果をキャッシュして、コンポーネントが初めて表示されたときにのみロジックを実行します。

オプション3:クラス非表示

クラス非表示はおそらく実装が最も簡単です。前述のように、display:noneを使用してCSSクラスを作成し、propに基づいてクラスを割り当てます。欠点は、すべての非表示コンポーネントのコード全体が呼び出され、すべての非表示コンポーネントがDOMにアタッチされることです。(オプション1は非表示コンポーネントをまったく作成しません。オプション2は、コンポーネントが非表示になると不要なコードを短絡し、コンポーネントをDOMから完全に削除します。)これは、他の答えは、私はそれについて話すことができません。

オプション4:1つのコンポーネントですが、小道具を変更します。または、コンポーネントがまったくなく、HTMLをキャッシュします。

これはすべてのアプリケーションで機能するわけではなく、コンポーネントを非表示にすることではないため、トピックから外れていますが、一部のユースケースでは非表示にするよりも優れたソリューションである可能性があります。タブがあるとしましょう。1つのReactコンポーネントを記述し、プロップを使用してタブに表示されるものを変更することもできます。また、JSXを状態変数に保存し、propを使用して、レンダー関数で返すJSXを決定することもできます。JSXを生成する必要がある場合は、JSXを生成して親にキャッシュし、正しいものをプロップとして送信します。または、子で生成し、子の状態でキャッシュし、小道具を使用してアクティブな子を選択します。


9

これは仮想DOMを利用する良い方法です

class Toggle extends React.Component {
  state = {
    show: true,
  }

  toggle = () => this.setState((currentState) => ({show: !currentState.show}));

  render() {
    return (
      <div>
        <button onClick={this.toggle}>
          toggle: {this.state.show ? 'show' : 'hide'}
        </button>    
        {this.state.show && <div>Hi there</div>}
      </div>
     );
  }
}

ここの

Reactフックの使用:

const Toggle = () => {
  const [show, toggleShow] = React.useState(true);

  return (
    <div>
      <button
        onClick={() => toggleShow(!show)}
      >
        toggle: {show ? 'show' : 'hide'}
      </button>    
      {show && <div>Hi there</div>}
    </div>
  )
}

ここの


私はこの無駄のない答えが好きです。フィドルは実行されません同情。
フアンLanus

以前の回答で述べたように、の状態に依存this.setState()するべきではありません
Dan Dascalescu

8

状態(例えば 'show')にブール値を設定し、次のようにします。

var style = {};
if (!this.state.show) {
  style.display = 'none'
}

return <div style={style}>...</div>

私はこれを試しましたが、クリックイベントはCSSを表示ブロックに切り替えませんでした。私はそれをどのように達成するか正確に迷っています。追加のヒントはありますか?
user1725382 2014

1
これには、スタイルルールテーブルをアクティブに変更することが含まれます。domノードの動的プロパティの一部ではない、オンとオフを切り替えることができる単一の既存のルールを用意することをお勧めします。
John Haugeland、2015年

1
ここでクラスやスタイルを使用するかどうかは問題ではありません。
ブリガンド

2
クラスを使用すると、数桁速くなります。知っておくと便利です。
Jason Rice

1
ただで条件付きのクラス名を使用することができます。github.com/JedWatson/classnames
backdesk

7

ドキュメントによると、ベストプラクティスは以下のとおりです。

{this.state.showFooter && <Footer />}

状態が有効な場合にのみ要素をレンダリングします。


この回答は1年前にすでに与えられていたため、今すぐ削除しても問題ありません。
Dan Dascalescu、

5
class Toggle extends React.Component {
  state = {
    show: true,
  }

  render() {
    const {show} = this.state;
    return (
      <div>
        <button onClick={()=> this.setState({show: !show })}>
          toggle: {show ? 'show' : 'hide'}
        </button>    
        {show && <div>Hi there</div>}
      </div>
     );
  }
}

4
   class FormPage extends React.Component{
      constructor(props){
           super(props);
           this.state = {
             hidediv: false
           }
      }

     handleClick = (){
       this.setState({
          hidediv: true
        });
      }

      render(){
        return(
        <div>
          <div className="date-range" hidden = {this.state.hidediv}>
               <input type="submit" value="Search" onClick={this.handleClick} />
          </div>
          <div id="results" className="search-results" hidden = {!this.state.hidediv}>
                        Some Results
           </div>
        </div>
        );
      }
  }

4

私は、Reactチームの次の声明から始めます。

Reactでは、必要な動作をカプセル化する別個のコンポーネントを作成できます。次に、アプリケーションの状態に応じて、それらの一部のみをレンダリングできます。

Reactでの条件付きレンダリングは、JavaScriptで条件が機能するのと同じように機能します。ifや条件演算子のようなJavaScript演算子を使用して、現在の状態を表す要素を作成し、それらに一致するようにReactにUIを更新させます。

基本的に、ボタンがクリックされたときにコンポーネントを表示する必要があります。純粋なReactを使用するか、CSSを使用するか、純粋なReactを使用するかの2つの方法で行うことができます。表示されていないhideResultsですtrueが、ボタンをクリックすることにより、状態のつもり変化とhideResultsされfalse、新しい値の条件で再びレンダリングコンポーネントのget、これが反応におけるコンポーネントのビューを変更するのは非常に一般的に使用され...

var Search = React.createClass({
  getInitialState: function() {
    return { hideResults: true };
  },

  handleClick: function() {
    this.setState({ hideResults: false });
  },

  render: function() {
    return (
      <div>
        <input type="submit" value="Search" onClick={this.handleClick} />
        { !this.state.hideResults && <Results /> }
      </div> );
  }

});

var Results = React.createClass({
  render: function() {
    return (
    <div id="results" className="search-results">
      Some Results
    </div>);
   }
});

ReactDOM.render(<Search />, document.body);

Reactの条件付きレンダリングについてさらに詳しく知りたい場合は、こちらをご覧ください


1
これは最もエレガントな方法です!
5

4

React Hooksを使用した単純な非表示/表示の例:(フィドルなしについて申し訳ありません)

const Example = () => {

  const [show, setShow] = useState(false);

  return (
    <div>
      <p>Show state: {show}</p>
      {show ? (
        <p>You can see me!</p>
      ) : null}
      <button onClick={() => setShow(!show)}>
    </div>
  );

};

export default Example;

2
{show?1:2}
PiotrŻak

3

コンポーネントの表示を切り替える方法を確認したい場合は、このフィドルをチェックアウトしてください。

http://jsfiddle.net/mnoster/kb3gN/16387/

var Search = React.createClass({
    getInitialState: function() {
        return { 
            shouldHide:false
        };
    },
    onClick: function() {
        console.log("onclick");
        if(!this.state.shouldHide){
            this.setState({
                shouldHide: true 
            })
        }else{
                    this.setState({
                shouldHide: false 
            })
        }
    },
render: function() {
    return (
      <div>
        <button onClick={this.onClick}>click me</button>
        <p className={this.state.shouldHide ? 'hidden' : ''} >yoyoyoyoyo</p>
      </div>
    );
}
});

ReactDOM.render( <Search /> , document.getElementById('container'));

3

フックを使用してReactで要素を表示/非表示にする簡単な方法

const [showText, setShowText] = useState(false);

次に、いくつかのロジックをrenderメソッドに追加します。

{showText && <div>This text will show!</div>}

そして

onClick={() => setShowText(!showText)}

よくやった。


2

場合によっては、高次コンポーネントが役立つことがあります。

高次コンポーネントを作成します。

export var HidableComponent = (ComposedComponent) => class extends React.Component {
    render() {
        if ((this.props.shouldHide!=null && this.props.shouldHide()) || this.props.hidden)
            return null;
        return <ComposedComponent {...this.props}  />;
    }
};

独自のコンポーネントを拡張します。

export const MyComp= HidableComponent(MyCompBasic);

その後、次のように使用できます。

<MyComp hidden={true} ... />
<MyComp shouldHide={this.props.useSomeFunctionHere} ... />

これにより、ボイラープレートが少し削減され、命名規則に従っていることになりますが、MyCompは引き続きインスタンス化されることに注意してください。省略する方法については前述しました。

{ !hidden && <MyComp ... /> }


1

rc-if-elseモジュールを使用する

npm install --save rc-if-else
import React from 'react';
import { If } from 'rc-if-else';

class App extends React.Component {
    render() {
        return (
            <If condition={this.props.showResult}>
                Some Results
            </If>
        );
    }
}

1

refを使用してCSSを操作する

1つの方法は、Reactを使用refし、ブラウザーのAPIを使用してCSSクラスを操作することです。その利点は、ボタンのクリックで一部のDOM要素を非表示または表示することだけが目的である場合、Reactでの再レンダリングを回避することです。

// Parent.jsx
import React, { Component } from 'react'

export default class Parent extends Component {
    constructor () {    
        this.childContainer = React.createRef()
    }

    toggleChild = () => {
        this.childContainer.current.classList.toggle('hidden')
    }

    render () {
        return (
            ...

            <button onClick={this.toggleChild}>Toggle Child</button>
            <div ref={this.childContainer}>
                <SomeChildComponent/>
            </div>

            ...
        );
    }
}


// styles.css
.hidden {
    display: none;
}

PS 私が間違っている場合は私を修正します。:)


ここで作成codesandbox.io例、: utgzx.csb.appは、コードがであるcodesandbox.io/embed/react-show-hide-with-css-utgzx
PATS

0

ブートストラップ4を使用すると、要素をそのように非表示にすることができます

className={this.state.hideElement ? "invisible" : "visible"}

0

これはこのようにして達成することもできます(非常に簡単な方法)

 class app extends Component {
   state = {
     show: false
   };
 toggle= () => {
   var res = this.state.show;
   this.setState({ show: !res });
 };
render() {
  return(
   <button onClick={ this.toggle }> Toggle </button>
  {
    this.state.show ? (<div> HELLO </div>) : null
  }
   );
     }

reactjs.org/docs/react-component.html#setstateで「以前の状態に基づく状態」の設定についてお読みください。また、最後にインデントを修正するといいでしょう。
Dan Dascalescu

0

この例は、1秒ごとに切り替わるトグルを使用してコンポーネントを切り替える方法を示しています

import React ,{Fragment,Component} from "react";
import ReactDOM from "react-dom";

import "./styles.css";

const Component1 = () =>(
  <div>
    <img 
src="https://i.pinimg.com/originals/58/df/1d/58df1d8bf372ade04781b8d4b2549ee6.jpg" />
   </div>
)

const Component2 = () => {
  return (
    <div>
       <img 
src="http://www.chinabuddhismencyclopedia.com/en/images/thumb/2/2e/12ccse.jpg/250px- 
12ccse.jpg" />
  </div>
   )

 }

 class App extends Component {
   constructor(props) {
     super(props);
    this.state = { 
      toggleFlag:false
     }
   }
   timer=()=> {
    this.setState({toggleFlag:!this.state.toggleFlag})
  }
  componentDidMount() {
    setInterval(this.timer, 1000);
   }
  render(){
     let { toggleFlag} = this.state
    return (
      <Fragment>
        {toggleFlag ? <Component1 /> : <Component2 />}
       </Fragment>
    )
  }
}


const rootElement = document.getElementById("root");
ReactDOM.render(<App />, rootElement);

奇妙な画像のURLとは何ですか?placeimg.com
Dan Dascalescu

0

この無駄のない短い構文を使用します。

{ this.state.show && <MyCustomComponent /> }

多分あなたはそれがどのように機能するかを説明するために無駄のない短い構文を拡張することができます。ああ、それは3年前の回答で行われました。あなたの答えは再びテーブルに何をもたらしますか?
Dan Dascalescu

0

要素を表示/非表示にするためのClassless Reactコンポーネントを使用した、シンプルで効果的で最良のソリューションが登場します。使用リアクト・フック最新で提供されています作成反応するアプリの用途は、そのプロジェクト16に反応

import React, {useState} from 'react';
function RenderPara(){
const [showDetail,setShowDetail] = useState(false);

const handleToggle = () => setShowDetail(!showDetail);

return (
<React.Fragment>
    <h3>
        Hiding some stuffs 
    </h3>
    <button onClick={handleToggle}>Toggle View</button>
   {showDetail && <p>
        There are lot of other stuffs too
    </p>}
</React.Fragment>)

}  
export default RenderPara;

ハッピーコーディング:)


0
//use ternary condition

{ this.state.yourState ? <MyComponent /> : null } 

{ this.state.yourState && <MyComponent /> }

{ this.state.yourState == 'string' ? <MyComponent /> : ''}

{ this.state.yourState == 'string' && <MyComponent /> }

//Normal condition

if(this.state.yourState){
 return <MyComponent />
}else{
  return null;
}

-1

あなたはcssファイルを使うことができます

    var Results = React.createClass({
    render: function() {
        return (
            <div id="results" className={`search-results ${this.state.showResults ? 'show' : ''}`}>
                Some Results
            </div>
        );
    }
})

そしてCSSファイルで

    .search-results {
     ...
     display: none
     &.show {
      display: block
   }
}

-1
var Search= React.createClass({
 getInitialState: () => { showResults: false },
 onClick: () => this.setState({ showResults: true }),
 render: function () {
   const { showResults } = this.state;
   return (
     <div className="date-range">
       <input type="submit" value="Search" onClick={this.handleClick} />
       {showResults && <Results />}
     </div>
   );
 }
});

var Results = React.createClass({
    render: function () {
        return (
            <div id="results" className="search-results">
                Some Results
            </div>
        );
    }
});

React.renderComponent(<Search /> , document.body);

1
あなたが何をしたのか説明してもらえますか、そしてそれはなぜ受け入れられた答えよりも優れているのですか?
Seblor

-1
class App extends React.Component {
  state = {
    show: true
  };

  showhide = () => {
    this.setState({ show: !this.state.show });
  };

  render() {
    return (
      <div className="App">
        {this.state.show && 
          <img src={logo} className="App-logo" alt="logo" />
        }
        <a onClick={this.showhide}>Show Hide</a>
      </div>
    );
  }
}

理解を深めるために説明を追加していただけますか?ありがとう!
Shanteshwar Inde

@ShanteshwarInde:これは、現在の状態に応じてsetStateの誤った使用法を含む、以前の回答からの同じアイデアを複製します。reactjs.org/docs/react-component.html#setstate:「以前の状態に基づいて状態を設定する必要がある場合は、アップデーターの引数についてお読みください」を参照してください。
Dan Dascalescu、

-1

var Search = React.createClass({
    getInitialState: function() {
        return { showResults: false };
    },
    onClick: function() {
        this.setState({ showResults: true });
    },
    render: function() {
        return (
            <div>
                <input type="checkbox" value="Search" onClick={this.onClick} />
                { this.state.showResults ? <Results /> : null }
            </div>
        );
    }
});

var Results = React.createClass({
    render: function() {
        return (
            <div id="results" className="search-results">
                <input type="text" />
            </div>
        );
    }
});

ReactDOM.render( <Search /> , document.getElementById('container'));
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/15.6.2/react.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react-dom/15.6.2/react-dom.min.js"></script>

<div id="container">
  <!-- This element's contents will be replaced with your component. -->
</div>


4
このコードは質問に答えることがありますが、このコードが質問に答える理由や方法に関する追加のコンテキストを提供すると、長期的な価値が向上します。
xiawi

@xiawiが言ったこと。また、定数を宣言するときのconst代わりに使用してくださいvar
Dan Dascalescu
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.