React'te öğeyi gösterme veya gizleme


532

React.js ile ilk kez uğraşıyorum ve tıklama etkinliği aracılığıyla bir sayfada bir şey göstermek veya gizlemek için bir yol bulamıyorum. Sayfaya başka bir kütüphane yüklemiyorum, bu yüzden React kütüphanesini kullanarak yerel bir yol arıyorum. Şimdiye kadar sahip olduğum şey bu. Tıklama etkinliği tetiklendiğinde sonuç div'ı göstermek istiyorum.

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
Kabul edilen yorum, yerel düzeydeki mevcut teknolojinin diğer diller ve kütüphanelerle hem daha kolay, daha hızlı hem de paylaşılabilir bir şekilde yapabileceklerini yapmak için yeni teknoloji kullanır. Bunu standart CSS ile ele almak neredeyse kesinlikle daha iyi bir yanıttır.
John Haugeland

13
@JohnHaugeland, React çerçevesini kullanırken en iyi cevap, bazı durumlarda yapmanız gereken temizleme işlevlerine sahip olan tüm React stiline giden kabul edilen cevaptır. Bileşenlerin karanlıkta saklanması iyi bir uygulama değildir. Bir şeyleri karıştırırsanız, her zaman başka bir şeyden daha hızlı olan tüm yerel olanlara gitmeniz daha iyi olur.
Claudiu Hojda

4
Hayır, gerçekten değil. CSS'yi yeniden icat etmek için tepki kullanmak kötü bir fikirdir.
John Haugeland

8
Ayrıca, söylediklerimi tamamen kaçırmış görünüyorsunuz, bu, fiziksel olarak kaldırmak için React kullanmak yerine, öğeyi gizlemek ve göstermek için CSS kullanmaktı. Sen olabilir gizlemek için kullanılması CSS Tepkisiz kullanabilir ve aynı kolaylıkla elemanını gösterir: <div style = {{display: this.props.example}} />.
John Haugeland

5
@ClaudiuHojda karanlıkta gizlenen bileşenlere sahip olmak bazı durumlarda gerçekten çok iyi bir uygulama, css ile gizlenmiş olsalar bile HTML'de kalmak için bağlantılara ihtiyacınız olan duyarlı gezinmeyi düşünüyorum
Toni Leigh

Yanıtlar:


545

2020 dolaylarında tepki

In onClickcallback'inde, çağrı devlet Kanca durumunu güncellemek için ayarlayıcı fonksiyonu ve yeniden işlemek:

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 dolaylarında tepki

Anahtar, tıklama işleyicisindeki bileşenin durumunu kullanarak güncellemektir setState. Durum değişiklikleri uygulandığında, renderyöntem yeni durumla yeniden çağrılır:

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
Evet, devlet vs sahne hakkında iyi bir nokta. Bunu, arama çubuğunun ve sonuç tablosunun Sonuçları Arama'ya koymak yerine kardeş olduğu buradaki öğreticide olduğu gibi daha iyi bir yol olabilir: facebook.github.io/react/docs/thinking-in-react.html
Douglas

53
Diğer cevapta belirtildiği gibi, ekleme / silme basit sınıf maskelemesinden çok daha yavaştır.
John Haugeland

4
Johns yorumlarının gözden geçirilmesi gerektiğini düşünüyorum. Amaçlanan cevap ile gittim ve bu temiz ve 'daha hissettim' gibi tepki. Ancak, başlangıç ​​durumlarını ve monte edilmemiş bir bileşende yararlı bir şey ayarlayamadım. Bunun yerine şeyleri gizlemek için css kullanmaya bakıyorum. Monte edilmemiş bileşenlerin dinleyicileri sessizce başarısız olacak, bu da bugün büyük zaman kaybım oldu.
indi

Bu tepki, stil değiştiğinde (göster / gizle olarak ayarlanmış)!
alex

@ Kaçırmadım, bu şekilde orijinaline geri dönmeye izin vermez. Sanırım OP istememiş olabilir ama bunu nasıl ekleyebilirim?
Solucan

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'ın cevabında olduğu gibi koşullu olarak null değerini döndürmek daha iyidir. Bu, React'in DOM'dan tamamen kaldırılmasına izin verir. Sizin durumunuzda div ve içeriği hala DOM'da gösterilmiyor. Bunun performans üzerinde etkileri olabilir.
pmont

125
Performans etkileri, dom öğesi eklemek ve kaldırmak için, gizlemek ve göstermek için olduğundan daha kötüdür. Onun yaklaşımı ve benimki arasındaki farkın farkındayım ve bunun tamamen yanlış olduğuna inanıyorum. Lütfen "performans sonuçlarını" tanımlamak için zaman ayırın ve ardından ölçün.
John Haugeland

6
"Ekleme / kaldırma ile yeniden akışlar garanti edilir" - Kesinlikle konumlandırılmış öğelerle değil, Famous'ın inanılmaz performansı bu şekilde elde edilir. Ancak metrikler üzerinde geçerli bir noktaya değindiniz.
pmont

9
değer için, buradaki tepki belgelerinde belirtilmiştir: facebook.github.io/react/docs/…
Brad Parks

85
Ben sadece 161 oldukça büyük dom düğümleri ile gizli bir sınıf ayarlama vs null dönen test etti. Bir sınıfı kullanmak, düğümü kaldırmaktan çok daha hızlıdır.
Jonathan Rowny

120

Üçlü operatör için alternatif bir sözdizimi:

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

şuna eşittir:

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

Yalın neden


Ayrıca alternatif sözdizimi ile display: 'none';

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

Ancak, aşırı kullanırsanız display: 'none', bu DOM kirliliğine yol açar ve sonuçta uygulamanızı yavaşlatır.


Uyarı! 'Bool değerleri için' çift ve işareti (&&) 'yaklaşımını kullanın. {this.state.myComponents.length && <Bileşenim />}, eğer Bileşenlerim boş diziyi (örneğin) 0 olarak işleyecek
Mega Proger

57

İşte yaklaşımım.

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

Yukarıdaki kodda, bunu başarmak için, aşağıdaki gibi kod kullanıyorum:

{opened && <SomeElement />}

Bu SomeElementsadece openeddoğru olduğunda gerçekleşir. JavaScript'in mantıksal koşulları nasıl çözdüğü nedeniyle çalışır:

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 yerine '' bu yaklaşımı kullanmanın nedenleri '' display: none ';

  • Bir öğeyi CSS ile gizlemek 'daha ucuz' olsa da - bu durumda 'gizli' öğe tepki dünyasında hala 'canlı'dır (bu aslında çok daha pahalı olabilir)
    • bu, üst öğenin (ör. <TabView>) sahne parçalarının değişeceği anlamına gelir - yalnızca bir sekme görseniz bile, 5 sekmenin tümü yeniden oluşturulacaktır
    • gizli öğenin hala çalışan bazı yaşam döngüsü yöntemleri olabilir - ör. görünür olmasa bile her güncellemeden sonra sunucudan bazı veriler alabilir
    • gizli öğe yanlış veri alırsa uygulamayı kilitleyebilir. Durumu güncellerken görünmez düğümleri 'unutabileceğiniz' gibi olabilir
    • öğeyi görünür hale getirirken yanlışlıkla yanlış 'görüntü' stili ayarlayabilirsiniz - ör. bazı div varsayılan olarak 'display: flex'dir, ancak yanlışlıkla' display: block 'ayarınıdisplay: invisible ? 'block' : 'none' düzenini bozabilir hangi
    • kullanarak someBoolean && <SomeNode />sizin mantık şey görüntüleyerek ilgili özellikle anlamak ve yaklaşık nedeni çok basittir edilir ya da değil karmaşık alır
    • çoğu durumda, yeniden göründüğünde eleman durumunu 'sıfırlamak' istersiniz. Örneğin. her gösterildiğinde başlangıç ​​konumuna ayarlamak istediğiniz bir kaydırıcıya sahip olabilirsiniz. (önceki öğe durumunu korumak için istenen davranış, gizli olsa bile, hangi IMO nadirdir - bu durumu farklı bir şekilde hatırlamak karmaşık olursa gerçekten CSS kullanmayı düşünürüm)

2
Bu harika bir örnek! Küçük bir şey, boxContent className = "boxContent" olmalıdır
Bhetzie

5
Burada bir hata var: this.setState({isOpened: !isOpened});. Durumu değiştirdiğinizde durumun kendisine bağımlı olmayın. İşte iyi bir örnektir: reactjs.org/docs/... olması gerektiği Yani: this.setState( s => ({isOpened: !s.isOpened}) ). SetState içindeki ok işlevine dikkat edin.
arcol

Bunu onaylayan herhangi bir kaynağınız / karşılaştırmanız / örneğiniz var mı? Görüntüyü ayarlarsanız: none - öğesi yine de tepkiyle oluşturulup DOM'a eklenir - performans üzerinde kötü etkisi olabilir. " ?
neiya

@neiya bilmiyorum. CSS, küçük öğelerle daha yüksek performans gösterebilir, ancak çoğu zaman isteğe bağlı olarak içeriğin büyük bölümlerini oluşturmak istersiniz. sekmesi. Ayrıca, bazı öğeler CSS ile gizlenmiş olsa da, reaksiyon dünyasında hala hayatta. Bu, durumunu güncelleyebileceği, pahalı olabileceği ve beklenmedik davranışlara yol açabilecek bazı verileri vb. Getirebileceği anlamına gelir. Ve IMO'nun uygulanması gerçekten çok basit.
pie6k


11

Bunu sizin için halleden küçük bir bileşen oluşturdum: tepki-geçiş-görüntüleme

Stil özniteliğini veya sahne öğelerine display: none !importantgöre ayarlar .hideshow

Örnek kullanım:

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

Zaten birkaç harika cevap var, ama çok iyi açıklandıklarını sanmıyorum ve verilen yöntemlerin birçoğu insanları gezebilecek bazı gotchalar içeriyor. Bu yüzden bunu yapmak ve artıları ve eksileri açıklamak için üç ana yoldan (artı bir konu dışı seçenek) geçeceğim. Çoğunlukla bunu yazıyorum çünkü Seçenek 1 çok tavsiye edildi ve doğru kullanılmazsa bu seçenekle ilgili birçok potansiyel sorun var.

Seçenek 1: Üst öğede Koşullu İşleme.

Bileşeni yalnızca bir kez oluşturup orada bırakmayacaksanız bu yöntemi sevmiyorum. Sorun, görünürlüğü her değiştirdiğinizde bileşenin sıfırdan bileşen oluşturmasına neden olmasıdır. İşte örnek. LogoutButton veya LoginButton, üst LoginControl öğesinde koşullu olarak oluşturuluyor. Bunu çalıştırırsanız, her düğme tıklamasında kurucunun çağrıldığını göreceksiniz. 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, sıfırdan bileşenler oluşturma konusunda oldukça hızlı. Ancak, kodunuzu oluştururken yine de kodunuzu çağırması gerekir. Bu nedenle, kurucunuz, componentDidMount, render vb. Kodunuz pahalıysa, bileşeni göstermede önemli ölçüde yavaşlar. Ayrıca, gizli olduğunda (ve görüntülendiğinde geri yüklendiğinde) durumun korunmasını istediğiniz durum bilgisi olan bileşenlerle bunu kullanamayacağınız anlamına gelir. Bir avantaj, gizli bileşenin seçilene kadar hiç oluşturulmamasıdır. Böylece gizli bileşenler ilk sayfa yüklemenizi geciktirmez. Değiştirildiğinde sıfırlamak için durum bilgisi olan bir bileşenin İSTENİLMESİ durumları da olabilir. Bu durumda bu en iyi seçeneğinizdir.

Seçenek 2: Çocukta Koşullu Görüntü Oluşturma

Bu, her iki bileşeni de bir kez oluşturur. Daha sonra, bileşen gizlenmişse render kodunun geri kalanını kısa devre yapar. Görünür pervaneyi kullanarak diğer yöntemlerde diğer mantığı kısa devre yapabilirsiniz. Kod açıklığı sayfasında console.log dosyasına dikkat edin. 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')
);

Şimdi, başlatma mantığı hızlıysa ve çocuklar vatansızsa, performans veya işlevsellikte bir fark görmezsiniz. Ancak, React'i her geçişte neden yepyeni bir bileşen oluştursun? Ancak başlatma pahalıysa, geçiş sırasında sayfayı yavaşlatan bir bileşeni her değiştirişinizde Seçenek 1 çalışacaktır. Seçenek 2, ilk sayfa yüklemesinde bileşenin tüm inits'lerini çalıştıracaktır. İlk yükü yavaşlatıyor. Tekrar not etmeliyim. Bileşeni yalnızca bir koşula bağlı olarak bir kez gösteriyorsanız ve değiştirmiyorsanız veya değiştirdiğinizde sıfırlanmasını istiyorsanız, Seçenek 1 iyidir ve muhtemelen en iyi seçenektir.

Ancak yavaş sayfa yüklemesi bir sorunsa, bir yaşam döngüsü yönteminde pahalı bir kodunuz olduğu anlamına gelir ve bu genellikle iyi bir fikir değildir. Pahalı kodu yaşam döngüsü yöntemlerinden çıkararak yavaş sayfa yükünü çözebilirsiniz ve muhtemelen çözmelisiniz. ComponentDidMount tarafından başlatılan bir zaman uyumsuz işlevine taşıyın ve geri çağrıyı setState () ile bir durum değişkenine koymasını sağlayın. Durum değişkeni null ise ve bileşen görünürse, oluşturma işlevinin bir yer tutucu döndürmesini sağlayın. Aksi takdirde verileri oluşturun. Bu şekilde sayfa hızla yüklenir ve sekmeler yüklendikçe doldurulur. Ayrıca mantığı ebeveyne taşıyabilir ve sonuçları sahne olarak çocuklara aktarabilirsiniz. Bu şekilde önce hangi sekmelerin yükleneceğine öncelik verebilirsiniz. Veya sonuçları önbelleğe alın ve mantığı yalnızca bir bileşen ilk kez gösterildiğinde çalıştırın.

Seçenek 3: Sınıf Gizleme

Sınıf gizleme muhtemelen uygulaması en kolay olanıdır. Belirtildiği gibi, sadece display: none ile bir CSS sınıfı oluşturursunuz ve sınıfı prop'ye göre atarsınız. Dezavantajı, her gizli bileşenin kodunun tamamıdır ve tüm gizli bileşenler DOM'a eklenir. (Seçenek 1, gizli bileşenleri hiç oluşturmaz. Bileşen gizlendiğinde ve bileşen DOM'dan tamamen kaldırıldığında Seçenek 2 kısa devre kodlarına gereksiz kodlar ekler.) diğer cevaplar ama bununla konuşamam.

Seçenek 4: Tek bileşenli ancak Props'u değiştir. Ya da hiç bileşen ve HTML önbellek.

Bu, her uygulama için çalışmaz ve konu dışıdır çünkü bileşenleri gizlemekle ilgili değildir, ancak bazı kullanım durumları için gizlemekten daha iyi bir çözüm olabilir. Diyelim ki sekmeleriniz var. Bir React Bileşeni yazmak ve sekmede görüntülenenleri değiştirmek için sadece propsları kullanmak mümkün olabilir. Ayrıca JSX'i durum değişkenlerine kaydedebilir ve oluşturma işlevinde hangi JSX'in döndürüleceğine karar vermek için bir prop kullanabilirsiniz. JSX oluşturulması gerekiyorsa, bunu yapın ve üst öğede önbelleğe alın ve doğru olanı prop olarak gönderin. Ya da çocukta oluşturun ve çocuğun durumunda önbellekleyin ve aktif olanı seçmek için sahne kullanın.


9

Bu, sanal DOM'dan yararlanmanın güzel bir yoludur :

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

Burada örnek

React kancalarını kullanma:

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

Burada örnek


Bu yalın yanıtı seviyorum. Yazık koşmazdı.
Juan Lanus

Daha önceki bir cevapta belirtildiği gibi , içindeki duruma bağlıthis.setState() olmamalısınız .
Dan Dascalescu

8

Durumda (örneğin 'göster)' bir boole değeri ayarlarsınız ve sonra şunları yaparsınız:

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

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

Bunu denedim, ancak click olayı css'yi görüntülemek için değiştirmedi. Tam olarak nasıl başaracağım konusunda kayboldum. Başka ipucu var mı?
user1725382

1
Bu, stil kuralı tablosunda etkin değişiklikler yapmayı içerir. Dom düğümünün dinamik özelliklerinin bir parçası olmayan açıp kapatabileceğiniz mevcut tek bir kurala sahip olmak çok daha iyidir.
John Haugeland

1
Burada bir sınıf veya stil kullanmanızın bir önemi yok ... bu konuda çok çalıştınız.
Brigand

2
Sınıf kullanımı birkaç büyüklükte daha hızlıdır. Bunu bilmek güzel.
Jason Rice

1
Koşullu sınıf adlarını şu şekilde kullanabilirsiniz: github.com/JedWatson/classnames
backdesk

7

En iyi uygulama belgelere göre aşağıdadır:

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

Elemanı yalnızca durum geçerli olduğunda oluşturun.


Bu yanıt zaten bir yıl önce verildi , bu yüzden şimdi silmeniz uygun.
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 ekibinden şu ifadeyle başlıyorum:

React'te, ihtiyacınız olan davranışı kapsayan farklı bileşenler oluşturabilirsiniz. Ardından, uygulamanızın durumuna bağlı olarak yalnızca bir kısmını oluşturabilirsiniz.

React'ta koşullu oluşturma, JavaScript'teki koşullarla aynı şekilde çalışır. Geçerli durumu temsil eden öğeler oluşturmak için if veya koşullu işleç gibi JavaScript işleçlerini kullanın ve React'in kullanıcı arayüzüyle eşleşecek şekilde güncellenmesine izin verin.

Temelde düğme tıklandığında bileşeni göstermeniz gerekir, saf React kullanarak veya CSS kullanarak, saf React yolu kullanarak iki şekilde yapabilirsiniz, ilk durumda, sonuçta aşağıdaki kod gibi bir şey yapabilirsiniz. olarak gösterilmiyor hideResultsolduğunu trueancak düğme, devlet değişmeyecek tıklayarak ve hideResultsolduğu falseve yeni değer koşulları ile tekrar render bileşen olsun, bu tepki bileşen görünümü değişen çok yaygın kullanımıdır ...

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'de koşullu oluşturma konusunda daha fazla çalışma yapmak istiyorsanız, buraya bir göz atın .


1
bu en zarif yol olmalı!
Beşinci

4

React Hooks ile basit gizle / göster örneği:

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
sadece {show? 1: 2}
Piotr Żak

3

Bir komponentin ekranını nasıl değiştireceğinizi görmek istiyorsanız bu kemanı kontrol edin.

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

Kanca kullanarak React'taki öğeleri göstermek / gizlemek için basit bir yöntem

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

Şimdi render yöntemimize biraz mantık ekleyelim:

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

Ve

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

Aferin.


2

Bazı durumlarda, yüksek dereceli bileşen yararlı olabilir:

Daha yüksek sipariş bileşeni oluşturma:

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

Kendi bileşeninizi genişletin:

export const MyComp= HidableComponent(MyCompBasic);

O zaman bu şekilde kullanabilirsiniz:

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

Bu biraz kaynatma plakasını azaltır ve adlandırma kurallarına bağlı kalmayı zorunlu kılar, ancak MyComp'un hala somutlaştırılacağını unutmayın - atlamanın yolundan daha önce bahsedildi:

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


1

Rc-if-else modülünü kullanın

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 kullanın ve CSS'yi değiştirin

Bunun bir yolu React'leri refkullanmak ve tarayıcının API'sını kullanarak CSS sınıfını değiştirmek olabilir . Avantajı, tek amaç bir düğmeyi tıklatarak bazı DOM öğelerini gizlemek / göstermekse React'a yeniden göndermekten kaçınmaktır.

// 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 Yanılıyorsam düzelt. :)


Oluşturulan codesandbox.io örneği, burada: utgzx.csb.app , kod codesandbox.io/embed/react-show-hide-with-css-utgzx
Ağustos'ta PatS

0

Bootstrap 4 kullanıyorsanız, öğeyi bu şekilde gizleyebilirsiniz

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

0

Bu da böyle yapılabilir (çok kolay bir yol)

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

Lütfen reaktjs.org/docs/react-component.html#setstate adresinde "önceki duruma göre durum" ayarını okuyun . Ayrıca, sonunda girintiyi düzeltmek güzel olurdu.
Dan Dascalescu

0

bu örnek, her 1 saniyeden sonra değişen bir geçiş kullanarak bileşenler arasında nasıl geçiş yapabileceğinizi gösterir

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

Garip resim URL'si nedir? Placeimg.com
Dan Dascalescu

0

Bu yalın ve kısa sözdizimini kullanın:

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

Belki nasıl çalıştığını açıklamak için yalın ve kısa sözdiziminizi genişletebilirsiniz. Oh bekleyin, bu 3 yıl önce bir cevapta yapıldı . Cevabınız tekrar masaya ne getiriyor?
Dan Dascalescu

0

Öğeleri göstermek / gizlemek için Sınıfsız Tepki Bileşeni ile basit, etkili ve en iyi çözüm geliyor. React 16 kullanan en yeni oluştur-tepki-uygulama projesinde bulunan React-Hooks kullanımı

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;

Mutlu Kodlama :)


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 dosyasını kullanabilirsiniz

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

ve css dosyasında

    .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
Ne yaptığınızı ve neden kabul edilen cevaptan daha iyi olduğunu açıklayabilir misiniz?
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>
    );
  }
}

Daha iyi anlamak için açıklama ekleyebilir misiniz? Teşekkürler!
Shanteshwar Inde

@ShanteshwarInde: Bu , geçerli duruma bağlı olarak setState öğesinin yanlış kullanımı da dahil olmak üzere , aynı fikri önceki bir yanıttan kopyalar. Bakınız reaktjs.org/docs/react-component.html#setstate : " Durumu önceki duruma göre ayarlamanız gerekiyorsa, güncelleyici bağımsız değişkenini okuyun".
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
Bu kod soruyu cevaplayabilirken, bu kodun soruyu neden ve / veya nasıl cevapladığı konusunda ek bağlam sağlamak uzun vadeli değerini arttırır.
xiawi

@Xiawi ne dedi. Ayrıca, sabit beyan ederken constyerine kullanın var.
Dan Dascalescu
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.