หากโมฆะเป็นสิ่งที่ชั่วร้ายสิ่งที่ควรใช้เมื่อค่าสามารถขาดความหมายได้อย่างไร

นี่เป็นกฎข้อหนึ่งที่ซ้ำแล้วซ้ำอีกและทำให้ฉันงงงวย

Nulls เป็นความชั่วร้ายและควรหลีกเลี่ยงเมื่อใดก็ตามที่เป็นไปได้

แต่จากความไร้เดียงสาของฉันให้ฉันกรีดร้อง - บางครั้งคุณค่าอาจหายไปอย่างมีความหมาย!

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

หลังจากนั้นแต่ละครั้งเซิร์ฟเวอร์จะเผยแพร่รายการของการอัปเดตรหัส JS ฝั่งไคลเอ็นต์ ชั้นอัปเดต:

public class GameUpdate
{
    public Player player;
    // other stuff
}

คลาสนี้ได้รับการต่อเนื่องเป็น JSON และส่งไปยังผู้เล่นที่เชื่อมต่อ

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

แน่นอนฉันสามารถ "แก้ไข" รหัสนี้โดยใช้การสืบทอด:

public class GameUpdate
{
    // stuff
}

public class GamePlayerUpdate : GameUpdate
{
    public Player player;
    // other stuff
}

อย่างไรก็ตามฉันล้มเหลวที่จะเห็นว่านี่คือการปรับปรุงใด ๆ ด้วยเหตุผลสองประการ:

• ตอนนี้โค้ด JS จะได้รับวัตถุที่ไม่มีผู้เล่นเป็นคุณสมบัติที่กำหนดซึ่งเหมือนกับว่ามันเป็นโมฆะเนื่องจากทั้งสองกรณีจำเป็นต้องตรวจสอบว่ามีค่าหรือไม่อยู่;
• หากมีการเพิ่มฟิลด์ nullable อื่นลงในคลาส GameUpdate ฉันจะต้องสามารถใช้การสืบทอดหลาย ๆ อันเพื่อดำเนินการต่อด้วยดีไซน์นี้ - แต่ MI นั้นชั่วร้ายในสิทธิ์ของตนเอง (ตามโปรแกรมเมอร์ที่มีประสบการณ์มากกว่า) และที่สำคัญกว่า C # ไม่ มีดังนั้นฉันไม่สามารถใช้งานได้

ฉันมีข้อถกเถียงว่ารหัสนี้เป็นหนึ่งในหลาย ๆ ที่ที่โปรแกรมเมอร์ที่มีประสบการณ์และมีประสบการณ์จะส่งเสียงกรี๊ดสยองขวัญ ในเวลาเดียวกันฉันไม่สามารถเห็นได้ว่าในสถานที่นี้เป็นโมฆะนี้ทำร้ายอะไรและสิ่งที่ควรทำแทน

คุณช่วยอธิบายเรื่องนี้ให้ฉันฟังได้ไหม

หลายสิ่งหลายอย่างดีกว่าที่จะกลับมาเป็นโมฆะ

• สตริงว่าง ("")
• คอลเล็กชันที่ว่างเปล่า
• "ตัวเลือก" หรือ "อาจจะ" monad
• ฟังก์ชั่นที่ไม่ทำอะไรเลยอย่างเงียบ ๆ
• วัตถุที่เต็มไปด้วยวิธีการที่ไม่ทำอะไรเลยอย่างเงียบ ๆ
• ค่าที่มีความหมายซึ่งปฏิเสธข้อสมมติฐานที่ไม่ถูกต้อง
  _{(ซึ่งเป็นสิ่งที่ทำให้คุณพิจารณาว่าว่างในตอนแรก)}

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

เมื่อคุณไม่ต้องการระเบิดและคุณไม่ต้องการตรวจสอบค่าว่างให้ใช้ตัวเลือกใดตัวเลือกหนึ่งต่อไปนี้ มันอาจดูแปลกที่จะส่งคืนคอลเลกชันถ้ามันมีองค์ประกอบ 0 หรือ 1 แต่มันก็ดีจริง ๆ ที่ให้คุณจัดการกับค่าที่หายไปอย่างเงียบ ๆ

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

สิ่งเหล่านี้ทำงานได้ดีกว่าในการทำให้ความตั้งใจของคุณชัดเจนยิ่งขึ้น นั่นคือความแตกต่างที่สำคัญที่สุด

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

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

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

ปัญหาของ null คือมันสามารถหมายถึงสิ่งต่าง ๆ มากเกินไป ดังนั้นมันจึงกลายเป็นการทำลายข้อมูล

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

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

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

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

นั่นคือวิธีการแก้ปัญหา polymorphic ระบบไม่จำเป็นต้องรู้ว่ามีการเปลี่ยนแปลงอะไร

มันดีจริงๆถ้าคุณสามารถดึงมันออกมาได้ ด้วยการเข้ารหัสการปฏิเสธสมมติฐานที่มีความหมายเป็นค่าคุณไม่จำเป็นต้องบังคับให้คำถามเปลี่ยน

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

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

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

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

วิธีนี้หากเซิร์ฟเวอร์กำลังปิดตัวลงและต้องหยุดเกมชั่วคราวก็สามารถส่งการอัปเดตที่รายงานสิ่งที่เกิดขึ้นและแสดงว่าเป็นแหล่งที่มาของการอัปเดต

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

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

nullไม่ใช่ปัญหาที่นี่จริงๆ ปัญหาคือว่าภาษาโปรแกรมส่วนใหญ่จัดการกับข้อมูลที่ขาดหายไปได้อย่างไร พวกเขาไม่ได้ใช้ปัญหานี้อย่างจริงจัง (หรืออย่างน้อยก็ไม่ให้การสนับสนุนและความปลอดภัยแก่โลกส่วนใหญ่จำเป็นต้องหลีกเลี่ยงหลุมพราง) สิ่งนี้นำไปสู่ปัญหาทั้งหมดที่เราได้เรียนรู้ที่จะกลัว (Javas NullPointerException, Segfaults, ... )

ให้ดูวิธีจัดการกับปัญหานั้นในทางที่ดีขึ้น

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

มีภาษาโปรแกรมที่ให้ความปลอดภัยต่อพอยน์เตอร์พอยน์เตอร์ (หรือที่เรียกว่า void safety) ในเวลารวบรวม เพื่อยกตัวอย่างที่ทันสมัย: Kotlin, Rust, Swift ในภาษาเหล่านั้นปัญหาของข้อมูลที่หายไปนั้นได้รับการดำเนินการอย่างจริงจังและการใช้ null จะไม่เจ็บปวดอย่างสมบูรณ์ - คอมไพเลอร์จะหยุดคุณจากการลงทะเบียน nullpointers
ใน Java มีความพยายามในการสร้างคำอธิบายประกอบ @ Nullable / @ NotNull พร้อมกับปลั๊กอินคอมไพเลอร์ + IDE เพื่อให้ได้ผลเช่นเดียวกัน มันไม่ประสบความสำเร็จจริงๆ แต่ก็ไม่อยู่ในขอบเขตสำหรับคำตอบนี้

ประเภททั่วไปที่ชัดเจนที่บ่งบอกถึงการขาดหายไปที่เป็นไปได้เป็นอีกวิธีหนึ่งในการจัดการกับมัน java.util.Optionalเช่นในชวามี มันสามารถทำงานได้:
ในโครงการหรือระดับ บริษัท คุณสามารถสร้างกฎ / แนวทาง

• ใช้เฉพาะห้องสมุดบุคคลที่สามที่มีคุณภาพสูง
• มักจะใช้java.util.Optionalแทนnull

ชุมชนภาษา / ระบบนิเวศของคุณอาจมีวิธีอื่นในการแก้ปัญหานี้ได้ดีกว่าผู้แปล / ล่าม

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

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

Null ควรหมายถึง "ไม่ได้อยู่ที่นั่น" ซึ่งยังไม่ได้สร้าง (ยัง) หรือ (แล้ว) หายไปหรือไม่ได้ให้ไว้หากมีการโต้แย้ง มันไม่ได้เป็นรัฐสิ่งทั้งหมดหายไป ในการตั้งค่า OO ที่สิ่งต่าง ๆ ถูกสร้างขึ้นและถูกทำลายตลอดเวลาซึ่งเป็นเงื่อนไขที่ถูกต้องและมีความหมายที่แตกต่างจากรัฐใด ๆ

ด้วย null คุณจะได้รับการตีที่รันไทม์ซึ่งคุณได้ถูกตีในเวลาคอมไพล์ด้วยทางเลือก null ประเภทที่ปลอดภัย

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

มีปัญหาหนึ่งที่ต้องระวัง ในบริบทแบบมัลติเธรดคุณจะต้องป้องกันสภาพการแข่งขันโดยการกำหนดให้กับตัวแปรท้องถิ่นก่อนที่จะทำการตรวจสอบสำหรับโมฆะ

ปัญหาของ null คือมันสามารถหมายถึงสิ่งต่าง ๆ มากมาย ดังนั้นมันจึงกลายเป็นการทำลายข้อมูล

ไม่มันไม่ได้ / ไม่ควรมีความหมายอะไรเลยดังนั้นจึงไม่มีอะไรจะทำลาย ชื่อและประเภทของตัวแปร / อาร์กิวเมนต์มักจะบอกสิ่งที่หายไปนั่นคือทั้งหมดที่ต้องรู้

แก้ไข:

ฉันครึ่งทางวิดีโอ candied_orange เชื่อมโยงกับหนึ่งในคำตอบอื่น ๆ ของเขาเกี่ยวกับการเขียนโปรแกรมการทำงานและเป็นที่น่าสนใจมาก ฉันเห็นประโยชน์ของมันในบางสถานการณ์ ฟังก์ชั่นการใช้งานที่ฉันได้เห็นจนถึงตอนนี้ด้วยโค้ดบางส่วนที่บินไปมาทำให้ฉันประจบประแจงเมื่อใช้ในการตั้งค่า OO แต่ฉันคิดว่ามันมีที่ ที่ไหนสักแห่ง. และฉันคิดว่าจะมีภาษาที่ทำงานได้ดีซ่อนสิ่งที่ฉันรู้สึกว่าสับสนเมื่อใดก็ตามที่ฉันพบใน C # ภาษาที่ให้รูปแบบที่สะอาดและใช้งานได้แทน

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

แนวคิดใด ๆ สามารถใช้ผิดวิธีได้ จากจุดที่ฉันยืนอยู่ "โซลูชัน" ที่นำเสนอไม่มีทางเลือกอื่นสำหรับการใช้งาน null อย่างเหมาะสม พวกเขาเป็นแนวคิดจากโลกอื่น

คำถามของคุณ.

แต่จากความไร้เดียงสาของฉันให้ฉันกรีดร้อง - บางครั้งคุณค่าอาจหายไปอย่างมีความหมาย!

ขึ้นเครื่องอย่างเต็มที่กับคุณที่นั่น อย่างไรก็ตามมีคำเตือนบางอย่างที่ฉันจะเข้าไปภายในไม่กี่วินาที แต่แรก:

Nulls นั้นชั่วร้ายและควรหลีกเลี่ยงเมื่อเป็นไปได้

ฉันคิดว่านี่เป็นคำที่เจตนาดี แต่มากเกินไป

Nulls ไม่ใช่ความชั่วร้าย พวกเขาไม่ได้เป็น antipattern พวกเขาไม่ใช่สิ่งที่ต้องหลีกเลี่ยงค่าใช้จ่ายทั้งหมด อย่างไรก็ตามค่า null มีแนวโน้มที่จะเกิดข้อผิดพลาด (จากความล้มเหลวในการตรวจสอบค่าว่าง)

แต่ฉันไม่เข้าใจว่าการตรวจสอบความล้มเหลวของ null เป็นวิธีการใดที่พิสูจน์ว่า null นั้นผิดที่จะใช้

ถ้า null เป็นความชั่วร้ายดังนั้นเป็นดัชนีอาร์เรย์และพอยน์เตอร์ C ++ พวกเขาไม่. พวกมันยิงได้ง่ายด้วยเท้า แต่ก็ไม่ควรที่จะหลีกเลี่ยงค่าใช้จ่ายทั้งหมด

สำหรับส่วนที่เหลือของคำตอบนี้ฉันจะปรับความตั้งใจของ "โมฆะคือความชั่วร้าย" กับโมฆะที่เหมาะสมยิ่งขึ้น " ควรได้รับการจัดการอย่างรับผิดชอบ "

ทางออกของคุณ

ในขณะที่ฉันเห็นด้วยกับความคิดเห็นของคุณเกี่ยวกับการใช้ null เป็นกฎสากล ฉันไม่เห็นด้วยกับการใช้ null ในกรณีนี้โดยเฉพาะ

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

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

หากการอัปเดตเหล่านี้มีความหมายแตกต่างกัน (ซึ่งเป็น) คุณจำเป็นต้องมีการอัพเดตสองแบบแยกกัน

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

สิ่งที่คุณทำอยู่ในขณะนี้คือการแยกแยะความแตกต่างระหว่างการอัปเดตสองประเภทอย่างมีประสิทธิภาพโดยยึดตามค่า null-ness ของคุณสมบัติ Player ซึ่งเทียบเท่ากับการตัดสินใจเลือกระหว่างข้อความ IM และข้อความแสดงข้อผิดพลาดตามการมีอยู่ของรหัสข้อผิดพลาด มันใช้งานได้ แต่ไม่ใช่วิธีที่ดีที่สุด

• ตอนนี้โค้ด JS จะได้รับวัตถุที่ไม่มีผู้เล่นเป็นคุณสมบัติที่กำหนดซึ่งเหมือนกับว่ามันเป็นโมฆะเนื่องจากทั้งสองกรณีจำเป็นต้องตรวจสอบว่ามีค่าหรือไม่อยู่;

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

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

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

ภาษาที่พิมพ์เช่น C # จะไม่อนุญาตให้คุณลองและเข้าถึงPlayerคุณสมบัติของ a GameUpdateเพราะGameUpdateเพียงไม่มีคุณสมบัติ Javascript มีความเข้มงวดมากขึ้นในแนวทางของมัน (และไม่จำเป็นต้องมีการคอมไพล์ล่วงหน้า) ดังนั้นจึงไม่ต้องกังวลที่จะแก้ไขคุณและทำให้มันระเบิดในรันไทม์แทน

• หากมีการเพิ่มฟิลด์ nullable อื่นลงในคลาส GameUpdate ฉันจะต้องสามารถใช้การสืบทอดหลาย ๆ อันเพื่อดำเนินการต่อด้วยดีไซน์นี้ - แต่ MI นั้นชั่วร้ายในสิทธิ์ของตนเอง (ตามโปรแกรมเมอร์ที่มีประสบการณ์มากกว่า) และที่สำคัญกว่า C # ไม่ มีดังนั้นฉันไม่สามารถใช้งานได้

คุณไม่ควรสร้างคลาสขึ้นอยู่กับการเพิ่มคุณสมบัติที่ไม่สามารถใช้ได้ คุณควรสร้างคลาสตามการปรับปรุงเกมที่มีลักษณะเฉพาะ

วิธีหลีกเลี่ยงปัญหาเกี่ยวกับ null โดยทั่วไปได้อย่างไร

ฉันคิดว่ามันเกี่ยวข้องกับการทำอย่างละเอียดเกี่ยวกับวิธีที่คุณสามารถแสดงถึงการขาดคุณค่า นี่คือชุดของการแก้ปัญหา (หรือแนวทางที่ไม่ดี) โดยไม่คำนึงถึงลำดับ

1. ใช้ค่า null อย่างไรก็ตาม

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

2. ใช้ค่าที่ไม่มีความหมายเป็นโมฆะ

ตัวอย่างง่ายๆที่นี่คือindexOf():

"abcde".indexOf("b"); // 1
"abcde".indexOf("f"); // -1

แทนที่จะคุณจะได้รับnull -1ในระดับเทคนิคนี่เป็นค่าจำนวนเต็มที่ถูกต้อง อย่างไรก็ตามค่าลบเป็นคำตอบที่ไร้สาระเนื่องจากดัชนีคาดว่าจะเป็นจำนวนเต็มบวก

เหตุผลนี้สามารถใช้ได้เฉพาะกรณีที่ประเภทส่งคืนอนุญาตให้มีค่าที่เป็นไปได้มากกว่าที่จะสามารถส่งคืนได้อย่างมีความหมาย (indexOf = จำนวนเต็มบวก; int = จำนวนเต็มบวกและลบ)

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

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

3. โยนข้อยกเว้นแทน

ไม่เพียงแค่ไม่มี. ไม่ควรมีข้อยกเว้นสำหรับการไหลแบบลอจิคัล

ที่ถูกกล่าวว่ามีบางกรณีที่คุณไม่ต้องการซ่อนข้อยกเว้น (nullreference) แต่แสดงข้อยกเว้นที่เหมาะสม ตัวอย่างเช่น:

var existingPerson = personRepository.GetById(123);

สิ่งนี้สามารถขว้างPersonNotFoundException(หรือคล้ายกัน) เมื่อไม่มีบุคคลใดที่มี ID 123

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

จุดที่เหตุใดค่านัลไม่ดีนั้นไม่ใช่ค่าที่หายไปถูกเข้ารหัสเป็นโมฆะ แต่ค่าอ้างอิงใด ๆ สามารถเป็นโมฆะ หากคุณมี C # คุณอาจจะหลงทางอยู่ดี ฉันไม่เห็นจุด ro ใช้ตัวเลือกที่นั่นเพราะประเภทการอ้างอิงเป็นทางเลือกอยู่แล้ว แต่สำหรับ Java นั้นมี @Notnull คำอธิบายประกอบซึ่งคุณดูเหมือนจะสามารถตั้งค่าที่ระดับแพ็คเกจแล้วสำหรับค่าที่พลาดได้คุณสามารถใช้คำอธิบายประกอบ @Nullable ได้

Nulls ไม่ใช่สิ่งชั่วร้ายไม่มีทางที่จะนำไปใช้ทางเลือกใด ๆ โดยไม่ต้องมีเหตุผลในการจัดการกับสิ่งที่ดูเหมือนเป็นโมฆะ

Nulls มี แต่อันตราย เช่นเดียวกับโครงสร้างระดับต่ำอื่น ๆ หากคุณเข้าใจผิดไม่มีอะไรที่จะจับคุณได้ด้านล่าง

ฉันคิดว่ามีข้อโต้แย้งที่ถูกต้องจำนวนมากต่อโมฆะ:

• หากคุณอยู่ในโดเมนระดับสูงแล้วจะมีรูปแบบที่ปลอดภัยกว่าการใช้แบบจำลองระดับต่ำ

• หากคุณไม่ต้องการข้อดีของระบบระดับต่ำและเตรียมพร้อมที่จะใช้ความระมัดระวังแล้วบางทีคุณไม่ควรใช้ภาษาระดับต่ำ

• ฯลฯ ...

สิ่งเหล่านี้ถูกต้องและไม่ต้องใช้ความพยายามในการเขียน getters และ setters เป็นต้นซึ่งเป็นเหตุผลทั่วไปที่จะไม่ทำตามคำแนะนำนั้น มันไม่น่าแปลกใจจริง ๆ ที่โปรแกรมเมอร์จำนวนมากได้ข้อสรุปว่าโมฆะมีอันตรายและขี้เกียจ (เป็นการรวมกันที่แย่!) แต่ก็เหมือนกับคำแนะนำ "สากล" อื่น ๆ อีกมากมายที่พวกเขาไม่ได้เป็นสากลตามที่พูด

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

Java มีOptionalคลาสพร้อมifPresent+ แลมบ์ดาที่ชัดเจนในการเข้าถึงค่าใด ๆ ได้อย่างปลอดภัย สิ่งนี้สามารถทำได้ใน JS ด้วย:

ดูคำถาม StackOverflowนี้

โดยวิธีการ: หลายคนที่พิถีพิถันจะพบการใช้งานนี้น่าสงสัย แต่ฉันไม่คิดอย่างนั้น มีคุณสมบัติเสริมให้เลือก

CAR Hoare เรียกว่า nulls "ความผิดพลาดพันล้านดอลลาร์" ของเขา อย่างไรก็ตามสิ่งสำคัญคือให้สังเกตว่าเขาคิดว่าวิธีแก้ปัญหาไม่ใช่ "ไม่มีโมฆะที่ใดก็ได้" แต่แทนที่จะเป็น "พอยน์เตอร์ที่ไม่ใช่โมฆะเป็นค่าเริ่มต้นและโมฆะเฉพาะที่จำเป็นต้องใช้ความหมาย"

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

หากต้องการแฮ็กข้อมูลที่ขาดพื้นฐานเกี่ยวกับการแสดงออกบางชุมชน (เช่นชุมชนสกาล่า) ไม่ใช้ค่าว่าง ในกาลาถ้าคุณต้องการค่า nullable ประเภทTที่คุณจะใช้ข้อโต้แย้งของพิมพ์Option[T]และถ้าคุณต้องการค่าที่ไม่ใช่ nullable Tคุณเพียงแค่ใช้เวลา หากมีคนส่ง null เป็นรหัสของคุณรหัสของคุณจะระเบิด อย่างไรก็ตามก็ถือว่ารหัสการโทรเป็นรหัส buggy Optionคือการเปลี่ยนที่ดีงามสำหรับ null แต่เนื่องจากรูปแบบ null จัดการทั่วไปจะถูกดึงเข้าสู่การทำงานห้องสมุดเหมือนหรือ.map(f).getOrElse(someDefault)