อะไรคือความแตกต่างระหว่างรัฐกับอุปกรณ์ประกอบฉากใน React?


559

ฉันกำลังดูหลักสูตร Pluralsight เกี่ยวกับ React และผู้สอนระบุว่าไม่ควรเปลี่ยนอุปกรณ์ประกอบฉาก ตอนนี้ฉันกำลังอ่านบทความ (uberVU / react-guide)บนอุปกรณ์ประกอบฉากเทียบกับรัฐและมันบอกว่า

ทั้งการเปลี่ยนอุปกรณ์ประกอบฉากและสถานะจะกระตุ้นการอัพเดท

ต่อมาในบทความมันบอกว่า:

อุปกรณ์ประกอบฉาก (ย่อมาจากคุณสมบัติ) คือการกำหนดค่าของคอมโพเนนต์ตัวเลือกของอุปกรณ์นั้นหากคุณสามารถ พวกเขาได้รับจากด้านบนและไม่เปลี่ยนรูป

  • ดังนั้นอุปกรณ์ประกอบฉากสามารถเปลี่ยนได้ แต่ควรเปลี่ยนไม่ได้?
  • คุณควรใช้อุปกรณ์ประกอบฉากเมื่อใดและเมื่อใดที่คุณควรใช้สถานะ
  • หากคุณมีข้อมูลที่องค์ประกอบการตอบสนองความต้องการมันควรจะถูกส่งผ่านอุปกรณ์ประกอบฉากหรือการติดตั้งในองค์ประกอบการทำปฏิกิริยาผ่านgetInitialState?


7
นี่เป็นคำถามที่ดีจริง ๆ แล้วดูเหมือนว่าไม่มีใครให้คำตอบง่ายๆ: /
Thomas Decaux

คำตอบ:


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. คุณใส่ bootstrapping ข้อมูลที่ไหน? ในการเริ่มต้นขององค์ประกอบเช่น getInitialState หรือคุณวางไว้นอกองค์ประกอบและแสดงองค์ประกอบเมื่อมีข้อมูล?
skaterdav85

37
1. นี่คือแง่มุม 'หน้าที่' ของ React ข้อมูลทั้งหมด (เกือบ) ไหลลงด้านล่าง เนื่องจาก prop เป็นเจ้าของโดยผู้ปกครองเท่านั้นผู้ปกครองควรเปลี่ยน เป็นการดีที่เด็กควรไร้สัญชาติ ไม่สามารถทำได้ในทางปฏิบัติ (ดูเอกสารประกอบแบบฟอร์มบนไซต์ตอบโต้) 2. คุณสามารถป้อนได้ที่ด้านบนซึ่งเป็นวิธีปฏิบัติที่แนะนำหรือคุณสามารถเก็บไว้ในวัตถุแยกต่างหาก วิธีการหนึ่งที่เป็นที่นิยมคือ Flux ซึ่งใช้วัตถุซิงเกิลตันที่เรียกว่า Stores นี่เป็นส่วนหนึ่งของรูปแบบสถาปัตยกรรมที่ใหญ่กว่า นอกจากนี้ยังเปิดแหล่งที่มาจาก Facebook และออกแบบมาเพื่อทำงานกับ React
ทอดด์

2
ดังนั้นร้านค้าจึงเป็นเหมือนตัวแปรทั่วโลกขนาดใหญ่?
SuperUberDuper

3
ใช่ร้านค้า Flux เป็นแคชฝั่งไคลเอ็นต์ นอกจากนี้ยังมีรูปแบบอื่น ๆ เช่น Relay ที่เพิ่งเปิดตัวจาก Facebook และ Redux
ทอดด์

6
เมื่อต้องการต้มสิ่งนี้ลงเล็กน้อย: สถานะคือข้อมูลส่วนประกอบที่จัดการจากภายในอุปกรณ์ประกอบฉากเป็นข้อมูลส่วนประกอบที่จัดการจากด้านบนและส่งผ่าน
Mark

221

สำหรับการสื่อสารระหว่างผู้ปกครองและเด็ก ๆ เพียงส่งอุปกรณ์ประกอบฉาก

ใช้สถานะเพื่อเก็บข้อมูลที่หน้าปัจจุบันของคุณต้องการในมุมมองคอนโทรลเลอร์ของคุณ

ใช้อุปกรณ์ประกอบฉากเพื่อส่งผ่านตัวจัดการข้อมูลและเหตุการณ์ลงไปยังองค์ประกอบลูกของคุณ

รายการเหล่านี้ควรช่วยแนะนำคุณเมื่อทำงานกับข้อมูลในส่วนประกอบของคุณ

อุปกรณ์ประกอบฉาก

  • ไม่เปลี่ยนรูป
    • ซึ่งทำให้ React ทำการตรวจสอบการอ้างอิงอย่างรวดเร็ว
  • ถูกใช้เพื่อส่งผ่านข้อมูลจาก view-controller ของคุณ
    • องค์ประกอบระดับบนสุดของคุณ
  • มีประสิทธิภาพที่ดีขึ้น
    • ใช้สิ่งนี้เพื่อส่งผ่านข้อมูลไปยังองค์ประกอบลูก

สถานะ

  • ควรจัดการใน view-controller ของคุณ
    • องค์ประกอบระดับบนสุดของคุณ
  • ไม่แน่นอน
  • มีประสิทธิภาพแย่ลง
  • ไม่ควรเข้าถึงได้จากองค์ประกอบลูก
    • ผ่านมันไปพร้อมกับอุปกรณ์ประกอบฉากแทน

สำหรับการสื่อสารระหว่างสองคอมโพเนนต์ที่ไม่มีความสัมพันธ์พาเรนต์ - ชายคุณสามารถตั้งค่าระบบเหตุการณ์โกลบอลของคุณเอง สมัครสมาชิกกิจกรรมใน componentDidMount () ยกเลิกการสมัครสมาชิก componentWillUnmount () และโทร setState () เมื่อคุณได้รับเหตุการณ์ รูปแบบฟลักซ์เป็นหนึ่งในวิธีที่เป็นไปได้ในการจัดเรียงนี้ - https://facebook.github.io/react/tips/communicate-between-components.html

ส่วนประกอบใดควรมีสถานะ

ส่วนประกอบส่วนใหญ่ของคุณควรใช้ข้อมูลบางอย่างจากอุปกรณ์ประกอบฉากและแสดงผล อย่างไรก็ตามบางครั้งคุณต้องตอบสนองต่อการป้อนข้อมูลของผู้ใช้คำขอของเซิร์ฟเวอร์หรือเวลาที่ผ่านไป สำหรับสิ่งนี้คุณใช้สถานะ

พยายามที่จะเก็บเป็นจำนวนมากของอุปกรณ์ของคุณเป็นไปได้ไร้สัญชาติ ด้วยการทำเช่นนี้คุณจะแยกสถานะออกเป็นส่วนที่เป็นตรรกะมากที่สุดและลดความซ้ำซ้อนให้น้อยที่สุดทำให้ง่ายขึ้นในการให้เหตุผลเกี่ยวกับการสมัครของคุณ

รูปแบบทั่วไปคือการสร้างองค์ประกอบไร้สัญชาติหลายอย่างที่เพิ่งสร้างข้อมูลและมีส่วนประกอบที่เป็นสถานะเหนือพวกเขาในลำดับชั้นที่ส่งผ่านสถานะของลูก ๆ ไปยังอุปกรณ์ของตนผ่านอุปกรณ์ประกอบฉาก คอมโพเนนต์ stateful encapsulate ตรรกะการโต้ตอบทั้งหมดในขณะที่คอมโพเนนต์ stateless ดูแลข้อมูลเรนเดอร์ด้วยวิธีการประกาศ - https://facebook.github.io/react/docs/interactivity-and-dynamic-uis.html#what-components-should-have-state

สิ่งที่ควรไปในรัฐ

สถานะควรมีข้อมูลที่ตัวจัดการเหตุการณ์ของคอมโพเนนต์อาจเปลี่ยนแปลงเพื่อทริกเกอร์การอัปเดต UI ในแอปจริงข้อมูลนี้มีขนาดเล็กมากและสามารถปรับให้เป็นแบบ JSON ได้ เมื่อสร้างส่วนประกอบแบบ stateful คิดเกี่ยวกับการเป็นตัวแทนที่น้อยที่สุดที่เป็นไปได้ของรัฐและเก็บคุณสมบัติเหล่านั้นในรัฐนี้เท่านั้น Inside of render () เพียงคำนวณข้อมูลอื่น ๆ ที่คุณต้องการตามสถานะนี้ คุณจะพบว่าการคิดและการเขียนแอปพลิเคชันด้วยวิธีนี้มีแนวโน้มที่จะนำไปสู่แอปพลิเคชันที่ถูกต้องที่สุดเนื่องจากการเพิ่มค่าที่ซ้ำซ้อนหรือคำนวณได้ในสถานะหมายความว่าคุณต้องเก็บไว้อย่างชัดเจน - https://facebook.github.io/react/docs/interactivity-and-dynamic-uis.html#what-should-go-in-state


2
ไม่เห็นด้วยการไปอุปกรณ์ประกอบฉากทั้งหมดจะมีประสิทธิภาพน้อยกว่าในการส่งผ่านข้อมูล เพียงตั้งค่าร้านค้าสำหรับส่วนประกอบเด็กแล้วคุณไม่ต้องจัดการกับความยุ่งเหยิงของอุปกรณ์ประกอบฉากและเมื่ออุปกรณ์เปลี่ยนคุณต้องอัปเดตส่วนประกอบของคุณ เพียงอัปเดตร้านค้าของคุณและให้ส่วนประกอบรับข้อมูลจากร้านค้า
PositiveGuy

คุณช่วยบอกฉันหน่อยได้ไหมว่าทำไมอุปกรณ์ประกอบฉากถึงมีประสิทธิภาพมากกว่ารัฐ ขอบคุณ
hqt

@hqt ฉันคิดว่าเพราะมันไม่เปลี่ยนรูปพวกเขาการเปรียบเทียบภายในเพื่อเปลี่ยนค่าเร็วขึ้น
Gaspar

@BentOnCoding วันที่ดีโปรดช่วยคุณ ฉันสามารถจินตนาการว่าเป็นเช่นนั้นได้ทุกเวลาที่มีข้อมูลที่จะเปลี่ยนแปลงภายในองค์ประกอบของ USER INTERACTION ซึ่งเป็นสถานะที่ใช้หรือไม่
ผี

72

คุณสามารถเข้าใจได้ดีที่สุดโดยเชื่อมโยงกับฟังก์ชั่น Plain JS

เพียงแค่ใส่

Stateคือสถานะโลคัลของคอมโพเนนต์ซึ่งไม่สามารถเข้าถึงและแก้ไขภายนอกคอมโพเนนต์ มันเทียบเท่ากับตัวแปรท้องถิ่นในฟังก์ชั่น

ฟังก์ชัน JS ธรรมดา

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

อุปกรณ์ประกอบฉากในมืออื่น ๆ ส่วนประกอบทำให้นำมาใช้ใหม่โดยให้ชิ้นส่วนความสามารถในการรับข้อมูลจากส่วนประกอบพ่อแม่ของพวกเขาในรูปแบบของอุปกรณ์ประกอบฉาก พวกเขาเทียบเท่ากับพารามิเตอร์ฟังก์ชั่น

ฟังก์ชัน JS ธรรมดา

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" />

เครดิต: Manoj Singh Negi

ลิงก์ของบทความ: อธิบายสถานะของรัฐและอุปกรณ์ประกอบฉาก


16
นี้เป็นจริงคำตอบที่เป็นประโยชน์มาก หลังจากอ่านบทความนี้ฉันสามารถเข้าใจคำตอบที่สมบูรณ์ยิ่งขึ้น ขอบคุณ
Aaron

1
React component = ธรรมดา JS function เป็นวิธีที่ยอดเยี่ยมในการอธิบายสิ่งนี้อย่างชัดเจน และด้วย React ที่เพิ่มมากขึ้นไปยังส่วนประกอบที่ใช้งานได้
JD Sandifer

1
คำอธิบายที่ดีที่สุดที่ฉันได้อ่านขอบคุณ
iWizard

48

อุปกรณ์ประกอบฉากเทียบกับบทสรุปของรัฐที่ฉันชอบที่สุดอยู่ที่นี่: ตอบโต้ - แนะนำหมวกขนาดใหญ่สำหรับคนเหล่านั้น ด้านล่างเป็นเวอร์ชันที่แก้ไขของหน้านั้น:


อุปกรณ์ประกอบฉากเทียบกับรัฐ

tl; drหากชิ้นส่วนจำเป็นต้องเปลี่ยนหนึ่งในคุณลักษณะของมัน ณ เวลาใดเวลาหนึ่งแอตทริบิวต์นั้นควรเป็นส่วนหนึ่งของสถานะ


อุปกรณ์ประกอบฉาก

อุปกรณ์ประกอบฉาก (ย่อมาจากคุณสมบัติ) เป็นการกำหนดค่าของคอมโพเนนต์ พวกเขาจะได้รับจากด้านบนและไม่เปลี่ยนรูปเท่าที่ส่วนประกอบที่ได้รับนั้นเกี่ยวข้อง ชิ้นส่วนไม่สามารถเปลี่ยนอุปกรณ์ประกอบฉากได้ แต่มันมีความรับผิดชอบในการรวบรวมอุปกรณ์ประกอบของส่วนประกอบของเด็ก อุปกรณ์ประกอบฉากไม่จำเป็นต้องเป็นข้อมูลเท่านั้น - ฟังก์ชันการโทรกลับอาจถูกส่งผ่านเป็นอุปกรณ์ประกอบฉาก

สถานะ

สถานะเป็นโครงสร้างข้อมูลที่เริ่มต้นด้วยค่าเริ่มต้นเมื่อเมาต์คอมโพเนนต์ มันอาจจะกลายพันธุ์ข้ามเวลาส่วนใหญ่เป็นผลมาจากเหตุการณ์ของผู้ใช้

คอมโพเนนต์จัดการสถานะของตนเองภายใน นอกจากการตั้งค่าสถานะเริ่มต้นแล้วก็ไม่มีปัญหาเรื่องการเล่นกับลูกของมัน คุณอาจคิดว่าสถานะเป็นส่วนตัวกับองค์ประกอบนั้น

เปลี่ยนอุปกรณ์ประกอบฉากและรัฐ

                                                   รัฐอุปกรณ์ประกอบฉาก
    สามารถรับค่าเริ่มต้นจากองค์ประกอบหลัก? ใช่ ๆ
    สามารถเปลี่ยนแปลงได้โดยองค์ประกอบหลัก? ใช่ไม่ใช่
    สามารถตั้งค่าเริ่มต้นภายในส่วนประกอบได้หรือไม่ * ใช่ใช่
    สามารถเปลี่ยนภายในคอมโพเนนต์ได้หรือไม่ ไม่มีใช่
    สามารถตั้งค่าเริ่มต้นสำหรับคอมโพเนนต์ลูกได้หรือไม่ ใช่ ๆ
    สามารถเปลี่ยนแปลงองค์ประกอบย่อยได้หรือไม่? ใช่ไม่ใช่
  • โปรดทราบว่าทั้งอุปกรณ์ประกอบฉากและค่าเริ่มต้นที่ได้รับจากผู้ปกครองแทนที่ค่าเริ่มต้นที่กำหนดไว้ภายในส่วนประกอบ

ชิ้นส่วนนี้ควรมีสถานะหรือไม่

รัฐเป็นตัวเลือก เนื่องจากสถานะเพิ่มความซับซ้อนและลดความสามารถในการคาดการณ์ได้ดีกว่าส่วนประกอบที่ไม่มีสถานะจึงเหมาะสมกว่า แม้ว่าคุณจะไม่สามารถทำได้อย่างชัดเจนหากไม่มีสถานะในแอปแบบโต้ตอบคุณควรหลีกเลี่ยงการมีส่วนประกอบแบบ Stateful มากเกินไป

ประเภทส่วนประกอบ

ชิ้นส่วนไร้สัญชาติอุปกรณ์ประกอบฉากเท่านั้นไม่มีสถานะ ไม่มีอะไรเกิดขึ้นนอกจากฟังก์ชั่น render () ตรรกะของพวกเขาหมุนรอบอุปกรณ์ประกอบฉากที่พวกเขาได้รับ ซึ่งทำให้พวกเขาง่ายมากที่จะปฏิบัติตามและในการทดสอบ

Component Statefulทั้งอุปกรณ์ประกอบฉากและรัฐ สิ่งเหล่านี้จะถูกใช้เมื่อองค์ประกอบของคุณจะต้องรักษาบางสถานะ นี่เป็นสถานที่ที่ดีสำหรับการสื่อสารกับไคลเอนต์ - เซิร์ฟเวอร์ (XHR, เว็บซ็อกเก็ต ฯลฯ ) ประมวลผลข้อมูลและตอบสนองต่อเหตุการณ์ผู้ใช้ โลจิสติกส์เหล่านี้ควรถูกห่อหุ้มด้วยส่วนประกอบ Stateful ในระดับปานกลางในขณะที่การสร้างภาพข้อมูลและตรรกะการจัดรูปแบบทั้งหมดควรย้ายลงไปสู่องค์ประกอบไร้สัญชาติจำนวนมาก

แหล่งที่มา


1
คุณหมายถึงอะไรโดย "ค่าเริ่มต้นของรัฐที่ได้รับจากผู้ปกครอง"? เท่าที่ฉันรู้สถานะถูกกำหนดเฉพาะในขอบเขตขององค์ประกอบเดียวและไม่สามารถเปลี่ยนแปลงได้จากภายนอกโดยตรง
Maxim Kuzmin

@ MaximKuzmin ฉันเชื่อว่ามีการอ้างอิงถึงรูปแบบทั่วไปของการใช้เสาเช่น 'initialColor' เพื่อเริ่มต้นสถานะเช่น 'color' รัฐจะได้รับค่าเริ่มต้นจากเสา (ได้รับจากผู้ปกครอง) จากนั้นจะยังคงทำหน้าที่เหมือนสถานะปกติหลังจากนั้น อาจจะสับสนเล็กน้อยในการแนะนำรัฐกับอุปกรณ์ประกอบฉาก แต่เป็นรูปแบบที่สำคัญที่ต้องรู้
JD Sandifer

18

อุปกรณ์ประกอบฉาก (ย่อมาจาก“ คุณสมบัติ”) และสถานะเป็นทั้งวัตถุ JavaScript ธรรมดา ในขณะที่ทั้งสองเก็บข้อมูลที่มีผลต่อผลลัพธ์ของการแสดงผลพวกเขาจะแตกต่างกันในวิธีสำคัญ: props ส่งผ่านไปยังองค์ประกอบ (คล้ายกับพารามิเตอร์ฟังก์ชั่น) ในขณะที่รัฐมีการจัดการภายในองค์ประกอบ (คล้ายกับตัวแปร

ดังนั้นรัฐเพียงแค่ถูก จำกัด อยู่ที่องค์ประกอบปัจจุบันของคุณ แต่อุปกรณ์ประกอบฉากสามารถส่งผ่านไปยังองค์ประกอบใด ๆ ที่คุณต้องการ ... คุณสามารถผ่านสถานะขององค์ประกอบปัจจุบันเป็นเสาไปยังส่วนประกอบอื่น ๆ ...

นอกจากนี้ใน React เรามีส่วนประกอบไร้สัญชาติที่มีอุปกรณ์ประกอบฉากเท่านั้นและไม่ใช่สถานะภายใน ...

ตัวอย่างด้านล่างแสดงวิธีการทำงานในแอปของคุณ:

พาเรนต์ (องค์ประกอบเต็มของรัฐ):

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

รัฐ VS Props

  • รัฐสามารถเปลี่ยนแปลงได้ (ไม่แน่นอน)
  • ในขณะที่อุปกรณ์ประกอบฉากไม่สามารถ (ไม่เปลี่ยนรูป)

7

โดยทั่วไปความแตกต่างคือสถานะเป็นสิ่งที่ชอบคุณลักษณะใน OOP : มันเป็นสิ่งที่เฉพาะในชั้นเรียน (องค์ประกอบ) ที่ใช้ในการอธิบายได้ดีขึ้น อุปกรณ์ประกอบฉากเป็นเหมือนพารามิเตอร์ - พวกมันจะถูกส่งไปยังส่วนประกอบจากผู้เรียกส่วนประกอบ (แม่): ราวกับว่าคุณเรียกใช้ฟังก์ชันที่มีพารามิเตอร์บางตัว


5

ทั้งรัฐและอุปกรณ์ประกอบฉากในการตอบสนองจะใช้ในการควบคุมข้อมูลลงในส่วนประกอบโดยทั่วไปอุปกรณ์ประกอบฉากจะถูกกำหนดโดยผู้ปกครองและส่งผ่านไปยังองค์ประกอบของเด็กและพวกเขาได้รับการแก้ไขตลอดทั้งองค์ประกอบ สำหรับข้อมูลที่จะเปลี่ยนเราต้องใช้สถานะ และอุปกรณ์ประกอบฉากนั้นไม่เปลี่ยนรูปในขณะที่สถานะไม่แน่นอนถ้าคุณต้องการเปลี่ยนอุปกรณ์ประกอบฉากคุณสามารถทำได้จากองค์ประกอบหลักแล้วส่งต่อไปยังองค์ประกอบลูก


4

อย่างที่ฉันได้เรียนรู้ขณะทำงานกับปฏิกิริยา

  • อุปกรณ์ประกอบฉากถูกใช้โดยส่วนประกอบเพื่อรับข้อมูลจากสภาพแวดล้อมภายนอกเช่นองค์ประกอบอื่น(บริสุทธิ์การทำงานหรือคลาส) หรือคลาสทั่วไปหรือรหัสจาวาสคริปต์ / typescript

  • สถานะที่ใช้ในการจัดการสภาพแวดล้อมภายในของส่วนประกอบหมายถึงการเปลี่ยนแปลงข้อมูลภายในองค์ประกอบ


3

อุปกรณ์ประกอบฉาก: อุปกรณ์ประกอบฉากไม่มีอะไรนอกจากคุณสมบัติของส่วนประกอบและส่วนประกอบที่ทำปฏิกิริยาคืออะไรนอกจากฟังก์ชั่นจาวาสคริปต์

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

องค์ประกอบ const =;

ที่นี่<Welcome name="Sara" />ผ่านวัตถุ {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>
      );
     }
}


{"message": "Uncaught SyntaxError: โทเค็นที่ไม่คาดคิด <", "filename": " stacksnippets.net/js ", "lineno": 17, "colno": 9}
Niko Jojo

2

โดยพื้นฐานแล้วอุปกรณ์ประกอบฉากและสถานะเป็นสองวิธีที่องค์ประกอบสามารถรู้ได้ว่าจะแสดงผลอย่างไรและอย่างไร ส่วนใดของสถานะแอปพลิเคชันที่เป็นของรัฐและในร้านค้าระดับบนสุดเกี่ยวข้องกับการออกแบบแอปของคุณมากกว่าการทำงานของ React วิธีที่ง่ายที่สุดในการตัดสินใจ IMO คือการคิดว่าข้อมูลส่วนนี้มีประโยชน์สำหรับแอปพลิเคชั่นโดยรวมหรือเป็นข้อมูลท้องถิ่น นอกจากนี้สิ่งสำคัญคือต้องไม่ทำซ้ำสถานะดังนั้นหากข้อมูลบางอย่างสามารถคำนวณได้จากอุปกรณ์ประกอบฉาก - ควรคำนวณจากอุปกรณ์ประกอบฉาก

ตัวอย่างเช่นสมมติว่าคุณมีตัวควบคุมแบบเลื่อนลงบางส่วน (ซึ่งล้อมรอบเลือก HTML แบบมาตรฐานสำหรับการกำหนดสไตล์เอง) ซึ่งสามารถก) เลือกค่าบางอย่างจากรายการและ b) เปิดหรือปิด (เช่นรายการตัวเลือกที่แสดงหรือซ่อน) ตอนนี้สมมติว่าแอปของคุณแสดงรายการของการเรียงลำดับบางส่วนและตัวกรองการควบคุมแบบเลื่อนลงของคุณสำหรับรายการ จากนั้นจะเป็นการดีที่สุดที่จะส่งค่าตัวกรองที่ใช้งานเป็นเสาและรักษาสถานะเปิด / ปิดในท้องถิ่น นอกจากนี้เพื่อให้สามารถใช้งานได้คุณจะต้องส่งผ่านตัวจัดการ onChange จากองค์ประกอบหลักซึ่งจะเรียกว่าองค์ประกอบภายในรายการแบบเลื่อนลงและส่งข้อมูลที่อัปเดต ในทางตรงกันข้ามสถานะเปิด / ปิดสามารถเก็บไว้ในองค์ประกอบแบบเลื่อนลงได้เนื่องจากส่วนที่เหลือของแอปพลิเคชันไม่สนใจจริงๆว่าจะเปิดการควบคุมหรือไม่จนกว่าผู้ใช้จะเปลี่ยนค่า

รหัสต่อไปนี้ใช้งานไม่ได้ต้องใช้ css และจัดการเหตุการณ์คลิก / เบลอ / เปลี่ยนแบบเลื่อนลง แต่ฉันต้องการให้ตัวอย่างน้อยที่สุด หวังว่ามันจะช่วยให้เข้าใจความแตกต่าง

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

แต่ในการใช้งาน latests ของปฏิกิริยาพื้นเมืองคุณก็สามารถทำได้:

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

ตัวอย่างสองตัวอย่างนี้ทำงานในลักษณะเดียวกันแน่นอนมันเป็นเพียงการปรับปรุงไวยากรณ์

ดังนั้นอะไรคือความแตกต่างจากการใช้คุณลักษณะของวัตถุที่เรามีในการเขียนโปรแกรม OO เสมอ? โดยปกติแล้วข้อมูลที่อยู่ในสถานะของคุณจะไม่คงที่ แต่จะเปลี่ยนแปลงตลอดเวลาและมุมมองของคุณจะต้องอัปเดตเพื่อแสดงถึงการเปลี่ยนแปลงนี้ รัฐเสนอฟังก์ชั่นนี้ในวิธีที่ง่าย

รัฐหมายความว่าจะไม่ถูกต้อง! และฉันไม่สามารถสร้างความเครียดให้กับสิ่งนี้ได้มากพอ สิ่งนี้หมายความว่าอย่างไร หมายความว่าคุณไม่ควรทำสิ่งนี้

 state.key2 = newValue;

วิธีที่เหมาะสมในการทำคือ:

this.setState({ key2: newValue });

การใช้ this.setState ส่วนประกอบของคุณจะผ่านรอบการอัปเดตและหากส่วนใดส่วนหนึ่งของการเปลี่ยนแปลงสถานะวิธีการแสดงผลคอมโพเนนต์ของคุณจะถูกเรียกอีกครั้งเพื่อแสดงถึงการเปลี่ยนแปลงนี้

ตรวจสอบเอกสารตอบกลับเพื่อดูคำอธิบายที่กว้างขึ้น: https://facebook.github.io/react/docs/state-and-lifecycle.html


2

อุปกรณ์ประกอบฉากเป็นเพียงชวเลขสำหรับคุณสมบัติ อุปกรณ์ประกอบฉากเป็นวิธีที่ส่วนประกอบพูดคุยกัน หากคุณคุ้นเคยกับ React คุณควรรู้ว่าอุปกรณ์ประกอบฉากไหลลงมาจากองค์ประกอบหลัก

นอกจากนี้ยังมีกรณีที่คุณสามารถมีอุปกรณ์ประกอบฉากเริ่มต้นเพื่อให้อุปกรณ์ประกอบฉากถูกตั้งค่าแม้ว่าองค์ประกอบหลักจะไม่ผ่านอุปกรณ์ประกอบฉากลง

นี่คือเหตุผลที่ผู้คนอ้างถึง React ว่ามีการไหลของข้อมูลแบบทิศทางเดียว สิ่งนี้ใช้เวลาสักครู่หนึ่งในการทำความเข้าใจและฉันอาจจะบล็อกเรื่องนี้ในภายหลัง แต่สำหรับตอนนี้โปรดจำไว้ว่า: ข้อมูลไหลจากพ่อแม่สู่ลูก อุปกรณ์ประกอบฉากไม่เปลี่ยนรูป (คำแฟนซีสำหรับมันไม่เปลี่ยนแปลง)

ดังนั้นเราจึงมีความสุข คอมโพเนนต์รับข้อมูลจากพาเรนต์ เรียงทั้งหมดใช่ไหม

ก็ไม่มาก จะเกิดอะไรขึ้นเมื่อส่วนประกอบได้รับข้อมูลจากบุคคลอื่นที่ไม่ใช่ผู้ปกครอง เกิดอะไรขึ้นถ้าผู้ใช้ป้อนข้อมูลโดยตรงกับส่วนประกอบ?

นี่คือสาเหตุที่เรามีสถานะ

สถานะ

อุปกรณ์ประกอบฉากไม่ควรเปลี่ยนแปลงดังนั้นให้ก้าวขึ้น ส่วนประกอบโดยทั่วไปจะไม่มีสถานะดังนั้นจะเรียกว่าไร้สัญชาติ คอมโพเนนต์ที่ใช้สถานะเรียกว่า stateful รู้สึกอิสระที่จะทิ้งชิ้นอาหารอันโอชะเล็ก ๆ น้อย ๆ ที่ฝ่ายและดูผู้คนออกจากคุณ

ดังนั้นสถานะจะถูกใช้เพื่อให้ส่วนประกอบสามารถติดตามข้อมูลในระหว่างการแสดงผลที่ทำ เมื่อคุณ setState มันจะอัพเดทวัตถุสถานะจากนั้นแสดงส่วนประกอบอีกครั้ง นี่คือสุดยอดเพราะนั่นหมายถึง React ดูแลการทำงานหนักและรวดเร็วอย่างเห็นได้ชัด

เป็นตัวอย่างเล็กน้อยของรัฐนี่คือตัวอย่างจากแถบค้นหา (ควรตรวจสอบหลักสูตรนี้หากคุณต้องการเรียนรู้เพิ่มเติมเกี่ยวกับ React)

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

ในระยะสั้น

ไม่สามารถเปลี่ยนค่าอุปกรณ์ประกอบฉาก [ไม่เปลี่ยนรูป]

ค่าสถานะสามารถเปลี่ยนแปลงได้โดยใช้วิธี setState [ไม่แน่นอน]


1

state - มันเป็นคุณสมบัติที่ไม่แน่นอนพิเศษที่เก็บข้อมูลส่วนประกอบ มันมีค่าเริ่มต้นเมื่อ Componet mounts

อุปกรณ์ประกอบฉาก - มันเป็นคุณสมบัติพิเศษที่ไม่สามารถเปลี่ยนแปลงได้โดยธรรมชาติและใช้ในกรณีที่ผ่านค่าจากผู้ปกครองไปยังเด็ก อุปกรณ์ประกอบฉากเป็นเพียงช่องทางสื่อสารระหว่างส่วนประกอบย้ายจากด้านบน (แม่) ไปยังก้น (เด็ก) เสมอ

ด้านล่างเป็นตัวอย่างที่สมบูรณ์ของการรวมรัฐและอุปกรณ์ประกอบฉาก: -

<!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. ที่ใดก็ตามในแอปพลิเคชันข้อมูลควรถูกส่งผ่านเป็นอุปกรณ์ประกอบฉากสำหรับส่วนประกอบอื่น ๆ ทั้งหมด

ใช่แล้วอุปกรณ์ประกอบฉากมีการเปลี่ยนแปลง แต่จะเปลี่ยนที่ 'แหล่งที่มา' และจากนั้นจะไหลลงมาจากที่นั่น ดังนั้นอุปกรณ์ประกอบฉากจึงไม่เปลี่ยนแปลงในบริบทของส่วนประกอบที่รับมา

เช่นหน้าจอข้อมูลอ้างอิงที่ผู้ใช้แก้ไขรายชื่อซัพพลายเออร์จะจัดการสิ่งนี้ในสถานะซึ่งจะมีการดำเนินการทำให้ข้อมูลที่อัปเดตถูกบันทึกไว้ใน ReferenceDataState ซึ่งอาจต่ำกว่าหนึ่งระดับ AppState จากนั้นรายชื่อผู้จำหน่ายรายนี้จะถูกส่งเป็นอุปกรณ์ประกอบฉาก ส่วนประกอบทั้งหมดที่จำเป็นต้องใช้


1

ในการตอบสนองรัฐเก็บข้อมูลเช่นเดียวกับอุปกรณ์ประกอบฉาก ความแตกต่างกับหลังคือข้อมูลที่จัดเก็บสามารถแก้ไขได้โดยการเปลี่ยนแปลงที่แตกต่างกัน สิ่งเหล่านี้ไม่มีอะไรมากไปกว่าวัตถุที่เขียนด้วย JavaScript แบบคงที่ดังนั้นพวกเขาจึงสามารถมีข้อมูลหรือรหัสแทนข้อมูลที่คุณต้องการสร้างแบบจำลอง หากคุณต้องการรายละเอียดเพิ่มเติมขอแนะนำให้คุณดูสิ่งพิมพ์เหล่านี้การ ใช้งานของรัฐในการตอบสนองและการ ใช้อุปกรณ์ประกอบฉากในการตอบสนอง


1
  • อุปกรณ์ประกอบฉาก --- คุณไม่สามารถเปลี่ยนค่าได้
  • สหรัฐฯ --- คุณสามารถเปลี่ยนค่าในรหัสของคุณ แต่มันจะใช้งานได้เมื่อการเรนเดอร์เกิดขึ้น

1

ความแตกต่างบางอย่างระหว่าง“ สถานะ” และ“ อุปกรณ์ประกอบฉาก” ในปฏิกิริยา

ตอบสนองการควบคุมและการแสดงผล DOM ตามสถานะ สถานะส่วนประกอบมีสองประเภท: props คือสถานะที่ถ่ายโอนระหว่างส่วนประกอบและสถานะคือสถานะภายในของส่วนประกอบ อุปกรณ์ประกอบฉากใช้สำหรับการถ่ายโอนข้อมูลจากองค์ประกอบหลักไปยังองค์ประกอบลูก ส่วนประกอบยังมีสถานะของตนเองอยู่ภายใน: สถานะซึ่งสามารถแก้ไขได้ภายในส่วนประกอบเท่านั้น

โดยทั่วไปสถานะขององค์ประกอบบางอย่างอาจเป็นอุปกรณ์ประกอบขององค์ประกอบของเด็กอุปกรณ์จะถูกส่งผ่านไปยังเด็กซึ่งระบุไว้ในวิธีการแสดงผลขององค์ประกอบหลัก


1

อุปกรณ์ประกอบฉาก

  • อุปกรณ์ประกอบฉากใช้ในการส่งผ่านข้อมูลในองค์ประกอบลูก

  • อุปกรณ์ประกอบฉากเปลี่ยนค่านอกองค์ประกอบ (องค์ประกอบเด็ก)

สถานะ

  • สถานะการใช้งานภายในองค์ประกอบคลาส

  • สถานะเปลี่ยนค่าภายในองค์ประกอบ

  • หากคุณแสดงหน้าคุณเรียก setState เพื่อปรับปรุง DOM (ปรับปรุงค่าหน้า)

รัฐมีบทบาทสำคัญในการตอบโต้


0

ในการตอบคำถามเริ่มต้นเกี่ยวกับอุปกรณ์ประกอบฉากที่ไม่เปลี่ยนรูปพวกเขาจะกล่าวว่าไม่เปลี่ยนรูปตราบใดที่องค์ประกอบของเด็กเกี่ยวข้องแต่อาจเปลี่ยนแปลงได้ในผู้ปกครอง


0

ส่วนประกอบการทำปฏิกิริยาใช้สถานะในการอ่าน / เขียนตัวแปรภายในที่สามารถเปลี่ยนแปลงได้ / กลายพันธุ์โดยตัวอย่างเช่น:

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

อุปกรณ์ประกอบฉาก React เป็นวัตถุพิเศษที่อนุญาตให้โปรแกรมเมอร์รับตัวแปรและวิธีการจากคอมโพเนนต์หลักไปยังคอมโพเนนต์ย่อย

มันเหมือนกับ Windows และประตูบ้าน อุปกรณ์ประกอบฉากยังเป็นองค์ประกอบย่อยของเด็กที่ไม่สามารถเปลี่ยนแปลงหรืออัพเดทได้

มีสองวิธีที่ช่วยให้ฟังเมื่อมีการเปลี่ยนอุปกรณ์ประกอบฉากโดยองค์ประกอบหลัก


0

นี่คือมุมมองปัจจุบันของฉันเกี่ยวกับคำอธิบายระหว่างรัฐและอุปกรณ์ประกอบฉาก

  1. รัฐเป็นเหมือนตัวแปรท้องถิ่นของคุณภายในองค์ประกอบของคุณ คุณสามารถจัดการค่าสถานะโดยใช้การตั้งค่าสถานะ จากนั้นคุณสามารถส่งค่าสถานะไปยังองค์ประกอบย่อยของคุณได้

  2. อุปกรณ์ประกอบฉากเป็นค่าที่ตั้งอยู่ในร้าน redux ของคุณอย่างแท้จริงสิ่งนี้มาจากสถานะที่มาจากตัวลด ส่วนประกอบของคุณควรเชื่อมต่อกับ redux เพื่อรับค่าจากอุปกรณ์ประกอบฉาก นอกจากนี้คุณยังสามารถส่งค่าอุปกรณ์ประกอบฉากของคุณไปยังองค์ประกอบลูกของคุณ


0

คำอธิบายง่ายๆคือ: STATE เป็นสถานะของส่วนประกอบในท้องถิ่นเช่น color = "blue" หรือ animation = true เป็นต้น ใช้ this.setState เพื่อเปลี่ยนสถานะของส่วนประกอบ PROPS เป็นวิธีที่ส่วนประกอบพูดคุยกัน (ส่งข้อมูลจากพ่อแม่สู่ลูก) และทำให้ส่วนประกอบสามารถนำมาใช้ใหม่


0

รัฐคือข้อมูลของคุณไม่แน่นอนคุณสามารถทำอะไรก็ได้ที่คุณต้องการอุปกรณ์ประกอบฉากเป็นข้อมูลที่อ่านได้อย่างเดียวโดยปกติเมื่อคุณส่งอุปกรณ์ประกอบฉากที่คุณได้ทำงานกับข้อมูลของคุณแล้วและคุณต้องการให้องค์ประกอบของเด็กแสดง ฟังก์ชั่นคุณเรียกมันว่าเพื่อทำงาน


0

รัฐคือต้นกำเนิดของความจริงที่ซึ่งข้อมูลของคุณอาศัยอยู่ คุณสามารถพูดได้ว่ารัฐแสดงออกผ่านอุปกรณ์ประกอบฉาก

การจัดหาอุปกรณ์ประกอบฉากให้กับองค์ประกอบคือสิ่งที่ทำให้ UI ของคุณซิงค์กับข้อมูลของคุณ องค์ประกอบเป็นเพียงฟังก์ชันที่ส่งคืนมาร์กอัป

ได้รับอุปกรณ์ประกอบฉากเดียวกัน (ข้อมูลที่จะแสดง) มันจะสร้างมาร์กอัปเดียวกันเสมอ

ดังนั้นอุปกรณ์ประกอบฉากจึงเป็นเหมือนท่อส่งข้อมูลจากแหล่งกำเนิดไปยังส่วนประกอบที่ใช้งานได้


0

อุปกรณ์ประกอบฉาก:แสดงข้อมูล "อ่านอย่างเดียว" ซึ่งไม่เปลี่ยนรูปและอ้างถึงแอตทริบิวต์จากองค์ประกอบของผู้ปกครอง

สถานะ:แสดงข้อมูลที่ไม่แน่นอนซึ่งมีผลต่อสิ่งที่แสดงในหน้าเว็บและจัดการโดยส่วนประกอบภายในตัวเองและเปลี่ยนการทำงานล่วงเวลาโดยทั่วไปเนื่องจากผู้ใช้ป้อนข้อมูล


1
มีเพียง 1 pro หรือไม่ และ 1 แย้ง
Book Of Zeus

0

ข้อแตกต่างที่สำคัญคือสถานะนั้นเป็นแบบส่วนตัวกับส่วนประกอบและสามารถเปลี่ยนแปลงได้ภายในส่วนประกอบนั้นในขณะที่อุปกรณ์ประกอบฉากเป็นเพียงค่าคงที่และคีย์สำหรับองค์ประกอบลูกซึ่งถูกส่งผ่านส่วนประกอบหลักและไม่สามารถเปลี่ยนแปลงภายในองค์ประกอบลูกได้

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.