คุณควรยืนยันว่าไม่ได้เป็นโมฆะกับคำสั่งยืนยันในรหัสการผลิต? [ปิด]

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

ตัวอย่าง:

class CustomObject {
    private Object object;

    @Nullable
    public Object getObject() {
        return (object == null) ? generateObject() : object;
    }
}

ตอนนี้คิดว่าฉันใช้มันเช่นนี้:

public void useObject(CustomObject customObject) {
    object = customObject.getObject();
    assert object != null;
    // Do stuff using object, which would throw a NPE if object is null.
}

ฉันบอกว่าฉันควรลบassert, ว่าพวกเขาไม่ควรใช้ในรหัสการผลิต, ใช้ในการทดสอบเท่านั้น มันเป็นเรื่องจริงเหรอ?

ใช้Objects.requireNonNull(Object)สำหรับการที่

ตรวจสอบว่าการอ้างอิงวัตถุที่ระบุไม่ใช่โมฆะ วิธีนี้ถูกออกแบบมาเพื่อทำการตรวจสอบความถูกต้องของพารามิเตอร์ในวิธีการและตัวสร้าง [... ]

ในกรณีของคุณสิ่งนี้จะเป็น:

public void useObject(CustomObject customObject) {
    object = customObject.getObject();
    Objects.requireNonNull(object);
    // Do stuff using object, which would throw a NPE if object is null.
}

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

ประโยชน์ก็คือความยืดหยุ่นเพิ่มเติมเกี่ยวกับการตรวจสอบ null assertในทางตรงกันข้ามกับ ในขณะที่assertเป็นคำหลักสำหรับการตรวจสอบค่าบูลีนObjects.requireNonNull(Object)เป็นฟังก์ชั่นและทำให้สามารถฝังตัวในรหัสมีความยืดหยุ่นมากขึ้นและสามารถอ่านได้ เช่น:

Foo foo = Objects.requireNonNull(service.fetchFoo());

// You cannot write it in on line.
Bar bar = service.fetchBar();
assert bar != null;

service.foo(Objects.requireNonNull(service.getBar()));

// You cannot write it in on line.
Bar bar = service.getBar();
assert bar != null;
service.foo(bar);

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

ตรวจสอบอย่างเป็นทางการเอกสารassertรายละเอียดเกี่ยวกับ

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

สำหรับความเข้ากันได้แบบย้อนหลัง JVM จะปิดใช้งานการตรวจสอบยืนยันตามค่าเริ่มต้น พวกเขาจะต้องเปิดใช้งานอย่างชัดเจนโดยใช้อาร์กิวเมนต์บรรทัดคำสั่ง -enableassertions หรือ shorthand -ea ของมัน:

java -ea com.whatever.assertion.Assertion

ดังนั้นจึงไม่ใช่วิธีที่ดีที่จะพึ่งพาพวกเขา

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

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

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

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

สำหรับตัวอย่างที่น่าสนใจเกี่ยวกับวิธีการใช้ asserts ให้ดูที่นี่ - ท้ายไฟล์มีวิธีการsingleThreadedAccess()ที่เรียกจากคำสั่ง assert ในบรรทัด 201 และมีการเข้าถึงแบบมัลติเธรดที่มีศักยภาพในการทดสอบ

คำตอบอื่น ๆ ครอบคลุมเรื่องนี้ดีพอ แต่มีตัวเลือกอื่น ๆ

ตัวอย่างเช่น Spring มีวิธีการคงที่:

org.springframework.util.Assert.notNull(obj)

มีห้องสมุดอื่น ๆ ที่มีAssert.something()วิธีการของตัวเองเช่นกัน มันค่อนข้างง่ายในการเขียนของคุณเอง

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

ในกรณีของการบริการเว็บมักจะไม่ใช่ข้อผิดพลาดของเซิร์ฟเวอร์ภายในและไม่ควรเป็น 500 แต่ควรเป็น 400 ซึ่งเป็นคำขอที่ไม่ดี

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

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

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

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

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

คุณสามารถใช้ยืนยันได้ตลอดเวลา การอภิปรายมาถึงเมื่อใช้ ตัวอย่างในคำแนะนำ :

• อย่าใช้การยืนยันสำหรับการตรวจสอบการโต้แย้งในวิธีการสาธารณะ
• อย่าใช้คำยืนยันในการทำงานใด ๆ ที่แอปพลิเคชันของคุณต้องการสำหรับการทำงานที่ถูกต้อง