प्रतिक्रिया में अवस्था और प्रॉप्स के बीच क्या अंतर है?


559

मैं रिएक्ट पर एक प्लुरलसाइट कोर्स देख रहा था और प्रशिक्षक ने कहा कि प्रॉपर को नहीं बदलना चाहिए। मैं अब प्रॉप्स बनाम राज्य पर एक लेख (uberVU / react-guide) पढ़ रहा हूं और यह कहता है

प्रॉप्स और राज्य परिवर्तन दोनों एक रेंडर अपडेट को ट्रिगर करते हैं।

बाद में लेख में कहा गया है:

प्रॉप्स (गुणों के लिए कम) एक कंपोनेंट का कॉन्फ़िगरेशन है, इसके विकल्प यदि आप कर सकते हैं। वे ऊपर और अपरिवर्तनीय से प्राप्त होते हैं।

  • तो प्रॉप्स बदल सकते हैं लेकिन उन्हें अपरिवर्तनीय होना चाहिए?
  • आपको प्रॉप्स का उपयोग कब करना चाहिए और आपको राज्य का उपयोग कब करना चाहिए?
  • यदि आपके पास कोई डेटा है जो एक रिएक्ट घटक की आवश्यकता है, तो क्या इसे प्रॉपर घटक में प्रॉपर या सेटअप के माध्यम से पारित किया जाना चाहिए getInitialState?


7
यह एक बहुत अच्छा सवाल है, वास्तव में, कोई भी एक सरल जवाब नहीं देता है: /
थॉमस डेकाक्स

जवाबों:


670

प्रॉप्स और राज्य संबंधित हैं। एक घटक की स्थिति अक्सर एक बच्चे के घटक का सहारा बन जाएगी। माता-पिता के रेंडर विधि के भीतर बच्चे को दूसरे तर्क के रूप में पारित कर दिया जाता है React.createElement(), यदि आप JSX का उपयोग कर रहे हैं, तो अधिक परिचित टैग विशेषताएँ।

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

माता-पिता का राज्य मूल्य childsNameबच्चे बन जाता है this.props.name। बच्चे के दृष्टिकोण से, नाम का नाम अपरिवर्तनीय है। यदि इसे बदलने की आवश्यकता है, तो अभिभावक को अपनी आंतरिक स्थिति बदलनी चाहिए:

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

और प्रतिक्रिया आपके लिए बच्चे को इसका प्रचार करेगी। एक स्वाभाविक अनुवर्ती प्रश्न है: क्या होगा यदि बच्चे को अपना नाम बदलने की आवश्यकता है? यह आमतौर पर बच्चे की घटनाओं और माता-पिता कॉलबैक के माध्यम से किया जाता है। बच्चा, उदाहरण के लिए, नामक एक घटना को उजागर कर सकता है onNameChanged। माता-पिता तब कॉलबैक हैंडलर पास करके ईवेंट की सदस्यता लेंगे।

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

बच्चा अपने अनुरोधित नए नाम को कॉलबैक, उदाहरण के लिए ईवेंट कॉलबैक पर एक तर्क के रूप में पारित करेगा this.props.onNameChanged('New name'), और माता-पिता अपने राज्य को अपडेट करने के लिए इवेंट हैंडलर में नाम का उपयोग करेंगे।

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

2
धन्यवाद! इसलिए कुछ और सवाल: 1. लोग क्यों कह रहे हैं कि प्रॉप्स को नहीं बदलना चाहिए? 2. आप अपने डेटा को कहां बूटस्ट्रैपिंग करते हैं? GetInitialState जैसे घटक के प्रारंभ में, या क्या आप इसे घटक के बाहर रखते हैं और डेटा उपलब्ध होने पर घटक को प्रस्तुत करते हैं?
skaterdav85

37
1. यह रिएक्ट का 'कार्यात्मक' पहलू है। सभी डेटा (लगभग) नीचे की ओर बहते हैं। चूंकि पैरेंट का स्वामित्व माता-पिता के पास होता है, केवल माता-पिता को इसे बदलना चाहिए। आदर्श रूप से, बच्चों को स्टेटलेस होना चाहिए। यह व्यवहार में संभव नहीं है (प्रतिक्रिया स्थल पर प्रपत्र प्रलेखन देखें)। 2. आप या तो इसे शीर्ष पर खिला सकते हैं, जो एक अनुशंसित अभ्यास है, या आप इसे अलग-अलग वस्तुओं में संग्रहीत कर सकते हैं। एक लोकप्रिय दृष्टिकोण फ्लक्स है, जो स्टोर्स नामक एकल वस्तुओं का उपयोग करता है। यह एक बड़े वास्तुशिल्प पैटर्न का हिस्सा है। यह फेसबुक से भी खुला है और रिएक्ट के साथ काम करने के लिए डिज़ाइन किया गया है।
टोड

2
तो स्टोर बड़े वैश्विक चर की तरह हैं?
SuperUberDuper 16

3
हां, फ्लक्स स्टोर क्लाइंट साइड कैश हैं। अन्य पैटर्न भी हैं जैसे हाल ही में जारी रिले, फेसबुक और रेडक्स से।
टोड

6
इसे थोड़ा उबालने के लिए: राज्य घटक डेटा है जिसे भीतर से प्रबंधित किया जाता है, प्रॉप्स घटक डेटा होते हैं जिन्हें प्रबंधित किया जाता है और पास किया जाता है।
मार्क

221

माता-पिता-बाल संचार के लिए, बस सहारा पास करें।

अपने कंट्रोलर-व्यू में आपके वर्तमान पृष्ठ की ज़रूरत के डेटा को संग्रहीत करने के लिए राज्य का उपयोग करें ।

अपने बाल घटकों को डेटा और ईवेंट हैंडलर पास करने के लिए प्रॉप्स का उपयोग करें ।

इन सूचियों को आपके घटकों में डेटा के साथ काम करते समय आपको मार्गदर्शन में मदद करनी चाहिए।

रंगमंच की सामग्री

  • अपरिवर्तनीय हैं
    • जो प्रतिक्रिया को तेज़ संदर्भ जाँच करने देता है
  • आपके व्यू-कंट्रोलर से डेटा पास करने के लिए उपयोग किया जाता है
    • आपका शीर्ष स्तर घटक
  • बेहतर प्रदर्शन किया है
    • बाल घटकों को डेटा पास करने के लिए इसका उपयोग करें

राज्य

  • आपके दृश्य-नियंत्रक में प्रबंधित किया जाना चाहिए
    • आपका शीर्ष स्तर घटक
  • पारस्परिक है
  • खराब प्रदर्शन है
  • बाल घटकों से पहुँचा नहीं जाना चाहिए
    • इसके बजाय सहारा के साथ नीचे पारित

दो घटकों के बीच संचार के लिए, जिनके माता-पिता-बच्चे के संबंध नहीं हैं, आप अपना स्वयं का वैश्विक ईवेंट सिस्टम सेट कर सकते हैं। जब आप कोई ईवेंट प्राप्त करते हैं, तो घटकवार्डमाउंट (), सदस्यता समाप्त करेंWillUnmount (), और कॉल सेटस्टेट () में घटनाओं की सदस्यता लें। फ्लक्स पैटर्न इसे व्यवस्थित करने के संभावित तरीकों में से एक है। - https://facebook.github.io/react/tips/communicate-between-compenders.html

राज्य में क्या घटक होने चाहिए?

आपके अधिकांश घटकों को बस प्रॉपर से कुछ डेटा लेना चाहिए और इसे प्रस्तुत करना चाहिए। हालांकि, कभी-कभी आपको उपयोगकर्ता इनपुट, सर्वर अनुरोध या समय बीतने पर प्रतिक्रिया देने की आवश्यकता होती है। इसके लिए आप स्टेट का इस्तेमाल करें।

संभव के रूप में अपने कई घटकों को स्टेटलेस रखने की कोशिश करें । ऐसा करने से आप राज्य को उसके सबसे तार्किक स्थान पर अलग कर देंगे और अतिरेक को कम कर देंगे, जिससे आपके आवेदन के बारे में तर्क करना आसान हो जाएगा।

एक सामान्य पैटर्न कई स्टेटलेस घटकों का निर्माण करना है जो केवल डेटा को प्रस्तुत करते हैं, और पदानुक्रम में उनके ऊपर एक स्टेटफुल घटक होता है जो अपने बच्चों को प्रॉप्स के माध्यम से अपने राज्य में भेजता है। स्टेटफुल कंपोनेंट इंटरैक्ट लॉजिक के सभी को इनकैप्सुलेट करता है, जबकि स्टेटलेस कंपोनेंट्स डिक्लेयर तरीके से डेटा रेंडर करने का ख्याल रखते हैं। - https://facebook.github.io/react/docs/interactivity-and-dynamic-uis.html#what-compenders-should-have-state

राज्य में क्या जाना चाहिए?

राज्य में वह डेटा होना चाहिए जो एक यूआई अपडेट को ट्रिगर करने के लिए एक घटक के ईवेंट हैंडलर बदल सकता है। वास्तविक ऐप्स में यह डेटा बहुत छोटा और JSON-serializable हो जाता है। स्टेटफुल कंपोनेंट का निर्माण करते समय, अपने राज्य के न्यूनतम संभव प्रतिनिधित्व के बारे में सोचें, और केवल उन संपत्तियों को इसमें जमा करें। रेंडर के अंदर () बस इस राज्य पर आधारित किसी भी अन्य जानकारी की गणना करें। आप पाएंगे कि इस तरह से अनुप्रयोगों के बारे में सोचने और लिखने से सबसे सही अनुप्रयोग होता है, क्योंकि निरर्थक या गणना मूल्यों को राज्य में जोड़ने का मतलब है कि आपको उनके लिए प्रतिक्रिया व्यक्त करने के बजाय उन पर निर्भर रहने की बजाय स्पष्ट रूप से सिंक में रखने की आवश्यकता है। - https://facebook.github.io/react/docs/interactivity-and-dynamic-uis.html#what-should-go-in-state


2
असहमत, सभी सहारा जा रहा है वास्तव में डेटा नीचे पारित करने के लिए कम प्रदर्शन है। बस बच्चे के घटकों के लिए स्टोर सेट करें, फिर आपको प्रॉपर की गड़बड़ी से निपटने की ज़रूरत नहीं है और जब प्रॉप्स बदलते हैं तो आपको अपने घटकों को अपडेट करना होगा। बस अपने स्टोर को अपडेट करें और घटक को उसके स्टोर से डेटा प्राप्त करने दें।
पॉजिटिव

क्या आप मुझे बता सकते हैं कि प्रॉप्स राज्यों की तुलना में अधिक प्रदर्शन क्यों हैं। धन्यवाद।
hqt

@ मुझे लगता है कि क्योंकि यह अपरिवर्तनीय है, मूल्यों को बदलने के लिए उनके अंदर की तुलना तेज है
गैस्पर

@ बेंटऑनकोडिंग, अच्छा दिन, कृपया आप मदद कर सकते हैं। क्या मैं इस तरह की कल्पना कर सकता हूं कि कभी भी ऐसा डेटा है जो USER INTERACTION पर एक घटक के भीतर बदलने वाला है, यह वह जगह है जहां राज्य का उपयोग किया जाता है?
डिकेंस

72

आप इसे प्लेन जेएस कार्यों से संबंधित करके सबसे अच्छा समझ सकते हैं।

सीधे शब्दों में कहें,

राज्य घटक की स्थानीय स्थिति है जिसे घटक के बाहर पहुँचा और संशोधित नहीं किया जा सकता है। यह एक समारोह में स्थानीय चर के बराबर है।

सादा जेएस समारोह

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

प्रतिक्रिया घटक

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

दूसरी ओर, प्रॉप्स घटकों को उनके मूल घटक से प्रॉप्स के रूप में डेटा प्राप्त करने की क्षमता देकर पुन: प्रयोज्य बनाते हैं। वे फ़ंक्शन मापदंडों के बराबर हैं।

सादा जेएस समारोह

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

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

प्रतिक्रिया घटक

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

}

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

साभार: मनोज सिंह नेगी

लेख लिंक: प्रतिक्रिया स्थिति बनाम प्रॉप्स की व्याख्या


16
यह वास्तव में एक बहुत ही उपयोगी उत्तर है। इसे पढ़ने के बाद, मैं और अधिक पूर्ण उत्तर समझ सकता हूं। धन्यवाद।
हारून

1
प्रतिक्रिया घटक = सादा जेएस फ़ंक्शन स्पष्ट रूप से यह समझाने का एक शानदार तरीका है। और प्रतिक्रिया के साथ कार्यात्मक घटकों की ओर अधिक बढ़ रहा है, यह और भी अधिक शाब्दिक मामला बन रहा है।
जद सैंडिफ़र

1
सबसे अच्छा स्पष्टीकरण मैंने पढ़ा है, धन्यवाद
iWizard 18

48

प्रॉप्स बनाम राज्य सारांश मुझे सबसे अच्छा लगता है: प्रतिक्रिया-गाइड बिग हैट टिप उन लोगों के लिए। नीचे उस पृष्ठ का संपादित संस्करण है:


प्रॉप्स बनाम राज्य

tl; dr अगर किसी घटक को किसी समय अपनी किसी विशेषता को बदलने की आवश्यकता होती है, तो वह विशेषता उसके राज्य का हिस्सा होनी चाहिए, अन्यथा यह केवल उस घटक के लिए एक प्रस्ताव होना चाहिए।


रंगमंच की सामग्री

प्रॉप्स (गुणों के लिए छोटा) एक घटक का विन्यास है। वे ऊपर और अपरिवर्तनीय से प्राप्त होते हैं जहां तक ​​उन्हें प्राप्त करने वाले घटक का संबंध है। एक घटक अपने रंगमंच की सामग्री को नहीं बदल सकता है, लेकिन यह अपने बच्चे के घटकों के समूह को एक साथ रखने के लिए जिम्मेदार है। प्रॉप्स के लिए केवल डेटा होना जरूरी नहीं है - कॉलबैक फ़ंक्शन को प्रॉपर के रूप में पारित किया जा सकता है।

राज्य

राज्य एक डेटा संरचना है जो एक घटक के माउंट होने पर डिफ़ॉल्ट मान से शुरू होती है। यह उपयोगकर्ता घटनाओं के परिणामस्वरूप, समय के साथ उत्परिवर्तित हो सकता है।

एक घटक आंतरिक रूप से अपने स्वयं के राज्य का प्रबंधन करता है। एक प्रारंभिक राज्य स्थापित करने के अलावा, इसका अपने बच्चों की स्थिति के साथ कोई व्यवसाय नहीं है। आप उस घटक के लिए निजी के रूप में राज्य की अवधारणा कर सकते हैं।

रंगमंच की सामग्री और स्थिति को बदलना

                                                   प्रॉप्स स्टेट
    मूल घटक से प्रारंभिक मूल्य प्राप्त कर सकते हैं? हाँ हाँ
    मूल घटक द्वारा बदला जा सकता है? हाँ नही
    घटक के अंदर डिफ़ॉल्ट मान सेट कर सकते हैं? * हाँ हाँ
    घटक के अंदर बदल सकते हैं? नहीं हाँ
    बाल घटकों के लिए प्रारंभिक मूल्य निर्धारित कर सकते हैं? हाँ हाँ
    बच्चे के घटकों में बदल सकते हैं? हाँ नही
  • ध्यान दें कि माता-पिता से प्राप्त दोनों प्रॉप्स और राज्य प्रारंभिक मूल्य एक घटक के अंदर परिभाषित डिफ़ॉल्ट मानों को ओवरराइड करते हैं।

क्या इस घटक के पास राज्य होना चाहिए?

राज्य वैकल्पिक है। चूंकि राज्य जटिलता बढ़ाता है और भविष्यवाणी कम करता है, राज्य के बिना एक घटक बेहतर होता है। भले ही आप स्पष्ट रूप से एक इंटरैक्टिव ऐप में राज्य के बिना नहीं कर सकते हैं, आपको बहुत सारे स्टेटफुल कंपोनेंट होने से बचना चाहिए।

घटक प्रकार

स्टेटलेस कंपोनेंट केवल प्रॉप्स, कोई राज्य नहीं। रेंडर () फंक्शन के अलावा बहुत कुछ नहीं चल रहा है। उनका तर्क उन्हें प्राप्त होने वाले रंगमंच के इर्द-गिर्द घूमता है। इससे उन्हें पालन करने, और परीक्षण करने में बहुत आसानी होती है।

स्टेटफुल कंपोनेंट प्रॉप्स एंड स्टेट दोनों। इनका उपयोग तब किया जाता है जब आपके घटक को कुछ स्थिति को बनाए रखना चाहिए। यह क्लाइंट-सर्वर संचार (XHR, वेब सॉकेट्स इत्यादि) के लिए एक अच्छा स्थान है, डेटा संसाधित करता है और उपयोगकर्ता घटनाओं का जवाब देता है। इस तरह की लॉजिस्टिक्स को उदारवादी घटकों की एक मध्यम संख्या में समझाया जाना चाहिए, जबकि सभी विज़ुअलाइज़ेशन और स्वरूपण तर्क को कई स्टेटलेस घटकों में डाउनस्ट्रीम में स्थानांतरित करना चाहिए।

सूत्रों का कहना है


1
"माता-पिता से प्राप्त राज्य प्रारंभिक मूल्य" से आपका क्या अभिप्राय है? जहां तक ​​मुझे पता है कि राज्य को केवल एक घटक के दायरे में परिभाषित किया गया है और इसे सीधे बाहर से नहीं बदला जा सकता है।
मैक्सिम

@MaximKuzmin मेरा मानना ​​है कि 'कलर' जैसे राज्य को इनिशियलाइज़ करने के लिए 'आरंभिक' जैसे प्रॉप में लेने के सामान्य पैटर्न का संदर्भ है। राज्य को शुरू में प्रोप (माता-पिता से प्राप्त) से मूल्य दिया जाता है और फिर उसके बाद नियमित राज्य की तरह कार्य करना जारी रखता है। यह राज्य बनाम प्रॉप्स के लिए एक परिचय में शामिल करने के लिए थोड़ा भ्रमित हो सकता है, लेकिन यह जानने के लिए एक महत्वपूर्ण पैटर्न है।
जद सैंडिफ़ेर

18

सहारा ("गुणों" के लिए कम) और राज्य दोनों सादे जावास्क्रिप्ट ऑब्जेक्ट हैं। जबकि दोनों जानकारी प्रदान करते हैं जो रेंडर के आउटपुट को प्रभावित करते हैं, वे एक महत्वपूर्ण तरीके से भिन्न होते हैं: प्रॉप्स घटक (फ़ंक्शन पैरामीटर के समान) के लिए पास हो जाते हैं जबकि राज्य घटक के भीतर प्रबंधित होता है (फ़ंक्शन के भीतर घोषित चर के समान)।

तो बस राज्य आपके वर्तमान घटक तक ही सीमित है, लेकिन आप जिस किसी भी घटक को चाहते हैं, उसके लिए प्रॉप्स को पास किया जा सकता है ... आप वर्तमान घटक की स्थिति को अन्य घटकों के लिए प्रस्ताव के रूप में पारित कर सकते हैं ...

इसके अलावा रिएक्ट में, हमारे पास स्टेटलेस घटक होते हैं जिनमें केवल प्रॉप्स होते हैं न कि आंतरिक स्थिति ...

नीचे दिए गए उदाहरण दिखाते हैं कि वे आपके ऐप में कैसे काम करते हैं:

मूल (राज्य-पूर्ण घटक):

class SuperClock extends React.Component {

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

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

बच्चे (राज्य-कम घटक):

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

11

प्रॉप्स और राज्य के बीच महत्वपूर्ण अंतर यह है कि राज्य आंतरिक और घटक द्वारा स्वयं नियंत्रित होता है जबकि प्रॉम्प्स बाहरी होते हैं और जो कुछ भी घटक को नियंत्रित करता है।

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

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


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

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

राज्य वीएस प्रॉप्स

  • राज्य बदला जा सकता है (म्यूटेबल)
  • जबकि प्रॉप्स (अपरिवर्तनीय) नहीं हो सकते

7

मूल रूप से, अंतर यह है कि राज्य ओओपी में विशेषताओं की तरह कुछ है : यह एक वर्ग (घटक) के लिए कुछ स्थानीय है, इसका बेहतर वर्णन करने के लिए उपयोग किया जाता है। प्रॉप पैरामीटर की तरह होते हैं - वे एक घटक के कॉलर से एक घटक (माता-पिता) को पारित किए जाते हैं : जैसे कि आप कुछ मापदंडों के साथ एक फ़ंक्शन कहते हैं।


5

प्रतिक्रिया में राज्य और प्रॉप दोनों का उपयोग एक घटक में डेटा को नियंत्रित करने के लिए किया जाता है, आमतौर पर प्रॉप्स को माता-पिता द्वारा निर्धारित किया जाता है और बच्चे के घटकों को पास किया जाता है और वे पूरे घटक में तय होते हैं। जो डेटा बदलने जा रहा है, उसके लिए हमें स्टेट का इस्तेमाल करना होगा। और प्रॉप्स अपरिवर्तनीय हैं, जबकि राज्यों में परिवर्तनशील हैं , यदि आप प्रॉपर बदलना चाहते हैं तो आप मूल घटक से कर सकते हैं और फिर इसे बाल घटकों में पास कर सकते हैं।


4

जैसा कि मैंने प्रतिक्रिया के साथ काम करते हुए सीखा।

  • प्रॉप्स का उपयोग बाह्य वातावरण से डेटा प्राप्त करने के लिए एक घटक द्वारा किया जाता है अर्थात एक अन्य घटक (शुद्ध, कार्यात्मक या वर्ग) या एक सामान्य वर्ग या जावास्क्रिप्ट / टाइपस्क्रिप्ट कोड

  • एक घटक के आंतरिक वातावरण का प्रबंधन करने के लिए राज्यों का उपयोग किया जाता है इसका मतलब घटक के अंदर डेटा परिवर्तन होता है


3

प्रॉप्स: प्रॉप्स कुछ नहीं बल्कि कंपोनेंट और रिएक्ट कंपोनेंट की प्रॉपर्टी है, जावास्क्रिप्ट फंक्शन के अलावा और कुछ नहीं है।

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

const तत्व =;

यहाँ <Welcome name="Sara" /> एक घटक {नाम: 'सारा'} का स्वागत वेलकम घटक के रूप में किया जा रहा है। एक मूल घटक से बाल घटक तक डेटा पास करने के लिए हम प्रॉपर का उपयोग करते हैं। प्रॉप्स अपरिवर्तनीय है। एक घटक के जीवन चक्र के दौरान प्रॉप्स को बदलना नहीं चाहिए (उन्हें अपरिवर्तनीय मानें)।

राज्य: राज्य केवल घटक के भीतर उपलब्ध है। घटक के भीतर डेटा का ट्रैक रखने के लिए हम राज्य का उपयोग करते हैं। हम setState द्वारा स्थिति बदल सकते हैं। अगर हमें बच्चे को राज्य पारित करने की आवश्यकता है तो हमें इसे सहारा के रूप में पारित करना होगा।

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

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

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

3

राज्य:

  1. दशाएँ परस्पर हैं।
  2. राज्य अलग-अलग घटकों से जुड़े होते हैं जिनका उपयोग अन्य घटकों द्वारा नहीं किया जा सकता है।
  3. कंपोनेंट माउंट पर राज्यों की शुरुआत होती है।
  4. राज्यों का उपयोग घटक के भीतर गतिशील परिवर्तनों को प्रस्तुत करने के लिए किया जाता है।

रंगमंच की सामग्री:

  1. सहारा अपरिवर्तनीय हैं।
  2. आप घटकों के बीच सहारा पारित कर सकते हैं।
  3. प्रॉप्स ज्यादातर घटकों के बीच संवाद करने के लिए उपयोग किए जाते हैं। आप सीधे माता-पिता से बच्चे के पास जा सकते हैं। बच्चे से माता-पिता को पारित करने के लिए आपको राज्यों को उठाने की अवधारणा का उपयोग करने की आवश्यकता है।

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

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


{"संदेश": " बिना पढ़ा हुआ वाक्य रचना : अनपेक्षित टोकन <", "फ़ाइल का नाम": " stacksnippets.net/js ", " लिनेनो ": 17, "कॉलनो": 9}
निको जोजो

2

मूल रूप से, सहारा और राज्य दो तरीके हैं जो घटक जान सकते हैं कि क्या और कैसे प्रस्तुत करना है। एप्लिकेशन राज्य का कौन सा हिस्सा राज्य से संबंधित है और कौन से शीर्ष स्तर के स्टोर में, आपके ऐप डिज़ाइन से अधिक संबंधित है, रिएक्ट कैसे काम करता है। निर्णय लेने का सबसे सरल तरीका, आईएमओ, यह सोचना है कि क्या यह विशेष डेटा एक पूरे के रूप में आवेदन के लिए उपयोगी है, या यह स्थानीय जानकारी है। इसके अलावा, राज्य को डुप्लिकेट नहीं करना महत्वपूर्ण है, इसलिए यदि डेटा के कुछ टुकड़े को प्रॉम्प्स से गणना की जा सकती है - तो इसे प्रॉम्प्स से गणना की जानी चाहिए।

उदाहरण के लिए, मान लें कि आपके पास कुछ ड्रॉपडाउन नियंत्रण है (जो कस्टम स्टाइल के लिए standart HTML का चयन करता है), जो a) सूची से कुछ मान का चयन कर सकता है, और b) खोला या बंद किया जा सकता है (यानी, विकल्प सूची प्रदर्शित या छिपी हुई है)। अब, मान लें कि आपका ऐप किसी प्रकार की वस्तुओं की सूची प्रदर्शित करता है और सूची प्रविष्टियों के लिए आपका ड्रॉपडाउन नियंत्रण फ़िल्टर करता है। फिर, सक्रिय फिल्टर मान को एक प्रोप के रूप में पास करना सबसे अच्छा होगा, और खुले / बंद राज्य को स्थानीय रखें। इसके अलावा, इसे कार्यात्मक बनाने के लिए, आप मूल घटक से एक ऑनचेंज हैंडलर पास करेंगे, जिसे ड्रॉपडाउन तत्व के अंदर कहा जाएगा और तुरंत स्टोर पर अद्यतन जानकारी (नया चयनित फ़िल्टर) भेजें। दूसरी ओर, खोला / बंद राज्य को ड्रॉपडाउन घटक के अंदर रखा जा सकता है, क्योंकि बाकी एप्लिकेशन वास्तव में परवाह नहीं करता है यदि नियंत्रण खोला जाता है, जब तक कि उपयोगकर्ता वास्तव में इसका मूल्य नहीं बदलता है।

निम्नलिखित कोड पूरी तरह से काम नहीं कर रहा है, इसे सीएसएस और हैंडलिंग ड्रॉपडाउन क्लिक / ब्लर / परिवर्तन घटनाओं की आवश्यकता है, लेकिन मैं उदाहरण को कम से कम रखना चाहता था। आशा है कि यह अंतर को समझने में मदद करता है।

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

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

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

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

    default:
        return items;
  }
}

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

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

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

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

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

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

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

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

2

राज्य वह तरीका है जो आपके घटक द्वारा रखी गई जानकारी के साथ प्रतिक्रिया करता है।

मान लीजिए कि आपके पास एक घटक है जिसे सर्वर से कुछ डेटा प्राप्त करने की आवश्यकता है। आप आमतौर पर उपयोगकर्ता को सूचित करना चाहते हैं यदि अनुरोध प्रसंस्करण है, अगर यह विफल हो गया है, आदि। यह जानकारी का एक टुकड़ा है जो उस विशिष्ट घटक के लिए बस प्रासंगिक है। यह वह जगह है जहाँ राज्य खेल में प्रवेश करता है।

आमतौर पर राज्य को परिभाषित करने का सबसे अच्छा तरीका इस प्रकार है:

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

लेकिन आप कर सकते हैं देशी प्रतिक्रिया के अक्षांश कार्यान्वयन में:

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

ये दो उदाहरण सटीक तरीके से निष्पादित होते हैं, यह सिर्फ एक सिंटैक्स सुधार है।

तो, क्या हम ऑब्जेक्ट विशेषताओं का उपयोग करने से अलग है, जैसा कि हमारे पास हमेशा ओओ प्रोग्रामिंग में है? आमतौर पर, आपके राज्य में आयोजित जानकारी स्थिर होने का मतलब नहीं है, यह समय के साथ बदल जाएगा और आपके दृष्टिकोण को इन परिवर्तनों को प्रतिबिंबित करने के लिए अपडेट करने की आवश्यकता होगी। राज्य इस कार्यक्षमता को सरल तरीके से पेश करता है।

राज्य में रहने योग्य होना चाहता हूँ! और मैं इस पर पर्याप्त तनाव नहीं बना सकता। इसका क्या मतलब है? इसका मतलब है कि आपको कभी ऐसा नहीं करना चाहिए।

 state.key2 = newValue;

इसे करने का उचित तरीका है:

this.setState({ key2: newValue });

इस का उपयोग करना। अपने घटक को अद्यतन चक्र के माध्यम से चलाता है और यदि राज्य के किसी भी हिस्से में परिवर्तन होता है, तो इस परिवर्तन को प्रतिबिंबित करने के लिए आपके घटक रेंडर विधि को फिर से बुलाया जाएगा।

अधिक विस्तृत विवरण के लिए प्रतिक्रिया डॉक्स की जाँच करें: https://facebook.github.io/react/docs/state-and-lifecycle.html


2

गुण के लिए सहारा सरल हैं। Props कैसे घटक एक दूसरे से बात करते हैं। यदि आप सभी रिएक्ट से परिचित हैं तो आपको पता होना चाहिए कि मूल घटक से प्रॉप्स नीचे की ओर बहते हैं।

ऐसी स्थिति भी है कि आप डिफ़ॉल्ट प्रॉप्स रख सकते हैं ताकि प्रॉपर सेट हो जाएं, भले ही कोई मूल घटक प्रॉपर डाउन न हो।

यही कारण है कि लोग रिएक्ट को यूनि-दिशात्मक डेटा प्रवाह के रूप में संदर्भित करते हैं। यह आपके सिर के आसपास होने का थोड़ा सा लेता है और मैं शायद बाद में इस पर ब्लॉग लिखूंगा, लेकिन अभी के लिए बस याद रखें: माता-पिता से बच्चे तक डेटा प्रवाहित होता है। प्रॉप्स अपरिवर्तनीय हैं (इसके लिए फैंसी शब्द बदलते नहीं हैं)

इसलिए हम खुश हैं। घटक माता-पिता से डेटा प्राप्त करते हैं। सभी हल, सही?

खैर, काफी नहीं। जब कोई घटक माता-पिता के अलावा किसी अन्य से डेटा प्राप्त करता है तो क्या होता है? क्या होगा यदि उपयोगकर्ता डेटा को सीधे घटक को इनपुट करता है?

खैर, यही कारण है कि हमारे पास राज्य है।

राज्य

प्रॉप्स को बदलना नहीं चाहिए, इसलिए राज्य कदम बढ़ाएं। आम तौर पर घटकों की स्थिति नहीं होती है और इसलिए उन्हें स्टेटलेस कहा जाता है। राज्य का उपयोग करने वाला एक घटक स्टेटफुल के रूप में जाना जाता है। पार्टियों में उस छोटे tidbit को छोड़ने के लिए स्वतंत्र महसूस करें और लोगों को आपसे दूर देखें।

इसलिए राज्य का उपयोग किया जाता है ताकि एक घटक किसी भी रेंडर के बीच जानकारी का ट्रैक रख सके जो वह करता है। जब आप इसे सेट करते हैं तो यह स्टेट ऑब्जेक्ट को अपडेट करता है और फिर कंपोनेंट को री-रेंडर करता है। यह सुपर कूल है क्योंकि इसका मतलब है कि रिएक्ट कड़ी मेहनत का ख्याल रखता है और धधकते हुए तेजी से होता है।

राज्य के एक छोटे से उदाहरण के रूप में, यहां सर्च बार से एक स्निपेट दिया गया है (यदि आप रिएक्ट के बारे में अधिक जानना चाहते हैं तो इस कोर्स को देखें)

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

सारांश

प्रॉप्स और स्टेट इसी तरह की चीजें करते हैं लेकिन अलग-अलग तरीकों से उपयोग की जाती हैं। आपके अधिकांश घटक संभवतः स्टेटलेस होंगे।

प्रॉप्स का उपयोग माता-पिता से बच्चे तक या घटक द्वारा स्वयं डेटा पास करने के लिए किया जाता है। वे अपरिवर्तनीय हैं और इस प्रकार परिवर्तित नहीं किए जाएंगे।

राज्य का उपयोग उत्परिवर्तनीय डेटा, या डेटा के लिए किया जाता है जो बदल जाएगा। यह उपयोगकर्ता इनपुट के लिए विशेष रूप से उपयोगी है। उदाहरण के लिए खोज पट्टियाँ सोचें। उपयोगकर्ता डेटा टाइप करेगा और यह अपडेट करेगा कि वे क्या देखते हैं।


2

संक्षेप में।

रंगमंच का मूल्य नहीं बदला जा सकता है [अपरिवर्तनीय]

राज्य के मूल्यों को बदला जा सकता है, सेटस्टेट विधि का उपयोग करके [उत्परिवर्ती]


1

राज्य - यह एक विशेष परिवर्तनशील संपत्ति है जो एक घटक डेटा रखती है। जब Componet माउंट करता है तो इसका डिफ़ॉल्ट मान होता है।

प्रॉप्स - यह एक विशेष गुण है जो स्वभाव से अपरिवर्तनीय है और माता-पिता से बच्चे तक के मूल्य के पारित होने के मामले में उपयोग किया जाता है। प्रॉप्स कंपोनेंट्स के बीच सिर्फ एक कम्युनिकेशन चैनल है, जो हमेशा टॉप (पैरेंट) से नितंब (बच्चे) तक जाता है।

नीचे राज्य और प्रॉप्स का मुकाबला करने का पूरा उदाहरण है: -

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

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

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

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

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

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

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

1

सामान्य तौर पर, एक घटक (माता-पिता) की स्थिति बच्चे के घटक के लिए होती है।

  1. राज्य एक घटक के भीतर रहता है जहां माता-पिता से बच्चे तक सहारा के रूप में पारित किया जाता है।
  2. प्रॉप्स आमतौर पर अपरिवर्तनीय होते हैं।

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

उपरोक्त कोड में, हमारे पास एक पैरेंट क्लास (पैरेंट) है, जिसका नाम उसके राज्य के रूप में है जो कि एक प्रस्ताव के रूप में चाइल्ड कंपोनेंट (चाइल्ड क्लास) को पास किया जाता है और चाइल्ड कंपोनेंट {this.props.name} का उपयोग करके इसे रेंडर करता है।


1

आपके पास कुछ डेटा है जो उपयोगकर्ताओं द्वारा एप्लिकेशन में कहीं दर्ज किया जा रहा है।

  1. जिस घटक में डेटा दर्ज किया जा रहा है, उसके राज्य में यह डेटा होना चाहिए क्योंकि उसे डेटा प्रविष्टि के दौरान हेरफेर और इसे बदलने की आवश्यकता है

  2. आवेदन में कहीं और डेटा को अन्य सभी घटकों के लिए सहारा के रूप में नीचे पारित किया जाना चाहिए

इसलिए हां, प्रॉप्स बदल रहे हैं लेकिन वे 'स्रोत' में बदल गए हैं और फिर बस वहां से नीचे बह जाएंगे। तो उन्हें प्राप्त करने वाले घटक के संदर्भ में सहारा अपरिवर्तनीय हैं

उदाहरण के लिए एक संदर्भ डेटा स्क्रीन, जहां उपयोगकर्ता आपूर्तिकर्ताओं की एक सूची संपादित करते हैं, जो राज्य में इसका प्रबंधन करेगा, जिसके बाद एक अद्यतन कार्रवाई होगी जिसके कारण संदर्भ डेटा को संदर्भ में सहेजा जा सकता है जो AppState से एक स्तर नीचे हो सकता है और फिर इस आपूर्तिकर्ता सूची को सहारा के रूप में पारित किया जाएगा। उपयोग करने के लिए आवश्यक सभी घटकों को।


1

प्रतिक्रिया में राज्यों डेटा के साथ ही सहारा की दुकान। उत्तरार्द्ध के साथ इसका अंतर यह है कि संग्रहीत डेटा को विभिन्न परिवर्तनों द्वारा संशोधित किया जा सकता है। ये फ्लैट जावास्क्रिप्ट में लिखी गई वस्तुओं से ज्यादा कुछ नहीं हैं, इसलिए वे उस डेटा या कोड को शामिल कर सकते हैं, जिसे आप मॉडल करना चाहते हैं। यदि आपको अधिक विवरणों की आवश्यकता है, तो यह अनुशंसा की जाती है कि आप इन प्रकाशनों का उपयोग करें और प्रतिक्रिया में अवस्था का उपयोग करें


1
  • सहारा --- आप इसका मूल्य नहीं बदल सकते।
  • कहा जाता है --- आप अपने कोड में इसके मूल्य को बदल सकते हैं, लेकिन रेंडर होने पर यह सक्रिय होगा।

1

प्रतिक्रिया में "राज्य" और "सहारा" के बीच कुछ अंतर।

प्रतिक्रिया को नियंत्रित करता है और DOM को राज्य पर आधारित करता है। दो प्रकार के घटक राज्य हैं: प्रॉप्स वह स्थिति है जो घटकों के बीच स्थानान्तरण करती है, और राज्य घटकों की आंतरिक स्थिति है। Props का उपयोग मूल घटक से बाल घटक में डेटा स्थानांतरण के लिए किया जाता है। घटकों के अंदर भी अपनी स्थिति होती है: वह अवस्था जिसे केवल घटक के अंदर ही संशोधित किया जा सकता है।

आम तौर पर कुछ घटक की स्थिति बाल घटक की प्रॉप्स हो सकती है, प्रॉप्स को उन बच्चों को दिया जाएगा जो मूल घटक की रेंडरिंग विधि के अंदर बताए गए हैं


1

रंगमंच की सामग्री

  • बच्चे के घटक में डेटा पारित करने के लिए सहारा का उपयोग करता है

  • प्रॉप्स एक घटक (चाइल्ड कंपोनेंट) के बाहर एक मान को बदलते हैं

राज्य

  • राज्य एक वर्ग घटक के अंदर का उपयोग करें

  • राज्य एक घटक के अंदर एक मूल्य बदलते हैं

  • यदि आप पृष्ठ को रेंडर करते हैं, तो आप DOM को अपडेट करने के लिए setState को कॉल करें (अपडेट पेज वैल्यू)

प्रतिक्रिया में राज्य की महत्वपूर्ण भूमिका है


0

प्रॉप्स अपरिवर्तनीय होने के बारे में प्रारंभिक प्रश्न के उत्तर में, उन्हें अपरिवर्तनीय कहा जाता है जहां तक ​​बाल घटक का संबंध है लेकिन माता-पिता में परिवर्तनशील हैं।


0

प्रतिक्रिया घटक राज्य को READ / WRITE का उपयोग करते हैं जो आंतरिक चर को बदल सकते हैं / उदाहरण के लिए उत्परिवर्तित:

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

रिएक्ट प्रॉप्स विशेष वस्तु है जो प्रोग्रामर को पैरेंट कंपोनेंट से चाइल्ड कंपोनेंट में वेरिएबल और मेथड प्राप्त करने की अनुमति देती है।

यह विंडोज और घर के दरवाजे जैसा कुछ है। प्रॉप्स भी अपरिवर्तनीय हैं चाइल्ड कंपोनेंट उन्हें बदल / अपडेट नहीं कर सकते हैं।

ऐसे कुछ तरीके हैं जो पेरेंट कंपोनेंट द्वारा प्रॉप्स बदलने पर सुनने में मदद करते हैं।


0

राज्य और प्रॉप्स के बीच स्पष्टीकरण के संबंध में यह मेरा वर्तमान दृष्टिकोण है

  1. राज्य आपके घटक के अंदर आपके स्थानीय चर की तरह है। आप सेट राज्य का उपयोग करके राज्य के मूल्य में हेरफेर कर सकते हैं। आप उदाहरण के लिए अपने बच्चे के घटक के लिए राज्य का मान पास कर सकते हैं।

  2. प्रॉप्स वह मूल्य है जो वास्तव में आपके रिडक्स स्टोर के अंदर स्थित है, यह वास्तव में राज्य से आता है जो रेड्यूसर से उत्पन्न होता है। प्रॉप्स से मूल्य प्राप्त करने के लिए आपके घटक को रिडक्स से जोड़ा जाना चाहिए। आप अपने बच्चे के घटक के लिए अपना सहारा मूल्य भी पास कर सकते हैं


0

सरल व्याख्या है: उदाहरण रंग = "नीला" या एनीमेशन = सच आदि के लिए STATE घटक की स्थानीय स्थिति है। घटक की स्थिति बदलने के लिए this.setState का उपयोग करें। PROPS यह है कि कैसे घटक एक दूसरे से बात करते हैं (माता-पिता से बच्चे को डेटा भेजें) और घटकों को पुन: प्रयोज्य बनाते हैं।


0

राज्य आपका डेटा है, आपस में जुड़ा हुआ है, आप अपनी ज़रूरत के अनुसार कुछ भी कर सकते हैं, प्रॉप्स को केवल डेटा पढ़ा जाता है, आमतौर पर जब आप प्रॉप्स पास करते हैं तो आप अपने डेटा के साथ काम करते हैं और इसे रेंडर करने के लिए आपको चाइल्ड कंपोनेंट की ज़रूरत होती है या यदि आपका प्रॉप्स ए function u इसे किसी कार्य को करने के लिए कहते हैं


0

राज्य सत्य की उत्पत्ति है, जहां आपका डेटा रहता है। आप कह सकते हैं कि राज्य प्रॉप्स के माध्यम से ही प्रकट होता है।

घटकों को प्रॉप्स प्रदान करना आपके यूआई को आपके डेटा के साथ सिंक में रखता है। एक घटक वास्तव में केवल एक फ़ंक्शन है जो मार्कअप देता है।

समान प्रॉप्स (इसे प्रदर्शित करने के लिए डेटा) को देखते हुए यह हमेशा एक ही मार्कअप का उत्पादन करेगा ।

तो प्रॉप पाइपलाइनों की तरह हैं जो डेटा को मूल से कार्यात्मक घटकों तक ले जाते हैं।


0

प्रॉप्स: "रीड-ओनली" डेटा का प्रतिनिधित्व करता है, जो अपरिवर्तनीय हैं और माता-पिता घटक से विशेषताओं का उल्लेख करते हैं।

राज्य: परिवर्तनशील डेटा का प्रतिनिधित्व करता है, जो अंततः पृष्ठ पर प्रदान किए गए और घटक द्वारा आंतरिक रूप से प्रबंधित किया जाता है और उपयोगकर्ता इनपुट के कारण आमतौर पर ओवरटाइम को बदलता है।


1
वहाँ केवल 1 समर्थक है? और 1 कोन?
बुक ऑफ़ ज़ीउस

0

मुख्य अंतर यह है कि राज्य एक घटक के लिए निजी हैं और केवल उस घटक के अंदर बदला जा सकता है जबकि प्रॉप्स केवल बच्चे के घटक के लिए स्थिर मूल्य और कुंजी है जो मूल घटक के माध्यम से पारित किया जाता है और बच्चे के घटक के अंदर नहीं बदला जा सकता है

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.