คำถามติดแท็ก immutability

ฉันเห็นประโยชน์ของการทำให้วัตถุในโปรแกรมของฉันไม่เปลี่ยนรูป เมื่อฉันคิดอย่างลึกซึ้งเกี่ยวกับการออกแบบที่ดีสำหรับแอปพลิเคชันของฉันฉันมักจะมาถึงวัตถุหลายอย่างของฉันที่ไม่เปลี่ยนรูป บ่อยครั้งที่มันมาถึงจุดที่ฉันต้องการให้วัตถุทั้งหมดของฉันไม่เปลี่ยนรูป คำถามนี้เกี่ยวกับความคิดเดียวกัน แต่ไม่มีคำตอบแนะนำว่าอะไรคือวิธีที่ดีในการเปลี่ยนรูปแบบไม่ได้และเมื่อใดจะใช้งานจริง มีรูปแบบการออกแบบที่เปลี่ยนแปลงไม่ได้บ้างไหม? แนวคิดทั่วไปดูเหมือนจะ "ทำให้วัตถุไม่เปลี่ยนรูปเว้นแต่คุณต้องการเปลี่ยนอย่างแน่นอน" ซึ่งไม่มีประโยชน์ในทางปฏิบัติ ประสบการณ์ของฉันคือการไม่เปลี่ยนรูปไดรฟ์รหัสของฉันมากขึ้นในกระบวนทัศน์การทำงานและความก้าวหน้านี้เกิดขึ้นเสมอ: ฉันเริ่มต้องการโครงสร้างข้อมูลแบบถาวร (ในแง่การใช้งาน) เช่นรายการแผนที่เป็นต้น มันไม่สะดวกอย่างยิ่งที่จะทำงานกับการอ้างอิงข้าม (เช่นโหนดต้นไม้ที่อ้างถึงลูกของมันในขณะที่เด็กที่อ้างอิงถึงพ่อแม่ของพวกเขา) ซึ่งทำให้ฉันไม่ได้ใช้การอ้างอิงไขว้เลยซึ่งทำให้โครงสร้างข้อมูลและรหัสของฉันทำงานได้อีก การรับมรดกหยุดที่จะทำให้ความรู้สึกใด ๆ และฉันเริ่มที่จะใช้องค์ประกอบแทน แนวคิดพื้นฐานทั้งหมดของ OOP เช่นการห่อหุ้มเริ่มที่จะกระจุยและวัตถุของฉันเริ่มดูเหมือนฟังก์ชั่น ณ จุดนี้ฉันแทบจะไม่ใช้อะไรเลยจากกระบวนทัศน์ของ OOP อีกต่อไปและสามารถเปลี่ยนเป็นภาษาที่ใช้งานได้อย่างหมดจด ดังนั้นคำถามของฉัน: มีวิธีการที่สอดคล้องกับการออกแบบ OOP ที่ไม่เปลี่ยนรูปแบบที่ดีหรือเป็นกรณีที่เมื่อคุณใช้ความคิดที่ไม่เปลี่ยนรูปแบบให้ได้เต็มศักยภาพคุณมักจะจบลงด้วยการเขียนโปรแกรมในภาษาที่ใช้งานได้ มีแนวทางที่ดีหรือไม่ในการตัดสินใจว่าคลาสใดควรไม่เปลี่ยนรูปแบบและควรจะอยู่ในรูปแบบใดเพื่อให้แน่ใจว่า OOP ไม่แตกสลาย? เพื่อความสะดวกฉันจะยกตัวอย่าง มาChessBoardเป็นคอลเล็กชั่นหมากรุกที่ไม่เปลี่ยนรูปแบบกันเถอะ(ขยายคลาสนามธรรม)Piece) จากมุมมองของ OOP ชิ้นส่วนมีหน้าที่สร้างการเคลื่อนไหวที่ถูกต้องจากตำแหน่งบนกระดาน แต่เพื่อสร้างการเคลื่อนไหวชิ้นส่วนจำเป็นต้องมีการอ้างอิงถึงคณะกรรมการในขณะที่คณะกรรมการจะต้องมีการอ้างอิงถึงชิ้นส่วนของมัน มีเทคนิคบางอย่างในการสร้างการอ้างอิงโยงที่ไม่เปลี่ยนรูปแบบเหล่านี้ขึ้นอยู่กับภาษา OOP ของคุณ แต่พวกเขามีความเจ็บปวดในการจัดการดีกว่าไม่มีชิ้นส่วนที่จะอ้างอิงบอร์ดของมัน แต่ชิ้นส่วนนั้นไม่สามารถสร้างการเคลื่อนไหวได้เนื่องจากมันไม่ทราบสถานะของบอร์ด จากนั้นชิ้นส่วนจะกลายเป็นเพียงโครงสร้างข้อมูลที่เก็บประเภทชิ้นส่วนและตำแหน่งของชิ้นงาน จากนั้นคุณสามารถใช้ฟังก์ชัน polymorphic เพื่อสร้างการเคลื่อนไหวสำหรับชิ้นส่วนทุกประเภท สิ่งนี้สามารถทำได้อย่างสมบูรณ์แบบในการเขียนโปรแกรมใช้งานได้ แต่แทบจะเป็นไปไม่ได้ใน …

11 object-oriented  functional-programming  immutability 

ฉันต้องการเรียนรู้วิธีสร้างกราฟและดำเนินการบางอย่างกับพวกเขาใน Haskell แต่คำถามนั้นไม่เฉพาะเจาะจงกับ Haskell และแทนที่จะเป็นกราฟเราอาจพิจารณาเชื่อมโยงรายการเป็นสองเท่า คำถาม: อะไรจะเป็นสำนวนหรือแนะนำวิธีการใช้รายการเชื่อมโยงทวีคูณ (หรืออื่น ๆ ที่เชื่อมโยงทวีคูณหรือโครงสร้างข้อมูลแบบวงกลม) และการดำเนินงานในภาษาที่สนับสนุนและสนับสนุนสำหรับโครงสร้างข้อมูลที่ไม่เปลี่ยนรูปแบบ (Haskell, Clojure เป็นต้น) ? โดยเฉพาะอย่างยิ่งวิธีการใช้การอัปเดตในสถานที่ซึ่งภาษาต้องห้ามอย่างเป็นทางการ? ฉันสามารถจินตนาการได้อย่างง่ายดายว่าหากมีการดำเนินการในท้องถิ่นในรายการที่ลิงก์ซ้ำกัน (หากมีการแทรกรายการไว้) อาจไม่จำเป็นต้องคัดลอกรายการทั้งหมดทันทีเนื่องจากความเกียจคร้านของภาษา อย่างไรก็ตามเนื่องจากรายการมีการเชื่อมโยงเป็นสองเท่าหากมีการแก้ไขในที่เดียวจึงไม่มีโหนดเก่าที่สามารถใช้ในรายการเวอร์ชันใหม่และพวกเขาจะต้องทำเครื่องหมายคัดลอกคัดลอกเก็บขยะไม่ช้า . เห็นได้ชัดว่าสิ่งเหล่านี้เป็นการดำเนินการที่ซ้ำซ้อนหากจะใช้เฉพาะสำเนาที่ปรับปรุงแล้วของรายการ แต่พวกเขาจะเพิ่มสัดส่วน "ค่าใช้จ่าย" ตามขนาดของรายการ นี่หมายความว่าสำหรับงานดังกล่าวข้อมูลที่ไม่เปลี่ยนรูปแบบนั้นไม่เหมาะสมและภาษาที่ประกาศได้โดยไม่ต้องมีการสนับสนุน "ดั้งเดิม" สำหรับข้อมูลที่ไม่แน่นอนไม่ดีเท่าที่จำเป็นหรือไม่? หรือมีวิธีแก้ปัญหาที่ยุ่งยากบ้างไหม? ป.ล. ฉันได้พบบทความและงานนำเสนอบางอย่างเกี่ยวกับเรื่องนี้ในอินเทอร์เน็ต แต่มีความยากลำบากในการติดตามพวกเขาในขณะที่ฉันคิดว่าคำตอบของคำถามนี้ไม่ควรใช้มากกว่าหนึ่งย่อหน้าและอาจเป็นไดอะแกรม ... ฉันหมายถึงถ้ามี ไม่มีวิธีแก้ปัญหา "ฟังก์ชั่น" สำหรับปัญหานี้คำตอบน่าจะเป็น "ใช้ C" หากมีอย่างใดอย่างหนึ่งมันจะซับซ้อนแค่ไหน? คำถามที่เกี่ยวข้อง "โครงสร้างข้อมูลในการโปรแกรมเชิงฟังก์ชัน" . คำถามเฉพาะของฉันเกี่ยวกับการใช้การอัปเดตแบบแทนที่ไม่ใช้ทางเลือกที่ไม่มีประสิทธิภาพ การกลายพันธุ์ภายในของโครงสร้างข้อมูลถาวร " . ดูเหมือนจะเน้นไปที่การใช้งานในระดับต่ำในภาษาที่ไม่ได้ระบุในขณะที่คำถามของฉันเกี่ยวกับการเลือกภาษาที่ถูกต้อง (การใช้งานหรืออื่น ๆ …

11 data-structures  functional-programming  graph  immutability 

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

10 c#  immutability  properties 

ฉันสามารถเห็นประโยชน์ของวัตถุที่เปลี่ยนแปลงไม่ได้กับวัตถุที่เปลี่ยนแปลงไม่ได้เช่นวัตถุที่ไม่เปลี่ยนรูปทำให้ยากต่อการแก้ไขปัญหาในการเขียนโปรแกรมแบบมัลติเธรดเนื่องจากสถานะที่ใช้ร่วมกันและเขียนได้ ในทางตรงกันข้ามวัตถุที่ไม่แน่นอนช่วยในการจัดการกับตัวตนของวัตถุมากกว่าการสร้างสำเนาใหม่ทุกครั้งและยังปรับปรุงประสิทธิภาพและการใช้หน่วยความจำโดยเฉพาะอย่างยิ่งสำหรับวัตถุขนาดใหญ่ สิ่งหนึ่งที่ฉันพยายามเข้าใจคือสิ่งที่ผิดพลาดในการมีวัตถุที่ไม่แน่นอนในบริบทของการเขียนโปรแกรมการทำงาน อย่างหนึ่งในจุดที่บอกกับฉันคือผลลัพธ์ของการเรียกฟังก์ชั่นในลำดับที่แตกต่างกันนั้นไม่ได้กำหนดขึ้น ฉันกำลังมองหาตัวอย่างที่เป็นรูปธรรมที่ชัดเจนว่าอะไรผิดพลาดได้โดยใช้วัตถุที่ไม่แน่นอนในการเขียนโปรแกรมฟังก์ชั่น โดยทั่วไปถ้ามันไม่ดีก็ไม่ดีโดยไม่คำนึงถึง OO หรือกระบวนทัศน์การเขียนโปรแกรมการทำงานใช่ไหม ฉันเชื่อว่าข้อความของฉันตอบคำถามนี้เอง แต่ฉันก็ยังต้องการตัวอย่างเพื่อที่ฉันจะได้รู้สึกเป็นธรรมชาติมากขึ้น OO ช่วยในการจัดการการพึ่งพาและเขียนโปรแกรมที่ง่ายขึ้นและบำรุงรักษาด้วยความช่วยเหลือของเครื่องมือเช่น encapsulation, polymorphism เป็นต้น ฟังก์ชั่นการเขียนโปรแกรมยังมีแรงจูงใจเดียวกันในการส่งเสริมรหัสที่สามารถบำรุงรักษาได้ แต่โดยการใช้สไตล์ซึ่งไม่จำเป็นต้องใช้เครื่องมือและเทคนิค OO - หนึ่งในสิ่งที่ฉันเชื่อคือการลดผลข้างเคียงฟังก์ชั่นบริสุทธิ์ ฯลฯ

9 c#  object-oriented  programming-practices  functional-programming  immutability 

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

9 functional-programming  haskell  clojure  immutability 

ฉันกำลังพัฒนาแอพพลิเคชั่น GUI ทำงานหนักกับกราฟิก - คุณสามารถคิดได้ว่ามันเป็นตัวแก้ไขเวกเตอร์เพื่อประโยชน์ของตัวอย่าง การดึงดูดให้โครงสร้างข้อมูลทั้งหมดไม่สามารถเปลี่ยนแปลงได้ - ดังนั้นฉันสามารถเลิกทำ / ทำซ้ำคัดลอก / วางและอื่น ๆ อีกมากมายโดยไม่ต้องใช้ความพยายาม สำหรับประโยชน์ของความเรียบง่ายฉันจะใช้ตัวอย่างต่อไปนี้ - แอปพลิเคชันใช้ในการแก้ไขรูปหลายเหลี่ยมดังนั้นฉันจึงมีวัตถุ "รูปหลายเหลี่ยม" ซึ่งเป็นเพียงรายการของจุดที่ไม่เปลี่ยนรูป: Scene -> Polygon -> Point ดังนั้นฉันจึงมีตัวแปรที่เปลี่ยนแปลงไม่ได้เพียงตัวเดียวในโปรแกรมของฉัน - ตัวแปรที่เก็บวัตถุฉากปัจจุบัน ปัญหาที่ฉันเริ่มเมื่อฉันพยายามใช้การลากจุด - ในเวอร์ชันที่ไม่แน่นอนฉันก็คว้าPointวัตถุและเริ่มแก้ไขพิกัดของมัน ในเวอร์ชันที่ไม่เปลี่ยนรูป - ฉันติดอยู่ ฉันสามารถเก็บดัชนีของPolygonปัจจุบันSceneดัชนีจุดลากPolygonเข้ามาและแทนที่ทุกครั้ง แต่วิธีการนี้ไม่ได้ปรับขนาด - เมื่อระดับการเขียนเรียงกันถึง 5 และไกลออกไปแผ่นกันความร้อนก็จะทนไม่ได้ ฉันแน่ใจว่าปัญหานี้สามารถแก้ไขได้ - หลังจากทั้งหมดมี Haskell ที่มีโครงสร้างที่ไม่เปลี่ยนแปลงอย่างสมบูรณ์และ IO monad แต่ฉันไม่สามารถหาวิธีได้ คุณสามารถให้คำแนะนำแก่ฉันได้ไหม

9 design-patterns  immutability