หากโมฆะไม่ดีทำไมภาษาสมัยใหม่ถึงนำมาใช้? [ปิด]

ฉันแน่ใจว่าผู้ออกแบบภาษาเช่น Java หรือ C # รู้ปัญหาที่เกี่ยวข้องกับการมีอยู่ของการอ้างอิงที่เป็นโมฆะ (ดูที่การอ้างอิงโมฆะเป็นเรื่องเลวร้ายจริง ๆ หรือไม่ ) การใช้ประเภทตัวเลือกนั้นไม่ซับซ้อนกว่าการอ้างอิงแบบ null

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

มันเป็นเพียงเพราะการอนุรักษ์ - "ภาษาอื่นมีเราต้องได้เช่นกัน ... "?

ข้อจำกัดความรับผิดชอบ: เนื่องจากฉันไม่รู้จักนักออกแบบภาษาใด ๆ เป็นการส่วนตัวคำตอบใด ๆ ที่ฉันให้คุณจะเป็นการเก็งกำไร

จากTony Hoareตัวเอง:

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

เน้นการขุด

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

"เราอยู่หลังโปรแกรมเมอร์ C ++ เราสามารถลากพวกเขาจำนวนมากประมาณครึ่งทางไปที่ Lisp" -Guy Steele ผู้เขียนร่วมของข้อกำหนด Java

(ที่มา: http://www.paulgraham.com/icad.html )

และแน่นอน C ++ มีค่าว่างเนื่องจาก C มีค่าเป็นศูนย์และไม่จำเป็นต้องมีผลกระทบทางประวัติศาสตร์ของ C ภาษา C ++ เป็นภาษา J ++ ซึ่งเป็นการนำ Java มาใช้ของ Microsoft และ C ++ นั้นเป็นภาษาที่ถูกเลือกสำหรับการพัฒนา Windows ดังนั้นมันจึงได้มาจากภาษาใดภาษาหนึ่ง

แก้ไขนี่คือข้อความที่ยกมาจาก Hoare ที่ควรพิจารณา:

ภาษาการเขียนโปรแกรมโดยรวมมีความซับซ้อนมากกว่าที่เคยเป็นมา: การวางแนวของวัตถุการสืบทอดและคุณสมบัติอื่น ๆ ยังไม่ได้รับการพิจารณาอย่างแท้จริงจากมุมมองของวินัยที่สอดคล้องกันและทางวิทยาศาสตร์หรือทฤษฎีความถูกต้อง . สัจพจน์ดั้งเดิมของฉันซึ่งฉันได้ใฝ่หาเป็นนักวิทยาศาสตร์มาตลอดชีวิตของฉันคือว่าหนึ่งใช้เกณฑ์ของความถูกต้องเป็นวิธีการบรรจบในการออกแบบภาษาการเขียนโปรแกรมที่ดี - หนึ่งที่ไม่ได้วางกับดักสำหรับผู้ใช้และใน ซึ่งองค์ประกอบที่แตกต่างกันของโปรแกรมสอดคล้องอย่างชัดเจนกับองค์ประกอบที่แตกต่างกันของข้อกำหนดเพื่อให้คุณสามารถให้เหตุผลเกี่ยวกับองค์ประกอบ [... ] เครื่องมือรวมถึงคอมไพเลอร์จะต้องอยู่บนพื้นฐานของทฤษฎีว่ามันหมายถึงอะไรในการเขียนโปรแกรมที่ถูกต้อง - บทสัมภาษณ์ประวัติศาสตร์โดย Philip L. Frana วันที่ 17 กรกฎาคม 2545 เมืองเคมบริดจ์ประเทศอังกฤษ Charles Babbage Institute, มหาวิทยาลัยมินนิโซตา [ http://www.cbi.umn.edu/oh/display.phtml?id=343]

ขอย้ำอีกครั้ง Sun / Oracle และ Microsoft เป็น บริษัท และกำไรของ บริษัท ใด ๆ ก็คือเงิน ประโยชน์ที่พวกเขามีnullอาจมีมากกว่าข้อเสียหรือพวกเขาอาจมีกำหนดเวลาแน่นเกินไปที่จะพิจารณาปัญหาอย่างเต็มที่ เป็นตัวอย่างของความผิดพลาดทางภาษาอื่นที่อาจเกิดขึ้นเนื่องจากกำหนดเวลา:

มันเป็นความอัปยศที่ Cloneable เสีย แต่เกิดขึ้น Java API ดั้งเดิมนั้นทำเสร็จเร็วมากภายใต้กำหนดเวลาที่ จำกัด เพื่อพบกับหน้าต่างตลาดปิด ทีม Java ดั้งเดิมทำงานได้ดีมาก แต่ API ทั้งหมดนั้นไม่ได้สมบูรณ์แบบ การโคลนนิ่งเป็นจุดอ่อนและฉันคิดว่าผู้คนควรตระหนักถึงข้อ จำกัด ของมัน -Josh Bloch

(ที่มา: http://www.artima.com/intv/bloch13.html )

ฉันแน่ใจว่าผู้ออกแบบภาษาเช่น Java หรือ C # รู้ปัญหาที่เกี่ยวข้องกับการมีอยู่ของการอ้างอิงที่เป็นโมฆะ

แน่นอน.

การใช้ประเภทตัวเลือกนั้นไม่ซับซ้อนกว่าการอ้างอิงแบบ null

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

เหตุใดพวกเขาจึงตัดสินใจรวมไว้ด้วย

การออกแบบทั้งหมดเป็นกระบวนการของการเลือกเป้าหมายที่เข้ากันไม่ได้อย่างละเอียดและไม่เข้าท่า ฉันสามารถให้ภาพร่างสั้น ๆ ของปัจจัยเพียงไม่กี่ข้อที่จะพิจารณา:

• ความโดดเด่นของคุณสมบัติภาษานั้นโดยทั่วไปถือว่าเป็นสิ่งที่ดี C # มีประเภทค่าที่เป็นโมฆะประเภทค่าที่ไม่เป็นโมฆะและประเภทการอ้างอิงที่ไม่มีค่า ประเภทการอ้างอิงที่ไม่เป็นโมฆะไม่มีอยู่ซึ่งทำให้ระบบประเภทไม่เป็นแบบมุมฉาก

• ความคุ้นเคยกับผู้ใช้ปัจจุบันของ C, C ++ และ Java เป็นสิ่งสำคัญ

• การทำงานร่วมกันได้ง่ายกับ COM เป็นสิ่งสำคัญ

• การทำงานร่วมกันได้ง่ายกับภาษา. NET อื่น ๆ ทั้งหมดเป็นสิ่งสำคัญ

• การทำงานร่วมกันอย่างง่ายดายกับฐานข้อมูลเป็นสิ่งสำคัญ

• ความสอดคล้องของความหมายเป็นสิ่งสำคัญ ถ้าเรามีการอ้างอิง TheKingOfFrance เท่ากับ null นั่นแปลว่า "ตอนนี้ไม่มีกษัตริย์ของฝรั่งเศส" หรือมันอาจหมายถึง "มีราชาแห่งฝรั่งเศสแน่นอนฉันไม่รู้ว่าใครเป็นใครในตอนนี้"? หรืออาจหมายถึง "ความคิดที่ว่าการมีกษัตริย์ในฝรั่งเศสนั้นไร้สาระดังนั้นอย่าถามด้วยซ้ำ!"? Null อาจหมายถึงสิ่งเหล่านี้ทั้งหมดและอื่น ๆ ใน C # และแนวคิดเหล่านี้ทั้งหมดมีประโยชน์

• ต้นทุนประสิทธิภาพเป็นสิ่งสำคัญ

• การคล้อยตามการวิเคราะห์เชิงสถิตเป็นสิ่งสำคัญ

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

• และความหมายที่สอดคล้องกันของความหมายคืออะไร? Null ค่าเผยแพร่เมื่อใช้ แต่ null อ้างอิงโยนข้อยกเว้นเมื่อนำมาใช้ มันไม่สอดคล้องกัน ความไม่สอดคล้องนั้นมีความชอบธรรมโดยผลประโยชน์

• เราสามารถใช้คุณสมบัติโดยไม่ทำลายคุณสมบัติอื่น ๆ ได้หรือไม่? คุณลักษณะอื่น ๆ ที่เป็นไปได้ในอนาคตมีคุณสมบัติที่ห้ามหรือไม่

• คุณไปทำสงครามกับกองทัพที่คุณมีไม่ใช่คนที่คุณต้องการ โปรดจำไว้ว่า C # 1.0 ไม่ได้มีชื่อสามัญดังนั้นการพูดถึงMaybe<T>ทางเลือกจึงไม่ใช่ตัวเริ่มต้นที่สมบูรณ์ . NET ควรลดลงเป็นเวลาสองปีในขณะที่ทีมรันไทม์เพิ่มชื่อทั่วไปเพื่อกำจัดการอ้างอิงที่เป็นโมฆะ?

• สิ่งที่เกี่ยวกับความสอดคล้องของระบบประเภท? คุณสามารถพูดNullable<T>สำหรับประเภทค่าใด ๆ - ไม่รอนั่นเป็นเรื่องโกหก คุณไม่สามารถพูดNullable<Nullable<T>>ได้ คุณควรจะทำอย่างไร ถ้ามีความหมายที่ต้องการคืออะไร? มันคุ้มค่าไหมที่ทำให้ระบบทั้งระบบมีตัวพิมพ์พิเศษสำหรับคุณสมบัตินี้?

และอื่น ๆ การตัดสินใจเหล่านี้มีความซับซ้อน

Null ให้บริการวัตถุประสงค์ที่ถูกต้องมากในการแสดงถึงการขาดคุณค่า

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

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

ตัวอย่างการพิสูจน์โมฆะ:

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

Date of Death เป็นฟิลด์ DateTime และไม่มีค่า "ไม่ทราบ" หรือ "ว่าง" มันมีวันที่เริ่มต้นที่เกิดขึ้นเมื่อคุณสร้างวันที่และเวลาใหม่ซึ่งแตกต่างกันไปตามภาษาที่ใช้ แต่มีโอกาสทางเทคนิคที่บุคคลนั้นในความเป็นจริงตายในเวลานั้นและจะตั้งค่าสถานะเป็น "ค่าว่าง" ถ้าคุณ ใช้วันที่เริ่มต้น

ข้อมูลจะต้องแสดงถึงสถานการณ์อย่างถูกต้อง

บุคคลคือวันที่ตายซึ่งเป็นที่รู้จัก (3/9/1984)

ง่าย '3/9/1984'

บุคคลคือวันที่ตายซึ่งไม่ทราบ

ดังนั้นสิ่งที่ดีที่สุด เป็นศูนย์ '0/0/0000' หรือ '01 / 01/1869 '(หรือค่าเริ่มต้นของคุณคืออะไร)

คนไม่ตายวันตายไม่เกี่ยวข้อง

ดังนั้นสิ่งที่ดีที่สุด เป็นศูนย์ '0/0/0000' หรือ '01 / 01/1869 '(หรือค่าเริ่มต้นของคุณคืออะไร)

งั้นลองคิดค่าแต่ละอย่างกัน ...

• เป็นโมฆะมันมีผลกระทบและความกังวลที่คุณต้องระวังโดยไม่ได้ตั้งใจพยายามที่จะจัดการมันโดยไม่ยืนยันว่ามันไม่ว่างก่อนเช่นจะโยนข้อยกเว้น แต่มันก็ยังแสดงถึงสถานการณ์ที่ดีที่สุด ... ถ้าคนไม่ตาย ไม่มีวันที่แห่งความตาย ... มันไม่มีอะไร ... มันเป็นโมฆะ ...
• 0/0/0000ซึ่งอาจใช้ได้ในบางภาษาและอาจเป็นการแสดงถึงวันที่ที่ไม่เหมาะสม น่าเสียดายที่บางภาษาและการตรวจสอบความถูกต้องจะปฏิเสธว่านี่เป็นช่วงเวลาที่ไม่ถูกต้องซึ่งทำให้ไม่สามารถใช้งานได้ในหลายกรณี
• 1/1/1869 (หรือค่าเริ่มต้นของคุณคืออะไร)ปัญหาที่นี่คือมันยากที่จะจัดการ คุณสามารถใช้สิ่งนั้นเป็นค่าขาดของคุณยกเว้นว่าจะเกิดอะไรขึ้นถ้าฉันต้องการกรองบันทึกทั้งหมดของฉันฉันไม่มีวันตาย ฉันสามารถกรองผู้ที่เสียชีวิตในวันนั้นซึ่งอาจทำให้เกิดปัญหาเรื่องความถูกต้องของข้อมูลได้อย่างง่ายดาย

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

หากฉันไม่มีแอปเปิ้ลฉันมี 0 แอปเปิ้ล แต่ถ้าฉันไม่รู้แอปเปิ้ลที่ฉันมี

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

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

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

แต่ (โดยเฉพาะอย่างยิ่งสำหรับ Java และ C # เนื่องจากเวลาของการแนะนำและกลุ่มเป้าหมายของพวกเขา) โดยใช้ประเภทตัวเลือกสำหรับชั้นการทำงานร่วมกันนี้อาจได้รับอันตรายหากไม่ได้ฉลองชัยการนำไปใช้ ไม่ว่าชนิดของตัวเลือกจะถูกส่งไปจนหมดทำให้เกิดความรำคาญกับโปรแกรมเมอร์ C ++ ในช่วงกลางถึงปลายยุค 90 หรือเลเยอร์การทำงานร่วมกันอาจทำให้เกิดข้อยกเว้นเมื่อพบโมฆะ ..

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

ช่วยให้nullการอ้างอิง (และตัวชี้) เป็นเพียงหนึ่งในการดำเนินการตามแนวคิดนี้และอาจจะเป็นที่นิยมมากที่สุดแม้ว่ามันจะรู้ว่าจะมีปัญหา: C, Java, Python, Ruby, PHP, JavaScript, ... nullทั้งหมดใช้ที่คล้ายกัน

ทำไม ทางเลือกคืออะไร

ในภาษาที่ใช้งานได้เช่น Haskell คุณมีOptionหรือMaybeพิมพ์; อย่างไรก็ตามสิ่งเหล่านี้ถูกสร้างขึ้นเมื่อ:

• ประเภทพารามิเตอร์
• ชนิดข้อมูลเชิงพีชคณิต

ตอนนี้ต้นฉบับ C, Java, Python, Ruby หรือ PHP รองรับฟีเจอร์เหล่านั้นหรือไม่? ไม่ข้อมูลทั่วไปของข้อบกพร่องของจาวาเป็นเรื่องล่าสุดในประวัติศาสตร์ของภาษาและฉันก็สงสัยว่าคนอื่น ๆ จะนำไปใช้จริง

ที่นั่นคุณมีมัน nullง่ายประเภทข้อมูลพีชคณิตเกี่ยวกับตัวแปรนั้นยากกว่า ผู้คนไปเพื่อทางเลือกที่ง่ายที่สุด

Null / nil / none ไม่มีความชั่วร้าย

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

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

ดังนั้นคำถามคือทำไมภาษาไม่สามารถใช้ตัวเลือก? ตามความเป็นจริงภาษาที่นิยมที่สุดในเนื้อหาตลอดเวลา C ++ มีความสามารถในการกำหนดตัวแปรวัตถุที่ไม่สามารถกำหนดNULLได้ นี่เป็นวิธีแก้ปัญหา "ปัญหาว่างเปล่า" ที่โทนี่โฮอาร์พูดถึงในคำพูดของเขา ทำไมภาษาที่ได้รับความนิยมสูงสุดอันดับถัดไปคือ Java ไม่มี หนึ่งอาจถามว่าทำไมมันมีข้อบกพร่องมากมายโดยเฉพาะอย่างยิ่งในระบบชนิดของมัน ฉันไม่คิดว่าคุณพูดได้จริงๆว่าภาษาทำผิดอย่างเป็นระบบ บางคนทำบางคนทำไม่ได้

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

ตัวอย่างเช่นถ้าฉันต้องการเขียนสคริปต์อย่างง่ายที่ทำงานกับไฟล์ฉันสามารถเขียนรหัสเทียมเช่น:

file = openfile("joebloggs.txt")

for line in file
{
  print(line)
}

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

มีการใช้ตัวชี้NULL(หรือnilหรือNilหรือnullหรือNothingหรือสิ่งที่เรียกว่าเป็นภาษาที่คุณต้องการ) อย่างชัดเจนและเป็นประโยชน์

สำหรับภาษาที่ไม่มีระบบการยกเว้น (เช่น C) ตัวชี้โมฆะสามารถใช้เป็นเครื่องหมายข้อผิดพลาดเมื่อควรส่งคืนพอยน์เตอร์ ตัวอย่างเช่น:

char *buf = malloc(20);
if (!buf)
{
    perror("memory allocation failed");
    exit(1);
}

ที่นี่NULLส่งคืนจากmalloc(3)ใช้เป็นเครื่องหมายของความล้มเหลว

เมื่อใช้ในการโต้แย้งวิธี / ฟังก์ชั่นก็สามารถระบุการใช้เริ่มต้นสำหรับการโต้แย้งหรือละเว้นอาร์กิวเมนต์เอาท์พุท ตัวอย่างด้านล่าง

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

NSError *err = nil;
NSString *content = [NSString stringWithContentsOfURL:sourceFile
                                         usedEncoding:NULL // This output is ignored
                                                error:&err];
if (!content) // If the object is null, we have a soft error to recover from
{
    fprintf(stderr, "error: %s\n", [[err localizedDescription] UTF8String]);
    if (!error) // Check if the parent method ignored the error argument
        *error = err;
    return nil; // Go back to parent layer, with another soft error.
}

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

มีสองประเด็นที่เกี่ยวข้อง แต่แตกต่างกันเล็กน้อย:

1. ควรnullมีอยู่ทั้งหมดหรือไม่ หรือคุณควรใช้ในMaybe<T>กรณีที่ null มีประโยชน์เสมอ

2. ควรอ้างอิงทั้งหมดเป็นโมฆะ? ถ้าไม่ควรจะเป็นค่าเริ่มต้น?

   การประกาศประเภทอ้างอิงที่ไม่สามารถระบุได้อย่างชัดเจนว่าเป็นสาเหตุที่ทำให้เกิดstring?ปัญหาส่วนใหญ่ (แต่ไม่ทั้งหมด) ของปัญหาnullโดยไม่แตกต่างจากโปรแกรมเมอร์ที่ใช้

อย่างน้อยฉันก็เห็นด้วยกับคุณที่ไม่อ้างอิงทั้งหมดควรเป็นโมฆะ แต่การหลีกเลี่ยงค่า null นั้นไม่ได้เกิดจากความซับซ้อน:

.NET เตรียมข้อมูลdefault<T>เบื้องต้นให้กับทุกฟิลด์ก่อนที่จะสามารถเข้าถึงได้โดยใช้รหัสที่ได้รับการจัดการ ซึ่งหมายความว่าสำหรับประเภทการอ้างอิงที่คุณต้องการnullหรือสิ่งที่เทียบเท่าและประเภทค่านั้นสามารถเริ่มต้นเป็นศูนย์ได้โดยไม่ต้องใช้รหัส ในขณะที่ทั้งสองอย่างนี้มีข้อเสียอย่างรุนแรงความเรียบง่ายของการdefaultเริ่มต้นอาจมีมากกว่าข้อเสียเหล่านั้น

• สำหรับเขตข้อมูลอินสแตนซ์คุณสามารถหลีกเลี่ยงปัญหานี้ได้โดยกำหนดให้เริ่มต้นเขตข้อมูลก่อนที่จะแสดงthisตัวชี้ไปยังรหัสที่ได้รับการจัดการ Spec # ไปตามเส้นทางนี้โดยใช้ไวยากรณ์ที่แตกต่างจากการกำหนดสายสัมพันธ์เทียบกับ C #

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

• วิธีการเริ่มต้นอาร์เรย์ของประเภทอ้างอิง? พิจารณาหนึ่งList<T>ซึ่งได้รับการสนับสนุนโดยอาร์เรย์ที่มีความจุมากกว่าความยาว องค์ประกอบที่เหลือต้องมีค่าบางอย่าง

ปัญหาอีกประการหนึ่งคือมันไม่อนุญาตให้วิธีการbool TryGetValue<T>(key, out T value)ที่กลับมาdefault(T)ราวกับvalueว่าพวกเขาไม่พบอะไรเลย แม้ว่าในกรณีนี้มันง่ายที่จะยืนยันว่าพารามิเตอร์ out เป็นการออกแบบที่ไม่ดีในตอนแรกและวิธีนี้ควรคืนค่าการแยกแยะสหภาพหรืออาจจะแทน

ปัญหาทั้งหมดเหล่านี้สามารถแก้ไขได้ แต่มันก็ไม่ง่ายเหมือน "การห้ามให้เป็นโมฆะและทั้งหมดเป็นอย่างดี"

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

ภาษาและระบบที่ต่างกันใช้แนวทางที่แตกต่างกัน

• วิธีหนึ่งที่จะกล่าวได้ว่าการพยายามอ่านสิ่งที่ไม่ได้เขียนจะก่อให้เกิดข้อผิดพลาดทันที

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

• วิธีที่สามคือการเพิกเฉยต่อปัญหาและปล่อยให้สิ่งที่จะเกิดขึ้น "ตามธรรมชาติ" ก็เกิดขึ้น

• วิธีที่สี่คือการบอกว่าทุกประเภทจะต้องมีค่าเริ่มต้นและช่องใด ๆ ที่ไม่ได้เขียนด้วยอะไรจะเริ่มต้นกับค่านั้น

วิธีการ # 4 มีความปลอดภัยกว่าวิธีที่ # 3 อย่างมากและโดยทั่วไปราคาถูกกว่าวิธีที่ # 1 และ # 2 จากนั้นจึงทิ้งคำถามว่าค่าเริ่มต้นควรเป็นประเภทการอ้างอิงใด สำหรับประเภทการอ้างอิงที่ไม่เปลี่ยนรูปแบบในหลายกรณีมันจะสมเหตุสมผลที่จะกำหนดอินสแตนซ์เริ่มต้นและบอกว่าค่าเริ่มต้นสำหรับตัวแปรใด ๆ ของประเภทนั้นควรเป็นการอ้างอิงไปยังอินสแตนซ์นั้น อย่างไรก็ตามสำหรับประเภทการอ้างอิงที่ไม่แน่นอนนั้นจะไม่เป็นประโยชน์ หากมีความพยายามในการใช้ประเภทการอ้างอิงที่ไม่แน่นอนก่อนที่จะถูกเขียนขึ้นโดยทั่วไปจะไม่มีวิธีการที่ปลอดภัยใด ๆ ยกเว้นกับดัก ณ จุดที่พยายามใช้งาน

การพูดเชิงความหมายถ้ามีหลายcustomersประเภทCustomer[20]และหนึ่งความพยายามCustomer[4].GiveMoney(23)โดยไม่เก็บอะไรไว้Customer[4]การดำเนินการจะต้องดัก เราอาจโต้เถียงว่าความพยายามในการอ่านCustomer[4]ควรดักทันทีแทนที่จะรอจนกว่าจะพยายามใช้รหัสGiveMoneyแต่มีหลายกรณีที่มีประโยชน์ในการอ่านสล็อตพบว่ามันไม่ได้มีคุณค่าและใช้ประโยชน์จากสิ่งนั้น ข้อมูลที่มีความพยายามในการอ่านตัวเองล้มเหลวมักจะเป็นปัญหาใหญ่

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