วัตถุที่ไม่แน่นอน
ใน JavaScript วัตถุเป็นข้อมูลประเภทอ้างอิง ข้อได้เปรียบคือเมื่อวัตถุได้รับการแก้ไขบ่อยครั้งพวกเขาจะถูกแก้ไขตามวัตถุต้นฉบับและไม่จำเป็นต้องสร้างใหม่ สิ่งนี้สามารถใช้หน่วยความจำได้อย่างมีประสิทธิภาพและจะไม่ทำให้พื้นที่หน่วยความจำเสีย คุณลักษณะของวัตถุนี้สามารถเรียกได้ว่าไม่แน่นอนซึ่งหมายถึง "ไม่แน่นอน" เป็นภาษาจีน
สำหรับวัตถุที่ไม่แน่นอนความยืดหยุ่นและการเปลี่ยนแปลงบางครั้งอาจกลายเป็นข้อเสีย ยิ่งข้อมูลมีความยืดหยุ่นและเปลี่ยนแปลงได้มากเท่าไหร่ก็ยิ่งควบคุมได้ยากขึ้นเท่านั้น สำหรับวัตถุที่มีโครงสร้างที่ซับซ้อนข้อมูลจะถูกแก้ไขโดยไม่ตั้งใจโดยไม่ได้ตั้งใจ หากวัตถุถูกใช้ในหลายขอบเขตมันเป็นเรื่องยากที่จะคาดการณ์ว่าข้อมูลจะเปลี่ยนไปหรือไม่
var obj = {/* วัตถุที่มีโครงสร้างที่ซับซ้อน*/}; dosomething (obj); // หลังจากบรรทัดฟังก์ชันข้างต้นเสร็จสิ้นแล้ว OBJ ยังคงเป็น OBJ ดั้งเดิมในเวลานี้หรือไม่?ในการแก้ไขปัญหานี้วิธีแก้ปัญหาทั่วไปสามารถคัดลอกวัตถุใหม่โดยการคัดลอกวัตถุลึกจากนั้นแก้ไขบนวัตถุใหม่ สิ่งนี้สามารถรับประกันความสามารถในการควบคุมข้อมูล แต่การคัดลอกบ่อยครั้งจะทำให้พื้นที่หน่วยความจำเสียจำนวนมาก
var obj = {/* วัตถุที่มีโครงสร้างที่ซับซ้อน*/}; // Copy สร้าง obj2 // ใหม่ แต่การดำเนินการคัดลอกจะเสียพื้นที่หน่วยความจำ var obj2 = deepclone (obj); dosomething (obj2); // หลังจากฟังก์ชั่นข้างต้นเสร็จสิ้นหรือไม่วัตถุที่ไม่เปลี่ยนรูป
เพื่อที่จะแก้ปัญหาข้างต้นได้ดีขึ้นวัตถุที่ไม่เปลี่ยนรูปจะปรากฏขึ้นซึ่งเป็น "ไม่เปลี่ยนรูป" แปลเป็นภาษาจีนอย่างแท้จริง ทุกครั้งที่มีการปรับเปลี่ยนวัตถุที่ไม่เปลี่ยนรูปจะสร้างวัตถุที่ไม่เปลี่ยนรูปใหม่ การดำเนินการบนวัตถุใหม่จะไม่ส่งผลกระทบต่อข้อมูลของวัตถุต้นฉบับ วัตถุพิเศษนี้ไม่ได้เป็นคุณสมบัติการทำงานใหม่ของ JavaScript แต่เป็นชุดของโซลูชั่นที่จัดทำโดยอุตสาหกรรมเพื่อแก้ปัญหานี้และห้องสมุดโอเพนซอร์สที่ยอดเยี่ยมบางแห่งได้โผล่ออกมาซึ่งมีชื่อเสียงมากที่สุดซึ่งเป็นโอเพ่นซอร์สของ Lee Byron ของ Facebook แน่นอนว่าการแก้ปัญหาของ Immutable นั้นไม่ได้เป็นต้นฉบับ แต่มาจาก Clojure และ Scala
การเปรียบเทียบประสิทธิภาพระหว่างการเปลี่ยนแปลงและไม่เปลี่ยนรูป
การทำงานที่ไม่มีประสิทธิภาพของวัตถุที่ไม่แน่นอนนั้นสะท้อนให้เห็นเป็นหลักในการจำลองแบบและการเปรียบเทียบและวัตถุที่ไม่เปลี่ยนรูปช่วยแก้จุดปวดที่ไม่มีประสิทธิภาพทั้งสองนี้
การดำเนินการคัดลอกลึกของวัตถุที่ไม่สามารถเปลี่ยนได้ทั่วไปจะคัดลอกข้อมูลทั้งหมด วัตถุที่ไม่เปลี่ยนรูปจะไม่คัดลอกข้อมูลทั้งหมดเมื่อแก้ไขข้อมูล แต่จะถ่ายโอนความสัมพันธ์แบบพาเรนต์-ลูกระหว่างโหนดที่เปลี่ยนแปลงและโหนดที่ไม่เปลี่ยนแปลงไปยังโหนดใหม่คล้ายกับโครงสร้างของรายการที่เชื่อมโยง จากมุมมองของ "คัดลอก" การลดการจำลองแบบจะเกิดขึ้นได้และส่วนที่ไม่เปลี่ยนแปลงจะถูกแชร์ Mutable คือ "เต็ม" เมื่อคัดลอกในขณะที่ไม่เปลี่ยนรูปคือ "เพิ่มขึ้น" ซึ่งกำหนดอัตราการใช้งานที่สูงหรือต่ำของพื้นที่หน่วยความจำ
และขึ้นอยู่กับคุณลักษณะที่ทุกครั้งที่มีการแก้ไขวัตถุที่ไม่เปลี่ยนรูปจะมีการสร้างวัตถุที่ไม่เปลี่ยนรูปใหม่ สิ่งนี้สามารถบันทึกสถานะการแก้ไขของข้อมูลลงในชุดสแน็ปช็อตซึ่งค่อนข้างสะดวก
มาพูดคุยเกี่ยวกับการดำเนินการเปรียบเทียบ สำหรับวัตถุที่ไม่แน่นอนหากคุณต้องการเปรียบเทียบว่าวัตถุทั้งสองเท่ากันคุณต้องสำรวจแต่ละโหนดของวัตถุเพื่อเปรียบเทียบ สำหรับวัตถุที่มีโครงสร้างที่ซับซ้อนประสิทธิภาพของพวกเขาจะไม่สูงขึ้นอย่างแน่นอน สำหรับวัตถุที่ไม่เปลี่ยนรูปแบบไม่เปลี่ยนรูป js ให้ API ที่กำหนดโดยตรงว่า "ค่า" ของวัตถุสองตัวที่ไม่เปลี่ยนรูปนั้นเท่ากันหรือไม่
var map1 = immutable.map ({a: 1, b: 1, c: 1}); var map2 = immutable.map ({a: 1, b: 1, c: 1}); assert (map1! == map2); // สำหรับอินสแตนซ์ที่ไม่เปลี่ยนรูปที่แตกต่างกันที่อยู่อ้างอิงยืนยัน (immutable.is (MAP1, MAP2)); // ค่าของ MAP1 และ MAP2 เท่ากันและค่ายืนยัน (MAP1.Equals (MAP2)); // ฟังก์ชั่นของการเปลี่ยนรูปไม่เหมือนกันในแอพพลิเคชั่นการพัฒนาจริงประสิทธิภาพไม่ได้เป็นสิ่งสำคัญและสำคัญที่สุดเสมอไป สำหรับโครงการ JavaScript ทั่วไปความสามารถในการควบคุมข้อมูลที่เกิดจากลักษณะของการเปลี่ยนแปลงไม่ได้เป็นประโยชน์มากกว่าประสิทธิภาพ สำหรับวัตถุที่ไม่แน่นอนมันเหมาะสำหรับการใช้งานในขอบเขตปิดในขณะที่วัตถุที่ไม่เปลี่ยนรูปนั้นเหมาะสำหรับการใช้งานเมื่อต้องส่งข้อมูลในหลายขอบเขต
ความแตกต่างระหว่างความไม่แน่นอนและไม่เปลี่ยนรูป
immutable.js ให้โครงสร้างข้อมูลที่หลากหลาย: รวมถึงรายการสแต็กแผนที่ orderedmap set ordered record records ซึ่งสอดคล้องกับโครงสร้างข้อมูลที่ไม่แน่นอน
ฉันจะไม่อธิบายการใช้งานของโครงสร้างข้อมูลแต่ละครั้งที่นี่ แต่ส่วนใหญ่พูดถึงความแตกต่างระหว่างการใช้วัตถุที่ไม่เปลี่ยนรูปและวัตถุที่ไม่แน่นอน
วัตถุที่ไม่แน่นอนพื้นเมืองนั้นสะดวกมากสำหรับ "การอ่าน" และ "การเขียน"
var mutableObj = {}; // เขียน data mutableobj.foo = 'bar'; // อ่าน data console.log (mutableobj.foo);วัตถุที่ไม่เปลี่ยนรูปต้อง "อ่าน" และ "เขียน" ข้อมูลผ่านชุดและรับ
var immutableObj1 = immutable.map (); // เขียนข้อมูล var imutableObj2 = immutableObj1.set ('foo', 'bar'); // อ่าน data console.log (immutableObj2.get ('foo')); // => 'bar'เพื่อแสดงให้เห็นถึงการใช้วิธีการตั้งค่าตัวอย่างด้านบนสร้างวัตถุเปล่าที่จุดเริ่มต้นและในความเป็นจริงค่าเริ่มต้นสามารถส่งผ่านในระหว่างการสร้างอินสแตนซ์
var immutableObj = immutable.map ({'foo', 'bar'});สำหรับข้อมูลที่มีระดับที่ลึกกว่านั้นอินเทอร์เฟซการเข้าถึงที่จัดทำโดยไม่เปลี่ยนรูป JS นั้นสะดวกมาก
var immutableObj1 = immutable.fromjs ({a: {b: 'c'}, d: [1, 2, 3]}); // อ่าน dea data console.log (immutableObj1.getin (['a', 'b']) // => 'c'console.log (immutableObj1.getin ([' a ',' b '])); // => 2 // แก้ไขข้อมูลลึก var immutableObj2 = immutableObj1.setin (['a', 'b'], 'd'); console.log (ไม่เปลี่ยนรูป // => 'D'หากเป็นวัตถุที่ไม่แน่นอนดั้งเดิมอาจมีการรายงานข้อผิดพลาดที่ไม่ได้กำหนดเมื่อเข้าถึงข้อมูลระดับลึกในห่วงโซ่ในขณะที่วัตถุที่ไม่เปลี่ยนรูปจะไม่รายงานข้อผิดพลาดเมื่อพบสถานการณ์นี้และการส่งคืนจะไม่ได้กำหนด
เมื่อทำการดีบักหากคุณต้องการดูโครงสร้างภายในของวัตถุที่ไม่เปลี่ยนรูปแบบขอแนะนำให้ใช้ TOJSON () เพื่อแปลงเป็นวัตถุที่ไม่แน่นอนปกติก่อน