İstisnalar veya yedeklilik olmadan giriş doğrulaması nasıl yapılır

Belirli bir program için bir arabirim oluşturmaya çalıştığımda genellikle doğrulanmamış girişe bağlı istisnalar atmaktan kaçınmaya çalışıyorum.

Yani sık sık böyle bir kod parçası düşündüm ki (bu sadece bir örnek uğruna bir örnek, gerçekleştirdiği işleve aldırma, örneğin 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();
}

Tamam, evenSizeaslında kullanıcı girişinden türetilmiş olduğunu söyleyin . Bu yüzden bile olduğundan emin değilim. Ancak bu yöntemi bir istisna oluşması ihtimaliyle çağırmak istemiyorum. Bu yüzden aşağıdaki işlevi yaparım:

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

ama şimdi aynı giriş doğrulamasını gerçekleştiren iki kontrolüm var: ifadedeki ififade ve açık check-in isEven. Yinelenen kod, hoş değil, bu yüzden yeniden düzenleyelim:

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();
}

Tamam, bu çözüldü, ama şimdi aşağıdaki duruma giriyoruz:

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)

artık yedekli bir kontrolümüz var: değerin eşit olduğunu zaten biliyoruz, ancak padToEvenWithIsEvenyine de bu işlevi çağırdığımız için her zaman true döndürecek parametre kontrolünü gerçekleştiriyoruz.

Şimdi isEvenelbette bir sorun oluşturmuyor, ancak parametre kontrolü daha hantalsa, bu çok fazla maliyete neden olabilir. Bunun yanı sıra, fazladan bir çağrı yapmak doğru gelmiyor.

Bazen "doğrulanmış bir tür" tanıtarak veya bu sorunun oluşamayacağı bir işlev oluşturarak bu sorunu çözebiliriz:

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();
}

ancak bu biraz akıllı düşünme ve oldukça büyük bir yeniden düzenleme gerektirir.

Gereksiz çağrıları önleyebilmemiz isEvenve çift parametre kontrolü gerçekleştirebilmemiz için (daha fazla) genel bir yol var mı? Çözümün aslında padToEvengeçersiz bir parametre ile çağrılmamasını ve istisnayı tetiklemesini istiyorum.

İstisnalar dışında, istisnasız programlama anlamına gelmez, yani kullanıcı girişi tasarım tarafından bir istisna tetiklemez, genel fonksiyonun kendisi hala parametre kontrolünü içerir (sadece programlama hatalarına karşı korumak için).

Örneğinizde, en iyi çözüm daha genel bir dolgu işlevi kullanmaktır; arayan kişi eşit bir boyuta geçmek isterse bunu kendileri kontrol edebilir.

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();
}

Bir değer üzerinde sürekli olarak aynı doğrulamayı gerçekleştirirseniz veya yalnızca bir türdeki değerlerin alt kümesine izin vermek istiyorsanız, mikrotipler / küçük türler yardımcı olabilir. Doldurma gibi genel amaçlı araçlar için bu iyi bir fikir değildir, ancak değeriniz alan adı modelinizde belirli bir rol oynarsa, ilkel değerler yerine özel bir tür kullanmak ileriye doğru büyük bir adım olabilir. Burada şunları tanımlayabilirsiniz:

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;
  }
}

Şimdi beyan edebilirsiniz

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

içeriden doğrulama yapmak zorunda değilsiniz. Bu kadar basit bir test için bir int'i bir nesnenin içine sarmak, çalışma süresi performansı açısından daha pahalı olacaktır, ancak yazım sistemini kendi yararınıza kullanmak hataları azaltabilir ve tasarımınızı netleştirebilir.

Bu tür küçük türlerin kullanılması, hiçbir doğrulama yapmadıklarında bile, örneğin FirstNamea LastName. Bu kalıbı sık sık statik olarak yazılmış dillerde kullanıyorum.

@ Amon'un cevabının bir uzantısı olarak EvenInteger, işlevsel programlama topluluğunun "Akıllı Yapıcı" olarak adlandırabileceği şeyle birleştirebiliriz - aptal yapıcıyı saran ve nesnenin geçerli bir durumda olduğundan emin olan bir işlev (dilsiz kurucu sınıfı veya sınıf dışı dillerdeki modül / paket özel olarak yalnızca akıllı kurucuların kullanıldığından emin olun). İşin püf noktası Optional, işlevi daha karmaşık hale getirmek için bir (veya eşdeğeri) döndürmektir .

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;
    }
}

Daha sonra Optionalgiriş mantığını yazmak için standart yöntemleri kolayca kullanabiliriz :

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

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

keepAsking()Do-while döngüsü ile daha deyimsel bir Java stili de yazabilirsiniz .

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

return result.get();

Daha sonra kodunuzun geri kalanında EvenIntegergerçekten eşit olacağına ve hatta çekimizin sadece bir kez yazıldığı belgelerine güvenebilirsiniz EvenInteger::of.

Doğrulamanın sonucu aynıysa ve doğrulama aynı sınıfta yapılıyorsa, iki kez doğrulama yapmak bir sorundur. Bu senin örneğin değil. Yeniden düzenlenmiş kodunuzda yapılan ilk isEven denetimi giriş doğrulamasıdır, başarısızlık yeni bir giriş istenir. İkinci kontrol, sınıfın dışından çağrılabilen ve farklı bir sonuca (istisna) sahip genel bir padToEvenWithEven yönteminde olduğu gibi ilkinden tamamen bağımsızdır .

Sorununuz, yanlışlıkla aynı kodun kuru olmama nedeniyle karıştırılması sorununa benzer. Uygulamayı tasarımla karıştırıyorsunuz. Aynı değildirler ve aynı olan bir veya bir düzine çizginiz olması, aynı amaca hizmet ettikleri ve sonsuza kadar değiştirilebilir olarak kabul edilebilecekleri anlamına gelmez. Ayrıca, muhtemelen sınıfınızı çok fazla yapmak, ancak atlayın, çünkü bu muhtemelen sadece bir oyuncak örneği ...

Bu bir performans sorunuysa, genel padToEvenWithEven uygulamanızın doğrulama işlemini yaptıktan sonra çağırdığı ve bunun yerine diğer yöntemin de arayacağı özel bir yöntem oluşturarak sorunu çözebilirsiniz. Bu bir performans sorunu değilse, farklı yöntemlerinizin atanmış görevlerini gerçekleştirmeleri için gereken denetimleri yapmasına izin verin.