React'teki durum ve sahne arasındaki fark nedir?


559

React ile ilgili Çoğul Görüş kursunu izliyordum ve eğitmen, aksesuarların değiştirilmemesi gerektiğini söyledi. Şimdi sahne vs devlet hakkında bir makale (uberVU / tepki-rehber) okuyorum ve diyor

Hem sahne hem de durum değişiklikleri bir render güncellemesini tetikler.

Makalenin ilerleyen bölümlerinde şöyle yazıyor:

Sahne (özelliklerin kısaltması) bir Bileşenin yapılandırmasıdır, varsa seçenekleri. Yukarıdan alınırlar ve değişmezler.

  • Yani aksesuarlar değişebilir ama değişmez olmalılar mı?
  • Sahne ne zaman ve ne zaman devlet kullanmalısınız?
  • Bir React bileşeninin ihtiyaç duyduğu verilere sahipseniz, React bileşenindeki desteklerden veya kurulumdan getInitialStatemı geçilmelidir ?


7
bu çok güzel bir soru, aslında, hiç kimse basit bir cevap vermiyor gibi görünüyor: /
Thomas Decaux

Yanıtlar:


670

Sahne ve devlet birbiriyle ilişkilidir. Bir bileşenin durumu genellikle bir alt bileşenin desteği olacaktır. Dikmeler alt React.createElement()öğeye render yöntemi içinde alt öğeye veya JSX kullanıyorsanız daha tanıdık etiket niteliklerine geçirilir.

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

Ebeveynin devlet değeri childsNameçocuğun olur this.props.name. Çocuğun bakış açısından, prop adı değişmezdir. Değiştirilmesi gerekiyorsa, ebeveyn yalnızca dahili durumunu değiştirmelidir:

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

ve React bunu sizin için çocuğa yayacaktır. Doğal bir takip sorusu şudur: çocuğun isim pervanesini değiştirmesi gerekiyorsa ne olur? Bu genellikle alt etkinlikler ve üst geri çağrılar aracılığıyla yapılır. Çocuk, örneğin adlı bir olayı açığa çıkarabilir onNameChanged. Ebeveyn daha sonra geri arama işleyicisini geçirerek etkinliğe abone olur.

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

Çocuk, istenen yeni adını örneğin çağrı yaparak olay geri aramasına argüman olarak iletir this.props.onNameChanged('New name')ve üst öğe, durumunu güncellemek için olay işleyicideki adı kullanır.

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

2
Teşekkürler! Peki birkaç soru daha: 1. İnsanlar neden sahne malzemelerinin değişmemesi gerektiğini söylüyor? 2. Veri önyüklemenizi nereye koyarsınız? GetInitialState gibi bir bileşenin başlatılmasında ya da bileşenin dışına koyup veri kullanılabilir olduğunda bileşeni oluşturuyor musunuz?
skaterdav85

37
1. Bu, React'in 'işlevsel' yönüdür. Tüm veriler (neredeyse) aşağıya doğru akar. Prop ebeveyne ait olduğundan, yalnızca ebeveyn değiştirmelidir. İdeal olarak, çocuklar vatansız olmalıdır. Bu pratikte mümkün değildir (React sitesindeki form belgelerine bakın). 2. Tavsiye edilen bir uygulama olan üst kısımdan besleyebilir veya ayrı nesnelerde saklayabilirsiniz. Popüler bir yaklaşım, Mağazalar adlı tektonlu nesneleri kullanan Flux'tur. Bu daha büyük bir mimari modelin parçasıdır. Ayrıca Facebook'tan açıktır ve React ile çalışmak üzere tasarlanmıştır.
Todd

2
mağazalar büyük küresel değişkenler gibi mi?
SuperUberDuper

3
Evet, Flux depoları istemci tarafı önbellekleridir. Facebook'tan ve Redux'dan yakın zamanda piyasaya sürülen Relay gibi başka desenler de var.
Todd

6
Biraz aşağı bu kaynatın için: devlet içinden yönetilmektedir bileşen veri, sahne olan yukarıdan yönetilen ve geçirilen içinde olan bileşen verilerdir.
Mark

221

Ebeveyn-çocuk iletişimi için, sadece sahne geçmek.

Geçerli sayfanızın gereksinim duyduğu verileri denetleyici görünümünüzde saklamak için durumu kullanın .

Veri ve olay işleyicilerini alt bileşenlerinize aktarmak için sahne araçlarını kullanın .

Bu listeler, bileşenlerinizdeki verilerle çalışırken size rehberlik etmelidir.

sahne donanımı

  • değişmez
    • React'in hızlı referans kontrolleri yapmasını sağlar
  • görüntüleme denetleyicinizden veri aktarmak için kullanılır
    • üst düzey bileşeniniz
  • daha iyi performansa sahip olmak
    • verileri alt bileşenlere aktarmak için bunu kullanın

Durum

  • görünüm denetleyicinizde yönetilmelidir
    • üst düzey bileşeniniz
  • değiştirilebilir
  • daha kötü performansa sahip
  • alt bileşenlerden erişilmemelidir
    • bunun yerine sahne ile geçir

Ebeveyn-çocuk ilişkisi olmayan iki bileşen arasındaki iletişim için kendi global olay sisteminizi kurabilirsiniz. ComponentDidMount () içindeki olaylara abone olun, componentWillUnmount () öğesinden çıkın ve bir olay aldığınızda setState () öğesini çağırın. Akı deseni bunu düzenlemenin olası yollarından biridir. - https://facebook.github.io/react/tips/communicate-between-components.html

Hangi Bileşenlerin Durumu Olmalıdır?

Bileşenlerinizin çoğunun, sahne malzemelerinden bazı verileri alması ve oluşturması gerekir. Ancak, bazen kullanıcı girdisine, bir sunucu isteğine veya zamanın geçişine yanıt vermeniz gerekir. Bunun için devlet kullanıyorsunuz.

Bileşenlerinizi mümkün olduğunca vatansız tutmaya çalışın . Bunu yaparak, durumu en mantıklı yerine izole edecek ve fazlalığı en aza indirerek uygulamanız hakkında akıl yürütmeyi kolaylaştıracaksınız.

Yaygın bir örüntü, sadece verileri işleyen ve durumlarını sahne aracılığıyla çocuklarına geçiren hiyerarşide üzerinde durum bilgisi olan bir bileşene sahip birkaç durumsuz bileşen oluşturmaktır . Durum bilgisi olmayan bileşen tüm etkileşim mantığını kapsar, vatansız bileşenler ise verileri bildirimsel bir şekilde oluşturmaya özen gösterir. - https://facebook.github.io/react/docs/interactivity-and-dynamic-uis.html#what-components-should-have-state

Devlette Neler Olmalı?

Durum, bir bileşenin olay işleyicilerinin UI güncellemesini tetiklemek için değiştirebileceği veriler içermelidir. Gerçek uygulamalarda bu veriler çok küçük ve JSON serileştirilebilir olma eğilimindedir. Durum bilgisi olan bir bileşen oluştururken, durumunun mümkün olan en az gösterimini düşünün ve bu özellikleri yalnızca bu.state içinde depolayın. Render () içinde bu duruma bağlı olarak ihtiyacınız olan diğer bilgileri hesaplayın. Uygulamaları bu şekilde düşünmenin ve bu şekilde yazmanın en doğru uygulamaya yol açacağını göreceksiniz, çünkü duruma gereksiz veya hesaplanmış değerler eklemek, bunları sizin için hesaplamaya tepki vermek yerine bunları açıkça senkronize tutmanız gerektiği anlamına gelir. - https://facebook.github.io/react/docs/interactivity-and-dynamic-uis.html#what-should-go-in-state


2
katılmıyorum, tüm sahne gitmek aslında veri aktarmak için daha az performans. Sadece alt bileşenler için mağaza ayarlayın, o zaman sahne karışıklığı ile uğraşmak zorunda değilsiniz ve sahne değişikliği olduğunda bileşenlerinizi güncellemeniz gerekir. Sadece mağazanızı güncelleyin ve bileşenin verilerini mağazasından almasına izin verin.
PositiveGuy

Bana sahne neden devletlerden daha fazla performans olduğunu söyleyebilir misiniz. Teşekkürler.
hqt

@hqt Bence değişmez olduğu için değerleri değiştirmek için iç karşılaştırmalar daha hızlı
Gaspar

@BentOnCoding, iyi günler, lütfen yardım edebilirsin. Durum böyle düşünebilir miyim Ne zaman KULLANICI ETKİLEŞİMİ bir bileşen içinde değişecek veri var, bu nerede devlet kullanılır?
Dickens

72

Düzgün JS işlevleriyle ilişkilendirerek en iyi şekilde anlayabilirsiniz.

Basit ifadeyle,

Durum , bileşenin dışında erişilemeyen ve değiştirilemeyen bileşenin yerel durumudur. Bir işlevdeki yerel değişkenlere eşdeğerdir.

Düz JS İşlevi

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

Reaksiyon Bileşeni

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

Dikmeler , diğer taraftan, marka bileşenleri bileşenleri sahne şeklinde, üst bileşen veri alma olanağı vererek, yeniden kullanılabilir. Fonksiyon parametrelerine eşdeğerdirler.

Düz JS İşlevi

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

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

Reaksiyon Bileşeni

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

}

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

Kredi: Manoj Singh Negi

Makale Bağlantısı: Tepki Durumu ve Props açıklaması


16
Bu aslında çok yardımcı bir cevap. Bunu okuduktan sonra daha eksiksiz cevapları anlayabiliyorum. Teşekkürler.
Aaron

1
React component = plain JS işlevi bunu açıkça açıklamak için mükemmel bir yoldur. React gittikçe daha fazla işlevsel bileşenlere doğru ilerlerken, bu durum kelimenin tam anlamıyla daha da artmaktadır.
JD Sandifer

1
okuduğum en iyi açıklama, teşekkür ederim
iWizard

48

Sahne vs devlet özeti En sevdiğim burada: tepki- bu adamlara büyük şapka ipucu. Aşağıda, bu sayfanın düzenlenmiş bir sürümü bulunmaktadır:


devlet vs sahne

tl; dr Bir Bileşenin belirli bir zamanda özniteliklerinden birini değiştirmesi gerekiyorsa, bu öznitelik durumunun bir parçası olmalıdır, aksi takdirde yalnızca bu Bileşen için bir destek olmalıdır.


sahne donanımı

Sahne donanımı (özelliklerin kısaltması) bir Bileşenin yapılandırmasıdır. Bunlar yukarıdan alınır ve bunları alan Bileşen açısından değişmez. Bir Bileşen, desteklerini değiştiremez, ancak alt Bileşenlerinin desteklerini bir araya getirmekten sorumludur. Sahne yalnızca veri olmak zorunda değildir - geri arama işlevleri sahne olarak aktarılabilir.

durum

Durum, Bileşen takıldığında varsayılan değerle başlayan bir veri yapısıdır. Çoğunlukla kullanıcı olaylarının bir sonucu olarak zaman içinde değişebilir.

Bir Bileşen kendi durumunu dahili olarak yönetir. Bir başlangıç ​​devleti kurmanın yanı sıra, çocuklarının devletiyle uğraşması da yoktur. Durumu bu bileşene özel olarak kavramsallaştırabilirsiniz.

Sahne ve durumu değiştirme

                                                   sahne devleti
    Üst bileşenden başlangıç ​​değeri alabilir mi? Evet evet
    Üst Bileşen tarafından değiştirilebilir mi? Evet Hayır
    Bileşen içindeki varsayılan değerleri ayarlayabilir mi? * Evet Evet
    Bileşen içinde değişiklik yapabilir mi? Hayır Evet
    Alt Bileşenler için başlangıç ​​değeri ayarlayabilir mi? Evet evet
    Alt Bileşenlerde değişiklik olabilir mi? Evet Hayır
  • Ebeveynlerden alınan hem sahne hem de durum başlangıç ​​değerlerinin, Bileşen içinde tanımlanan varsayılan değerleri geçersiz kıldığını unutmayın.

Bu Bileşenin durumu olmalı mı?

Durum isteğe bağlıdır. Durum karmaşıklığı arttırdığı ve öngörülebilirliği azalttığı için Durumsuz bir Bileşen tercih edilir. Etkileşimli bir uygulamada durum olmadan açıkça yapamasanız bile, çok fazla Durumsal Bileşen'den kaçınmalısınız.

Bileşen türleri

Vatansız Bileşen Yalnızca sahne, durum yok. Render () işlevinin yanında fazla bir şey yoktur. Mantıkları aldıkları sahne etrafında döner. Bu onları takip etmeyi ve test etmeyi çok kolaylaştırır.

Durumsal Bileşen Hem sahne hem de durum. Bunlar, bileşeninizin bir durumu koruması gerektiğinde kullanılır. Bu, istemci-sunucu iletişimi (XHR, web soketleri, vb.), Verileri işlemek ve kullanıcı olaylarına yanıt vermek için iyi bir yerdir. Tüm görselleştirme ve biçimlendirme mantığı, aşağı yukarı birçok Vatansız Bileşene taşınması gerekirken, bu tür lojistiklerin az sayıda Durumsal Bileşenler içinde kapsüllenmesi gerekir.

kaynaklar


1
"ebeveynden alınan başlangıç ​​değeri" ne demek? Bildiğim kadarıyla devlet sadece tek bir bileşen kapsamında tanımlanır ve doğrudan dışarıdan değiştirilemez.
Maxim Kuzmin

@MaximKuzmin Bunun 'renk' gibi bir durumu başlatmak için 'initialColor' gibi bir pervane alma ortak modeline bir referans olduğuna inanıyorum. Devlete başlangıçta pervaneden (ebeveynden alınan) değer verilir ve bundan sonra normal durum gibi davranmaya devam eder. Bunu devlete karşı sahne girişine dahil etmek biraz kafa karıştırıcı olabilir, ancak bilmek önemli bir modeldir.
JD Sandifer

18

sahne ("özellik" kısaltması) ve durum her ikisi de düz JavaScript nesneleridir. Her ikisi de oluşturma çıktısını etkileyen bilgileri tutarken, bunlar önemli bir şekilde farklıdır: sahne bileşenleri bileşene aktarılır (işlev parametrelerine benzer), durum bileşen içinde yönetilir (bir işlev içinde bildirilen değişkenlere benzer).

Basitçe durum mevcut bileşeninizle sınırlıdır, ancak aksesuarlar istediğiniz herhangi bir bileşene geçirilebilir ... Geçerli bileşenin durumunu diğer bileşenlere destek olarak geçirebilirsiniz ...

Ayrıca React'te, sadece sahne olan ve iç durum olmayan vatansız bileşenlere sahibiz ...

Aşağıdaki örnek, uygulamanızda nasıl çalıştıklarını gösteren örnek:

Üst (durum-dolu bileşen):

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

Alt (eyaletsiz bileşen):

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

11

Sahne ve durum arasındaki temel fark, durumun dahili olması ve bileşenin kendisi tarafından kontrol edilmesidir; sahne donanımı ise dış ve bileşeni oluşturan her şey tarafından kontrol edilir.

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

Devlet VS Sahne

  • Durum değiştirilebilir (Değişebilir)
  • Oysa Sahne yapamıyor (Değişmez)

7

Temel olarak, fark, durumun OOP'deki nitelikler gibi bir şey olmasıdır : onu daha iyi tanımlamak için kullanılan bir sınıf (bileşen) için yerel bir şeydir . Sahne parametreleri gibidir - bir bileşenin (üst öğe) çağıranından bir bileşene aktarılır : sanki belirli parametrelerle bir işlevi çağırdınız.


5

Reaksiyondaki hem durum hem de sahne donanımı , verileri bir bileşene kontrol etmek için kullanılır, genellikle sahne öğeleri ebeveyn tarafından ayarlanır ve alt bileşenlere geçirilir ve bileşen boyunca sabitlenir. Değişecek veriler için durum kullanmalıyız. Durumlar değiştirilebilir durumdayken sahne değiştirilemez , sahne öğelerini değiştirmek isterseniz üst bileşenden yapabilir ve ardından alt bileşenlere iletebilirsiniz.


4

tepki ile çalışırken öğrendiğim gibi.

  • aksesuarlar bir bileşen tarafından harici ortamdan veri almak için kullanılır ( başka bir bileşen (saf, işlevsel veya sınıf) veya genel bir sınıf veya javascript / daktilo kodu

  • devletler kullanılan bir bileşen iç ortamını yönetmek için araçlar veri değiştirirbileşenin


3

Props: Props, bileşenin ve tepki bileşeninin özelliğinden başka bir şey değildir.

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

sabit eleman =;

burada <Welcome name="Sara" />Hoşgeldin bileşeninin sahne donanımı olarak bir {name: 'Sara'} nesnesi geçiyor. Bir ana bileşenden alt bileşene veri aktarmak için sahne kullanıyoruz. Sahne değişmez. Bir bileşenin yaşam döngüsü sırasında sahne değişmemelidir (değişmez olarak düşünün).

Durum: duruma yalnızca Bileşen içinden erişilebilir. Bileşen içindeki verileri takip etmek için durum kullanıyoruz. setState ile durumu değiştirebiliriz. Devleti çocuğa geçirmemiz gerekiyorsa, bunu sahne olarak geçirmemiz gerekir.

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

Durum:

  1. devletler değişebilir.
  2. tek tek bileşenlerle ilişkilendirilen durumlar diğer bileşenler tarafından kullanılamaz.
  3. durumlar bileşen montajında ​​başlatılır.
  4. durumlar, bileşen içinde dinamik değişiklikler oluşturmak için kullanılır.

sahne:

  1. sahne değiştirilemez.
  2. bileşenleri bileşenler arasında geçirebilirsiniz.
  3. aksesuarlar çoğunlukla bileşenler arasında iletişim kurmak için kullanılır. ebeveynden çocuğa doğrudan geçebilirsiniz. Çocuktan ebeveyne geçmek için devletleri kaldırma kavramını kullanmanız gerekir.

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": "Yakalanmayan Sözdizimi Hata : Beklenmedik belirteç <", "dosyaadı": " stacksnippets.net/js ", "lineno": 17, "colno": 9}
Niko Jojo

2

Temel olarak, sahne donanımı ve durum, bileşenin neyi ve nasıl oluşturulacağını bilmesi için iki yöntemdir. Uygulama durumunun hangi kısmı eyalete ait ve hangisi üst düzey mağaza için React'in nasıl çalıştığından daha fazla uygulama tasarımınızla ilgilidir. Karar vermenin en basit yolu, IMO, bu belirli veri parçasının bir bütün olarak uygulama için yararlı olup olmadığını veya bazı yerel bilgiler olduğunu düşünmektir. Ayrıca, durumu çoğaltmamak önemlidir, bu nedenle bir parça veri'den aksesuarlar hesaplanabilirse - bu, uygulamalardan hesaplanmalıdır.

Örneğin, a) listeden bir değer seçebilen ve b) açılabilir veya kapatılmış (yani, görüntülenen veya gizlenen seçenekler listesi) gibi bir açılır kontrolünüz (özel HTML için standart HTML seçimini saran) olduğunu varsayalım. Şimdi, uygulamanızın bir tür öğelerin bir listesini ve liste girişleri için açılır kontroller filtrenizi görüntülediğini varsayalım. Ardından, aktif filtre değerini bir prop olarak geçirmek ve açık / kapalı durumunu yerel tutmak en iyisidir. Ayrıca, işlevsel hale getirmek için, açılır bileşenin içinde çağrılacak ve güncellenmiş bilgileri (yeni seçilen filtre) hemen mağazaya gönderecek olan ana bileşenden bir onChange işleyicisi geçirirsiniz. Öte yandan, açık / kapalı durum açılır bileşen içinde tutulabilir, çünkü uygulamanın geri kalanı kontrolün açılıp açılmadığını gerçekten kullanıcı değerini değiştirene kadar umursamaz.

Aşağıdaki kod tamamen çalışmıyor, css ve açılan tıklama / bulanıklık / değişiklik olayları işleme gerekiyor, ancak örnek minimum tutmak istedim. Umarım farkı anlamaya yardımcı olur.

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

Durum, bileşeniniz tarafından tutulan bilgilerle ilgilenmenin yoludur.

Diyelim ki sunucudan bazı verileri almanız gereken bir bileşeniniz var. Genellikle, istek işleniyorsa, başarısız olursa vb. Kullanıcıyı bilgilendirmek istersiniz. Bu, söz konusu bileşenle ilgili olan bir bilgi parçasıdır. Devletin oyuna girdiği yer burasıdır.

Genellikle durumu tanımlamanın en iyi yolu aşağıdaki gibidir:

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

ancak en son tepki yerli uygulamalarında şunları yapabilirsiniz:

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

Bu iki örnek aynı şekilde çalışır, sadece sözdizimi geliştirir.

Peki, OO programlamasında her zaman sahip olduğumuz gibi sadece nesne niteliklerini kullanmaktan farklı olan nedir? Genellikle, eyaletinizde tutulan bilgilerin statik olması gerekmez, zamanla değişir ve Görünümünüzün bu değişiklikleri yansıtması için güncellenmesi gerekir. State bu işlevi basit bir şekilde sunar.

Devlet TUTULMAYACAKTIR! ve bu konuda yeterince stres alamıyorum. Bu ne anlama geliyor? Bu ASLA böyle bir şey yapmamanız gerektiği anlamına gelir.

 state.key2 = newValue;

Bunu yapmanın uygun yolu:

this.setState({ key2: newValue });

This.setState bileşenini kullanarak güncelleme döngüsünde çalışır ve durumun herhangi bir kısmı değişirse, bu değişiklikleri yansıtacak şekilde Bileşen oluşturma yönteminiz yeniden çağrılır.

Daha ayrıntılı bir açıklama için tepki belgelerine bakın: https://facebook.github.io/react/docs/state-and-lifecycle.html


2

Sahne özellikleri için kısaca. Sahne bileşenleri birbirleriyle nasıl konuşur. React'e aşina iseniz, aksesuarların ana bileşenden aşağı doğru aktığını bilmelisiniz.

Ayrıca, bir üst bileşen destekleri geçemese bile desteklerin ayarlanabilmesi için varsayılan desteklere sahip olmanız da söz konusudur.

Bu yüzden insanlar React'i tek yönlü veri akışına sahip olarak adlandırırlar. Bu, başınızı döndürmek için biraz zaman alıyor ve muhtemelen bu konuda daha sonra blog yazacağım, ancak şimdilik hatırlıyorum: veri ebeveynlerden çocuğa akıyor. Sahne değişmez (değişmediği için süslü bir kelime)

Bu yüzden mutluyuz. Bileşenler üst öğeden veri alır. Hepsi sıralı, değil mi?

Pek iyi değil. Bir bileşen üst öğeden başka bir kişiden veri aldığında ne olur? Kullanıcı verileri doğrudan bileşene girerse ne olur?

Bu yüzden devletimiz var.

DURUM

Sahne değiştirilmemelidir, bu nedenle durum hızlanır. Normalde bileşenlerin durumu yoktur ve bu nedenle durum bilgisi olmayan olarak adlandırılır. Durum kullanan bir bileşen durum bilgisi olarak bilinir. Partilere bu küçük tidbit'i bırakmaktan ve insanların senden uzaklaşmasını izlemekte özgürsün.

Böylece durum, bir bileşenin oluşturduğu tüm oluşturma işlemleri arasındaki bilgileri takip edebilmesi için kullanılır. SetState öğesini ayarladığınızda, durum nesnesini güncelleştirir ve ardından bileşeni yeniden işler. Bu süper havalı çünkü React zor işlerle ilgileniyor ve çok hızlı.

Durumun küçük bir örneği olarak, burada bir arama çubuğundan bir snippet (React hakkında daha fazla bilgi edinmek istiyorsanız bu kursa göz atmaya değer)

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

ÖZET

Sahne ve Devlet benzer şeyler yapar ancak farklı şekillerde kullanılır. Bileşenlerinizin çoğu muhtemelen vatansız olacaktır.

Sahne, verileri üst öğeden alt öğeye veya bileşenin kendisi tarafından aktarmak için kullanılır. Değişmezler ve bu nedenle değiştirilmeyeceklerdir.

Durum değiştirilebilir veriler veya değişecek veriler için kullanılır. Bu özellikle kullanıcı girişi için kullanışlıdır. Örneğin arama çubuklarını düşünün. Kullanıcı verileri yazacak ve bu gördüklerini güncelleyecektir.


2

Kısacası.

sahne değerleri değiştirilemez [değişmez]

durum değerleri, setState yöntemi [mutable] kullanılarak değiştirilebilir


1

state - Bir Component verisi tutan özel bir değişken özelliktir. Componet takıldığında varsayılan değere sahiptir.

sahne - Doğası gereği değişmeyen ve ebeveynlerden çocuğa değerin geçmesi durumunda kullanılan özel bir özelliktir. sahne, Bileşenler arasında sadece her zaman üstten (ana) alttan (alt) geçen bir iletişim kanalıdır.

Aşağıda devlet ve sahne ile ilgili tam bir örnek verilmiştir:

<!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

Genel olarak, bir bileşenin (ebeveyn) durumu alt bileşen için desteklenir.

  1. Durum, bileşenlerin üst öğeden alt öğeye geçirildiği bir bileşen içinde bulunur.
  2. Sahne genellikle değişmez.

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

Yukarıdaki kodda, adı olarak alt bileşene (Alt sınıf) prop olarak iletilen ve alt bileşeni {this.props.name} kullanarak işleyen bir üst sınıf (Ebeveyn) var.


1

Uygulamanın herhangi bir yerinde kullanıcılar tarafından girilen bazı verileriniz var.

  1. verilerin girildiği bileşenin bu veri durumunda olması gerekir, çünkü veri girişi sırasında onu işlemesi ve değiştirmesi gerekir

  2. uygulamada başka herhangi bir yerde veri tüm diğer bileşenlere sahne olarak aktarılmalıdır

Yani evet sahne değişiyor, ancak 'kaynakta' değiştiriliyorlar ve sonra oradan aşağı doğru akacaklar. Bu nedenle, aksesuarlar onları alan bileşen bağlamında değişmezdir .

Örneğin, kullanıcıların bir tedarikçi listesini düzenlediği bir referans veri ekranı, bu durumda durumun yönetilmesini sağlar; bu işlem, güncellenmiş verilerin AppState'in bir düzey altında olabilen ReferenceDataState'e kaydedilmesine ve bu tedarikçi listesinin sahne olarak geçirilmesine neden olur. kullanmak için gereken tüm bileşenlere.


1

React'te devletler hem verileri hem de destekleri depolar. İkincisi ile farkı, saklanan verilerin farklı değişikliklerle değiştirilebilmesidir. Bunlar düz JavaScript ile yazılmış nesnelerden başka bir şey değildir, bu nedenle veri veya kod içerebilir, modellemek istediğiniz bilgileri temsil eder. Daha fazla ayrıntı gerekiyorsa o bu yayınlara bakın önerilir Tepki Devlet Kullanımı ve içinde Dikmeler Kullanımı tepki


1
  • sahne --- değerini değiştiremezsiniz.
  • durumları --- kodunuzdaki değerini değiştirebilirsiniz, ancak bir oluşturma gerçekleştiğinde etkin olur.

1

Reaksiyondaki “durum” ve “sahne” arasındaki bazı farklılıklar.

Tepki, DOM'u duruma göre kontrol eder ve oluşturur. İki tür bileşen durumu vardır: sahne, bileşenler arasında aktarılan durumdur ve durum, bileşenlerin dahili durumudur. Sahne, ana bileşenden alt bileşene veri aktarımı için kullanılır. Bileşenlerin kendi durumları da vardır: yalnızca bileşen içinde değiştirilebilen durum.

Genellikle belirli bir bileşenin durumu, alt bileşenin destekleri olabilir, destek, ana bileşenin oluşturma yönteminde belirtilen çocuklara aktarılır


1

sahne donanımı

  • sahne alt öğeye veri iletmek için kullanın

  • sahne bileşenleri bir bileşenin (alt bileşen) dışındaki bir değeri değiştirme

Durum

  • sınıf bileşeni içinde durum kullanımı

  • durum, bileşen içindeki bir değeri değiştirme

  • Sayfayı oluşturursanız DOM'u güncellemek için setState'i çağırırsınız (sayfa değerini güncelle)

Devletin tepkilerde önemli bir rolü var


0

Sahne malzemesinin değişmez olması hakkındaki ilk soruya cevap olarak, alt bileşen söz konusu olduğunda değişmez oldukları, ancak ebeveynte değişebildikleri söylenir .


0

React Components, aşağıdakilerle değiştirilebilen / değiştirilebilen dahili değişkenleri READ / WRITE olarak kullanır:

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

React props, programcının Üst Bileşenden Alt Bileşene değişkenleri ve yöntemleri almasına izin veren özel bir nesnedir.

Bir pencere ve evin kapıları gibi bir şey. Sahne ayrıca değişmez Alt Bileşen onları değiştiremez / güncelleyemez.

Ana Bileşen tarafından sahne değiştirildiğinde dinlemeye yardımcı olan birkaç yöntem vardır.


0

Bu, devlet ve sahne organları arasındaki açıklama ile ilgili şu anki bakış açım

  1. Durum, bileşeninizdeki yerel değişkeniniz gibidir. Durum değerini set durumunu kullanarak değiştirebilirsiniz. Daha sonra durum değerini örneğin alt öğenize iletebilirsiniz.

  2. Sahne, tam olarak redux mağazanızın içinde bulunan değerdir, bu aslında redüktörden kaynaklanan durumdan gelir. Sahne değerinden değeri almak için bileşeninizin redux'a bağlı olması gerekir. Sahne değerinizi alt öğenize de iletebilirsiniz


0

Basit açıklama şudur: STATE, örneğin color = "blue" veya animation = true vb. Gibi bileşenin yerel durumudur. Bileşenin durumunu değiştirmek için this.setState öğesini kullanın. PROPS, bileşenlerin birbirleriyle nasıl konuştukları (ebeveynlerden çocuğa veri gönderme) ve bileşenleri yeniden kullanılabilir hale getirmektir.


0

Durum sizin verilerinizdir, değiştirilebilir, bununla ihtiyacınız olan her şeyi yapabilirsiniz, sahne verileri salt okunurdur, genellikle verilerinizle zaten çalıştığınız destekleri geçtiğinizde ve bunu oluşturmak için alt bileşene ihtiyacınız varsa veya destekleriniz bir işlev u bir görevi gerçekleştirmek için çağır


0

Devlet, verilerinizin yaşadığı gerçeğin kaynağıdır. Devletin sahne aracılığıyla kendini tezahür ettiğini söyleyebilirsiniz.

Bileşenlere destek sağlamak, kullanıcı arayüzünüzü verilerinizle senkronize tutan şeydir. Bir bileşen gerçekten sadece biçimlendirme döndüren bir işlevdir.

Aynı sahne (görüntülenecek veriler) göz önüne alındığında , her zaman aynı işaretlemeyi üretecektir .

Bu nedenle aksesuarlar, verileri orijinden fonksiyonel bileşenlere taşıyan boru hatları gibidir.


0

Props: değişmez olan ve ebeveyn bileşeninin niteliklerine atıfta bulunan "salt okunur" verileri temsil eder.

Durum: Sayfada oluşturulan ve sonuçta bileşenin kendisi tarafından dahili olarak yönetilen ve Kullanıcı girdisi nedeniyle fazla mesaiyi değiştiren değiştirilebilir verileri temsil eder.


1
sadece 1 profesyonel var mı? ve 1 con?
Zeus Kitabı

0

Temel fark, durumun bir bileşene özel olması ve bu bileşenin içinde yalnızca sahne öğeleri yalnızca statik değer ve üst bileşenden geçirilen ve alt bileşen içinde değiştirilemeyen alt bileşen için anahtar olması durumunda değiştirilebilir.

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.