ฟิลด์บูลีนใหม่ดีกว่าการอ้างอิงค่า Null หรือไม่หากค่าสามารถขาดหายไปอย่างมีความหมายได้

ตัวอย่างเช่นสมมติว่าฉันมีคลาสMemberซึ่งมี lastChangePasswordTime:

class Member{
  .
  .
  .
  constructor(){
    this.lastChangePasswordTime=null,
  }
}

ซึ่ง lastChangePasswordTime อาจไม่มีความหมายเนื่องจากสมาชิกบางคนอาจไม่เปลี่ยนรหัสผ่าน

แต่ถ้าหาก nulls เป็นสิ่งชั่วร้ายสิ่งที่ควรใช้เมื่อค่าสามารถขาดความหมายได้อย่างไร และhttps://softwareengineering.stackexchange.com/a/12836/248528ฉันไม่ควรใช้ null เพื่อแสดงค่าขาดหายไปอย่างมีความหมาย ดังนั้นฉันพยายามเพิ่มธงบูลีน:

class Member{
  .
  .
  .
  constructor(){
    this.isPasswordChanged=false,
    this.lastChangePasswordTime=null,
  }
}

แต่ฉันคิดว่ามันค่อนข้างล้าสมัยเพราะ:

1. เมื่อ isPasswordChanged เป็นเท็จ lastChangePasswordTime จะต้องเป็นโมฆะและการตรวจสอบ lastChangePasswordTime == null เกือบจะเหมือนกันกับการตรวจสอบ isPasswordChanged เป็นเท็จดังนั้นฉันชอบเช็ค lastChangePasswordTime == null โดยตรง

2. เมื่อเปลี่ยนลอจิกที่นี่ฉันอาจลืมอัปเดตทั้งสองฟิลด์

หมายเหตุ: เมื่อผู้ใช้เปลี่ยนรหัสผ่านฉันจะบันทึกเวลาเช่นนี้:

this.lastChangePasswordTime=Date.now();

ฟิลด์บูลีนเพิ่มเติมดีกว่าการอ้างอิงโมฆะที่นี่หรือไม่

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

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

class Member {
    DateTime lastChangePasswordTime = null;
    bool isPasswordChanged() { return lastChangePasswordTime != null; }

}

ในความคิดของฉันทำแบบนี้:

• ให้โค้ดที่อ่านง่ายกว่าการตรวจสอบค่า null ซึ่งอาจทำให้บริบทเสียไป
• ขจัดความต้องการที่คุณจะต้องกังวลเกี่ยวกับการรักษาisPasswordChangedคุณค่าที่คุณพูดถึง

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

nullsไม่ใช่ความชั่วร้าย ใช้พวกเขาโดยไม่ต้องคิดคือ นี่เป็นกรณีที่nullตรงกับคำตอบที่ถูกต้อง - ไม่มีวันที่

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

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

ขึ้นอยู่กับภาษาการเขียนโปรแกรมของคุณอาจมีทางเลือกที่ดีเช่นoptionalชนิดข้อมูล ใน C ++ (17) นี้จะเป็นมาตรฐาน :: ตัวเลือก มันอาจจะขาดหรือมีค่าโดยพลการของชนิดข้อมูลพื้นฐาน

ใช้ null ให้ถูกต้อง

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

ในสถานการณ์เหล่านี้คุณส่วนใหญ่ใช้มันในลักษณะนี้ (ในรหัสหลอก):

if (value is null) {
  doSomethingAboutIt();
  return;
}

doSomethingUseful(value);

ปัญหา

และมันก็มีปัญหาใหญ่มาก ปัญหาคือตามเวลาที่คุณเรียกใช้doSomethingUsefulค่าอาจไม่ได้รับการตรวจสอบnull! หากไม่เป็นเช่นนั้นโปรแกรมจะเกิดข้อผิดพลาด และผู้ใช้อาจไม่เห็นข้อความแสดงข้อผิดพลาดใด ๆ ที่ถูกทิ้งไว้กับบางสิ่งเช่น "ข้อผิดพลาดที่น่ากลัว: ค่าที่ต้องการ แต่ได้รับค่าว่าง!" (หลังจากอัปเดต: แม้ว่าอาจมีข้อผิดพลาดที่ให้ข้อมูลน้อยลงเช่นSegmentation fault. Core dumped.หรือแย่กว่านั้นก็ไม่มีข้อผิดพลาดและการจัดการที่ไม่ถูกต้องในค่า null ในบางกรณี)

การลืมตรวจสอบการเขียนnullและการจัดการnullสถานการณ์เป็นปัญหาที่พบบ่อยมาก นี่คือเหตุผลที่ Tony Hoare ผู้คิดค้นnullกล่าวในการประชุมซอฟต์แวร์ชื่อ QCon London ในปี 2009 ว่าเขาทำผิดพลาดนับพันล้านดอลลาร์ในปี 1965: https://www.infoq.com/presentations/Null-References-The-Billion-Dollar- ผิดพลาดโทนี่โฮร์

หลีกเลี่ยงปัญหา

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

ตัวอย่างเช่น Haskell มีMaybemonad แทนที่จะเป็น nulls สมมติว่าDatabaseRecordเป็นประเภทที่ผู้ใช้กำหนด ใน Haskell ค่าชนิดMaybe DatabaseRecordสามารถจะเท่ากับหรือมันอาจจะเท่ากับJust <somevalue> Nothingจากนั้นคุณสามารถใช้งานได้หลายวิธี แต่ไม่ว่าคุณจะใช้งานอย่างไรคุณไม่สามารถใช้การดำเนินการบางอย่างNothingโดยที่ไม่รู้ตัว

เช่นฟังก์ชันนี้เรียกว่าzeroAsDefaultreturn xfor Just xและ0for Nothing:

zeroAsDefault :: Maybe Int -> Int
zeroAsDefault mx = case mx of
    Nothing -> 0
    Just x -> x

Christian Hackl กล่าวว่า C ++ 17 และ Scala มีวิธีการของตนเอง ดังนั้นคุณอาจต้องการลองดูว่าภาษาของคุณมีอะไรแบบนั้นและใช้มันไหม

Nulls ยังคงใช้งานได้อย่างกว้างขวาง

หากคุณไม่มีอะไรที่ดีกว่าการใช้nullก็ดี เพียงแค่คอยระวัง พิมพ์ประกาศในฟังก์ชั่นจะช่วยให้คุณค่อนข้างอยู่แล้ว

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

ตามข้อเสนอของคุณ

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

วิธีที่จะไม่ใช้ null

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

จากจุดยืนพีชคณิตสตริงว่างสำหรับสตริงนั้นมีค่าเท่ากับ 0 สำหรับตัวเลขนั่นคือเอกลักษณ์:

a+0=a
concat(str, '')=str

สตริงว่างเปล่าทำให้สตริงโดยทั่วไปกลายเป็น monoid: https://en.wikipedia.org/wiki/Monoid ถ้าคุณไม่เข้าใจมันไม่ใช่เรื่องสำคัญสำหรับคุณ

ตอนนี้เรามาดูกันว่าเหตุใดการเขียนโปรแกรมด้วยตัวอย่างนี้จึงมีความสำคัญ:

for (element in array) {
  doSomething(element);
}

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

วิธีจัดการ null

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

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

ถามตัวคุณเองว่าพฤติกรรมแบบใดที่ต้องใช้ฟิลด์เป็นครั้งสุดท้ายเปลี่ยนรหัสผ่านเวลา

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

class Member{
   private DateTime lastChangePasswordTime;

   public Member(DateTime lastChangePasswordTime) {
      // set value, maybe check for null
   }

   public bool IsPasswordExpired() {
      DateTime limit = DateTime.Now.AddMonths(-3);
      return lastChangePasswordTime < limit;
   }
}

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

class Member{
   private DateTime lastChangePasswordTime;
   private bool passwordShouldBeChanged;

   public Member(DateTime lastChangePasswordTime, bool passwordShouldBeChanged) {
      // set values, maybe check for nulls
   }

   public bool ShouldChangePassword() {
      return PasswordExpired(lastChangePasswordTime) || passwordShouldBeChanged;
   }

   private static bool PasswordExpired(DateTime lastChangePasswordTime) {
      DateTime limit = DateTime.Now.AddMonths(-3);
      return lastChangePasswordTime < limit;
   }
}

ทำให้ความตั้งใจของคุณชัดเจนในรหัส

ข้อแรกข้อเสียของความชั่วคือความเชื่อและตามปกติกับความเชื่อมันใช้งานได้ดีที่สุดในฐานะเป็นแนวทางและไม่ผ่านการทดสอบผ่าน / ไม่ผ่าน

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

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

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

ไม่มีคำตอบที่ถูกต้องเดียว ขึ้นอยู่กับสิ่งที่คุณกังวล

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

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