วิธีการตรวจสอบอินพุตโดยไม่มีข้อยกเว้นหรือความซ้ำซ้อน

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

ดังนั้นสิ่งที่มักจะเกิดขึ้นคือฉันคิดว่าโค้ดบางส่วนเช่นนี้ (นี่เป็นเพียงตัวอย่างเพื่อประโยชน์ของตัวอย่างไม่ต้องสนใจฟังก์ชั่นที่ใช้งานตัวอย่างใน Java):

public static String padToEvenOriginal(int evenSize, String string) {
    if (evenSize % 2 == 1) {
        throw new IllegalArgumentException("evenSize argument is not even");
    }

    if (string.length() >= evenSize) {
        return string;
    }

    StringBuilder sb = new StringBuilder(evenSize);
    sb.append(string);
    for (int i = string.length(); i < evenSize; i++) {
        sb.append(' ');
    }
    return sb.toString();
}

ตกลงดังนั้นพูดได้ว่าevenSizeมาจากการป้อนข้อมูลของผู้ใช้ ดังนั้นฉันไม่แน่ใจว่ามันจะเป็นเช่นนั้น แต่ฉันไม่ต้องการเรียกวิธีนี้โดยมีความเป็นไปได้ที่จะมีข้อผิดพลาดเกิดขึ้น ดังนั้นฉันจึงทำฟังก์ชั่นต่อไปนี้:

public static boolean isEven(int evenSize) {
    return evenSize % 2 == 0;
}

แต่ตอนนี้ฉันมีสองการตรวจสอบที่ดำเนินการตรวจสอบการป้อนข้อมูลเหมือนกัน: การแสดงออกในคำสั่งและการตรวจสอบอย่างชัดเจนในif isEvenทำซ้ำรหัสไม่ดีดังนั้นเราจะทำการ refactor:

public static String padToEvenWithIsEven(int evenSize, String string) {
    if (!isEven(evenSize)) { // to avoid duplicate code
        throw new IllegalArgumentException("evenSize argument is not even");
    }

    if (string.length() >= evenSize) {
        return string;
    }

    StringBuilder sb = new StringBuilder(evenSize);
    sb.append(string);
    for (int i = string.length(); i < evenSize; i++) {
        sb.append(' ');
    }
    return sb.toString();
}

ตกลงนั่นแก้ไขได้ แต่ตอนนี้เราเข้าสู่สถานการณ์ต่อไปนี้:

String test = "123";
int size;
do {
    size = getSizeFromInput();
} while (!isEven(size)); // checks if it is even
String evenTest = padToEvenWithIsEven(size, test);
System.out.println(evenTest); // checks if it is even (redundant)

ตอนนี้เราได้รับการตรวจสอบซ้ำซ้อน: เรารู้อยู่แล้วว่าค่านี้เป็นเลขคู่ แต่padToEvenWithIsEvenยังคงทำการตรวจสอบพารามิเตอร์ซึ่งจะคืนค่าจริงเสมอเมื่อเราเรียกฟังก์ชันนี้แล้ว

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

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

public static String padToEvenSmarter(int numberOfBigrams, String string) {
    int size = numberOfBigrams * 2;
    if (string.length() >= size) {
        return string;
    }

    StringBuilder sb = new StringBuilder(size);
    sb.append(string);
    for (int i = string.length(); i < size; i++) {
        sb.append('x');
    }
    return sb.toString();
}

แต่สิ่งนี้ต้องใช้ความคิดที่ชาญฉลาดและค่อนข้าง refactor ขนาดใหญ่

มีวิธีการทั่วไป (เพิ่มเติม) ที่เราสามารถหลีกเลี่ยงการโทรซ้ำซ้อนisEvenและดำเนินการตรวจสอบพารามิเตอร์ซ้ำได้หรือไม่? ฉันต้องการวิธีการแก้ปัญหาที่จะไม่โทรpadToEvenด้วยพารามิเตอร์ที่ไม่ถูกต้องจริงเรียกข้อยกเว้น

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

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

public static String padString(int size, String string) {
    if (string.length() >= size) {
        return string;
    }

    StringBuilder sb = new StringBuilder(size);
    sb.append(string);
    for (int i = string.length(); i < size; i++) {
        sb.append(' ');
    }
    return sb.toString();
}

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

final class EvenInteger {
  public final int value;

  public EvenInteger(int value) {
    if (!(value % 2 == 0))
      throw new IllegalArgumentException("EvenInteger(" + value + ") is not even");
    this.value = value;
  }
}

ตอนนี้คุณสามารถประกาศ

public static String padStringToEven(EvenInteger evenSize, String string)
    ...

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

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

ในฐานะที่เป็นส่วนขยายของคำตอบ @ amon เราสามารถรวมเขาเข้าEvenIntegerกับชุมชนการเขียนโปรแกรมที่ใช้งานได้อาจเรียกว่า "Smart Constructor" - ฟังก์ชั่นที่หุ้มตัวสร้างใบ้และตรวจสอบให้แน่ใจว่าวัตถุนั้นอยู่ในสถานะที่ถูกต้อง คลาสคอนสตรัคหรือในภาษาที่ไม่ใช่คลาสโมดูล / แพคเกจส่วนตัวเพื่อให้แน่ใจว่ามีการใช้ตัวสร้างสมาร์ทเท่านั้น) เคล็ดลับคือการส่งคืนOptional(หรือเทียบเท่า) เพื่อให้ฟังก์ชั่นแต่งได้มากขึ้น

public final class EvenInteger {
    private final int value;

    private EvenInteger(value) {
        this.value = value;
    }

    public static Optional<EvenInteger> of(final int value) {
        if (value % 2 == 0) {
            return Optional.of(new EvenInteger(value));
        }
        return Optional.empty();
    }

    public int getValue() {
        return this.value;
    }
}

จากนั้นเราสามารถใช้Optionalวิธีมาตรฐานเพื่อเขียนตรรกะอินพุตได้อย่างง่ายดาย:

class GetEvenInput {
    public Optional<EvenInteger> askOnce() {
        int size = getSizeFromInput();
        return EvenInteger.of(size);
    }

    public EvenInteger keepAsking() {
        return askOnce().orElseGet(() -> keepAsking());
    }
}

นอกจากนี้คุณยังสามารถเขียนkeepAsking()ในสไตล์ Java ที่มีสำนวนมากขึ้นด้วยการวนซ้ำในขณะที่

Optional<EvenInteger> result;
do {
    result = askOnce();
} while (!result.isPresent());

return result.get();

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

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

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

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