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

13
@JohnHaugeland, React 프레임 워크를 사용할 때 가장 좋은 대답은 모든 React 스타일을 채택하는 승인 된 대답입니다. 어두운 곳에 컴포넌트를 숨기는 것은 좋은 습관이 아닙니다. 당신이 재료를 혼합하면 항상 다른 것보다 빠른 모든 네이티브를 얻는 것이 좋습니다.
Claudiu Hojda 12

4
아니요, 그렇지 않습니다. CSS를 재발 명하기 위해 react를 사용하는 것은 나쁜 생각입니다.
John Haugeland

8
게다가, 당신은 내가 말한 요점을 완전히 놓친 것 같습니다. CSS를 사용하여 요소를 숨기고 표시하는 대신 React를 사용하여 실제로 제거하는 것이 었습니다. 당신은 할 수 있습니다 숨기기로 사용 CSS에 반응 사용하고 그냥 간단하게 요소를 보여줍니다 <DIV 스타일 = {{디스플레이 : this.props.example}} />.
John Haugeland

5
@ClaudiuHojda는 어두운 곳에 컴포넌트를 숨기는 것이 실제로 매우 좋은 방법입니다. 반응 형 탐색을 생각하고 있습니다. CSS로 숨겨져 있어도 HTML에 링크를 유지해야합니다.
Toni Leigh

답변:


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
예, 상태 대 소품에 대한 좋은 지적. 검색 창과 결과 테이블이 결과를 검색에 넣는 대신 형제 자식 인 자습서에서와 같이이 방법을 사용하는 더 좋은 방법 : facebook.github.io/react/docs/thinking-in-react.html
Douglas

53
다른 답변에서 언급했듯이 삽입 / 삭제는 간단한 클래스 마스킹보다 훨씬 느립니다.
John Haugeland

4
존스 의견은 검토가 필요하다고 생각합니다. 나는 의도 된 답변을 받았고 깔끔하고 '충분한'것처럼 반응합니다. 그러나 마운트되지 않은 구성 요소에서 초기 상태 및 유용한 것을 설정할 수 없었습니다. 대신 CSS를 사용하여 물건을 숨기려고합니다. 마운트되지 않은 구성 요소의 리스너는 자동으로 실패하므로 오늘 시간이 크게 단축되었습니다.
착륙

스타일이 변경 될 때 반응이 컴포넌트를 다시 렌더링한다는 것을 의미합니까 (표시 / 숨기기로 설정)!?
alex

@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
Douglas의 답변에서와 같이 조건부로 null을 반환하는 것이 좋습니다. 이를 통해 React는 DOM에서 완전히 제거 할 수 있습니다. 귀하의 경우 div 및 그 내용은 여전히 ​​표시되지 않은 DOM에 있습니다. 성능에 영향을 줄 수 있습니다.
pmont

125
돔 요소를 숨기거나 표시하는 것보다 dom 요소를 추가하고 제거 할 때 성능에 미치는 영향이 훨씬 더 나쁩니다. 나는 그의 접근 방식과 나의 접근 방식의 차이점을 알고 있으며, 당신이 정확히 잘못했다고 생각합니다. "성능 관련"을 정의하고 측정하는 데 시간을 투자하십시오.
John Haugeland

6
"리플 로우는 추가 / 제거를 통해 보장됩니다"-절대적으로 배치 된 요소가 아니라 Famous가 놀라운 성능을 얻는 방식입니다. 그러나 지표에 대해 올바른 지적을합니다.
pmont

9
가치가있는 것에 대해서는 여기에서 반응 문서에 언급되어 있습니다 : facebook.github.io/react/docs/…
Brad Parks

85
그래서 방금 null을 반환하고 161 개의 상당히 큰 dom 노드로 숨겨진 클래스를 설정하는 것을 테스트했습니다. 클래스를 사용하는 것이 노드를 제거하는 것보다 훨씬 빠릅니다.
Jonathan Rowny

120

삼항 연산자에 대한 대체 구문은 다음과 같습니다.

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

다음과 같습니다.

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

마른 이유


또한 대체 구문 display: 'none';

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

그러나 과도하게 사용 display: 'none'하면 DOM 오염으로 이어지고 결국 응용 프로그램 속도가 느려집니다.


경고! 부울 값에 대해서만 '더블 앰퍼샌드 (&&)'접근 방식을 사용하십시오. myComponents가 비어있는 배열 (예를 들어) 인 경우 {this.state.myComponents.length && <MyComponent />}는 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 />}

사실 일 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>이 변경되면 탭이 하나만 표시 되더라도 5 개의 탭이 모두 다시 렌더링됩니다.
    • 숨겨진 요소에는 여전히 일부 수명주기 메소드가 실행 중일 수 있습니다. 모든 업데이트 후에도 서버에서 일부 데이터를 가져올 수 있습니다.
    • 숨겨진 데이터가 잘못된 데이터를 수신하면 앱이 중단 될 수 있습니다. 상태를 업데이트 할 때 보이지 않는 노드에 대해 '잊어 버릴'수 있습니다.
    • 요소를 표시 할 때 실수로 '표시'스타일을 잘못 설정했을 수 있습니다 (예 : 일부 div는 기본적으로 'display : flex'이지만 display: invisible ? 'block' : 'none'레이아웃을 깨뜨릴 수있는 실수로 'display : block'을 설정 합니다
    • 사용하는 someBoolean && <SomeNode />것은 이해하기 쉽고 매우 간단합니다. 특히 무언가를 표시하는 것과 관련된 논리가 복잡 해지는 경우
    • 대부분의 경우 요소 상태가 다시 나타날 때 '재설정'하려고합니다. 예. 표시 될 때마다 초기 위치로 설정하려는 슬라이더가있을 수 있습니다. (이전 요소 상태가 숨겨져 있어도 IMO가 거의 발생하지 않는 것이 바람직한 동작이라면-이 상태를 다른 방식으로 기억하는 것이 복잡 할 경우 실제로 CSS를 사용하는 것이 좋습니다)

2
이것은 좋은 예입니다! 하나 개의 작은 것은, boxContent는 클래스 명 = "boxContent"해야
Bhetzie

5
여기에 버그가 있습니다 : this.setState({isOpened: !isOpened});. 상태를 수정할 때 상태 자체에 의존하지 마십시오. 다음은 좋은 예입니다 : reactjs.org/docs/… 따라서 다음과 같아야합니다 this.setState( s => ({isOpened: !s.isOpened}) ).. setState 내의 화살표 함수를 참고하십시오.
arcol

"디스플레이를 설정하는 경우 none-요소가 여전히 반응에 의해 렌더링되고 DOM에 추가되어 성능에 나쁜 영향을 줄 수 있음"을 확인하는 소스 / 벤치 마크 / 예가 있습니까? ?
neiya

@neiya하지 않습니다. CSS는 작은 요소로 성능이 높을 수 있지만, 예를 들어 콘텐츠의 큰 부분을 선택적으로 렌더링하려는 경우가 종종 있습니다. 탭. 또한 일부 요소는 CSS로 숨겨져 있지만 여전히 반응 형 세계에 살아 있습니다. 그것은 상태를 업데이트하고 일부 데이터를 가져 오는 등 비싸고 예기치 않은 동작을 유발할 수 있음을 의미합니다. 그리고 실제로 구현하기가 매우 간단합니다.
pie6k


11

나는 당신을 위해 이것을 처리하는 작은 구성 요소를 만들었습니다 : react-toggle-display

또는 props 를 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

이미 몇 가지 훌륭한 답변이 있지만, 나는 그들이 잘 설명되지 않았다고 생각하며 주어진 방법 중 일부에는 사람들을 여행 할 수있는 문제가 있습니다. 이 작업을 수행하고 장단점을 설명하는 세 가지 주요 방법 (한 가지 주제 이외의 옵션)을 살펴 보겠습니다. 옵션 1을 많이 권장하고 올바르게 사용하지 않으면 해당 옵션에 많은 잠재적 인 문제가 있기 때문에 주로 이것을 쓰고 있습니다.

옵션 1 : 부모의 조건부 렌더링.

구성 요소를 한 번만 렌더링하고 그대로 두지 않는 한이 방법이 마음에 들지 않습니다. 가시성을 토글 할 때마다 구성 요소가 처음부터 새로 작성되도록하는 문제가 발생합니다. 다음은 그 예입니다. 부모 LoginControl에서 LogoutButton 또는 LoginButton이 조건부로 렌더링됩니다. 이것을 실행하면 각 버튼 클릭시 생성자가 호출되는 것을 알 수 있습니다. 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, 렌더링 등의 코드가 비싸면 구성 요소 표시 속도가 크게 느려집니다. 또한 숨겨져있을 때 상태를 유지하고 표시 할 때 복원하려는 상태 저장 구성 요소에는이 기능을 사용할 수 없습니다. 한 가지 장점은 숨겨진 구성 요소를 선택할 때까지 전혀 만들지 않는다는 것입니다. 따라서 숨겨진 구성 요소는 초기 페이지로드를 지연시키지 않습니다. 전환 할 때 상태 저장 구성 요소를 재설정하려는 경우도 있습니다. 어떤 경우에는 이것이 최선의 선택입니다.

옵션 2 : 자식의 조건부 렌더링

이렇게하면 두 구성 요소가 한 번 생성됩니다. 그런 다음 구성 요소가 숨겨져 있으면 나머지 렌더링 코드를 단락시킵니다. visible prop을 사용하여 다른 방법으로 다른 로직을 단락시킬 수도 있습니다. 코드 펜 페이지에서 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는 첫 페이지로드시 모든 구성 요소의 init를 실행합니다. 첫로드를 느리게합니다. 다시 참고해야합니다. 조건에 따라 구성 요소를 한 번만 표시하고 전환하지 않거나 toggledm 일 때 재설정하려는 경우 옵션 1이 적합하고 아마도 가장 좋은 옵션 일 것입니다.

그러나 느린 페이지로드가 문제인 경우 수명주기 방법에 값 비싼 코드가 있으며 일반적으로 좋은 생각이 아닙니다. 고가의 코드를 라이프 사이클 메소드에서 제거하여 페이지로드 속도가 느려질 수 있습니다. ComponentDidMount에 의해 시작된 비동기 함수로 이동하고 콜백이 setState ()를 사용하여 상태 변수에 넣도록합니다. 상태 변수가 null이고 구성 요소가 표시되면 render 함수가 자리 표시자를 반환하도록합니다. 그렇지 않으면 데이터를 렌더링하십시오. 이렇게하면 페이지가 빠르게로드되고 탭이로드 될 때 채워집니다. 논리를 부모로 이동하고 결과를 자식으로 소품으로 푸시 할 수도 있습니다. 이렇게하면 먼저로드 할 탭의 우선 순위를 지정할 수 있습니다. 또는 결과를 캐시하고 구성 요소가 처음 표시 될 때만 로직을 실행하십시오.

옵션 3 : 수업 숨기기

클래스 숨기기는 아마도 구현하기 가장 쉬운 방법 일 것입니다. 언급했듯이 display : none으로 CSS 클래스를 만들고 prop를 기반으로 클래스를 할당하십시오. 단점은 모든 숨겨진 구성 요소의 전체 코드가 호출되고 모든 숨겨진 구성 요소가 DOM에 첨부됩니다. (옵션 1은 숨겨진 컴포넌트를 전혀 생성하지 않습니다. 그리고 옵션 2는 컴포넌트가 숨겨진 경우 불필요한 코드를 단락시키고 컴포넌트를 DOM에서 완전히 제거합니다.) 다른 답변이지만 말할 수는 없습니다.

옵션 4 : 하나의 구성 요소이지만 소품을 변경하십시오. 또는 구성 요소가 전혀없고 HTML을 캐시 할 수도 있습니다.

이것은 모든 응용 프로그램에서 작동하지는 않으며 구성 요소를 숨기는 것이 아니기 때문에 주제와는 관련이 없지만 일부 사용 사례의 경우 숨기는 것보다 더 나은 솔루션 일 수 있습니다. 탭이 있다고 가정 해 봅시다. 하나의 React Component를 작성하고 props를 사용하여 탭에 표시되는 내용을 변경할 수 있습니다. JSX를 상태 변수에 저장하고 소품을 사용하여 렌더링 함수에서 반환 할 JSX를 결정할 수도 있습니다. JSX를 생성해야하는 경우이를 수행하고이를 상위에 캐시하고 올바른 것을 소품으로 보냅니다. 또는 자식에서 생성하여 자식 상태로 캐시하고 props를 사용하여 활성 상태를 선택하십시오.


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>
     );
  }
}

여기

반응 고리 사용하기 :

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>
  )
}

여기


나는이 마른 대답을 좋아한다. 바이올린이 안타깝게도
Juan Lanus

이전 답변에서 언급했듯이의 상태에 의존this.setState() 해서는 안됩니다 .
Dan Dascalescu

8

상태 (예 : 'show)'에서 부울 값을 설정 한 후 다음을 수행하십시오.

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

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

나는 이것을 시도했지만 클릭 이벤트는 CSS를 표시 블록으로 전환하지 않았다. 나는 그것을 달성하는 방법에 정확하게 빠져 있습니다. 추가 팁이 있습니까?
user1725382

1
스타일 규칙 테이블을 적극적으로 변경해야합니다. 켜고 끌 수있는 기존 규칙 하나를 사용하는 것이 훨씬 좋습니다. 이는 dom 노드의 동적 속성의 일부가 아닙니다.
John Haugeland

1
여기서 클래스 나 스타일을 사용하는 것은 중요하지 않습니다.
Brigand

2
클래스를 사용하면 몇 배 더 빠릅니다. 알아두면 좋습니다.
Jason Rice

1
: 단지와 조건 클래스 이름을 사용할 수 github.com/JedWatson/classnames
backdesk

7

모범 사례는 설명서에 따라 다음과 같습니다.

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

상태가 유효한 경우에만 요소를 렌더링하십시오.


이 답변은 이미 주어진 그것의 OK 지금을 삭제하므로, 전년 동기.
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 방식을 사용하여 두 가지 방법으로 할 수 있습니다. 경우에 따라 아래 코드와 같은 것을 수행 할 수 있으므로 첫 번째 실행에서 결과 로 표시되지 않는 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);

이제 렌더 메소드에 로직을 추가해 봅시다 :

{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-경우 - 다른 모듈

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 조작

한 가지 방법은 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;
}

추신 : 내가 틀렸다면 나를 수정하십시오. :)


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
댄 Dascalescu

0

이 간결하고 짧은 구문을 사용하십시오.

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

어쩌면 간단하고 짧은 구문을 확장하여 작동 방식을 설명 할 수 있습니다. 아 잠깐만, 3 년 전에 답변을하였습니다 . 당신의 대답은 다시 테이블에 무엇을 가져 옵니까?
Dan Dascalescu

0

여기에 요소를 표시 / 숨기기위한 Classless React Component가있는 간단하고 효과적이며 최상의 솔루션이 제공됩니다. 의 사용 반작용 - 후크 최신에서 사용할 수 있습니다 만들-반응 - 응용 프로그램 프로젝트가 사용하는 것을 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.