Чи добре використовувати винятки як інструменти для раннього «ловлення» помилок?

Я використовую винятки, щоб рано наздогнати проблеми. Наприклад:

public int getAverageAge(Person p1, Person p2){
    if(p1 == null || p2 == null)
        throw new IllegalArgumentException("One or more of input persons is null").
    return (p1.getAge() + p2.getAge()) / 2;
}

Моя програма ніколи не повинна переходити nullна цю функцію. Я ніколи цього не маю намір. Однак, як ми всі знаємо, в програмуванні трапляються випадкові речі.

Якщо виникла ця проблема, викид, якщо ця проблема виникає, дозволяє мені виявити та виправити її, перш ніж вона спричинить більше проблем в інших місцях програми. Виняток зупиняє програму і каже мені, що "тут трапилися погані речі, виправте це". Замість цього nullпереміщення по програмі спричиняє проблеми в інших місцях.

Тепер ви маєте рацію, у цьому випадку це nullпросто спричинить NullPointerExceptionвідразу, тому це може бути не найкращим прикладом.

Але розглянемо, наприклад, такий метод, як цей:

public void registerPerson(Person person){
    persons.add(person);
    notifyRegisterObservers(person); // sends the person object to all kinds of objects.
}

У цьому випадку nullпараметр a як передається навколо програми, і може спричинити помилки набагато пізніше, які важко простежити до їх походження.

Зміна такої функції:

public void registerPerson(Person person){
    if(person == null) throw new IllegalArgumentException("Input person is null.");
    persons.add(person);
    notifyRegisterObservers(person); // sends the person object to all kinds of objects.
}

Дозволяє мені помітити проблему набагато раніше, ніж вона спричинить дивні помилки в інших місцях.

Також nullпосилання як параметр є лише прикладом. Це може бути багато видів проблем, від недійсних аргументів до чого-небудь іншого. Завжди краще помітити їх рано.

Тож моє запитання просто: це хороша практика? Чи добре використовувати виключення як інструменти для запобігання проблемам? Це законне застосування винятків чи це проблематично?

Так, "невдалий термін" - дуже хороший принцип, і це просто один із можливих способів його здійснення. І в методах, які повинні повернути певне значення, насправді не дуже багато чого можна зробити, щоб навмисно провалитися - це або кидання винятків, або запуск тверджень. Винятки повинні сигналізувати про "виняткові" умови, і виявлення помилки програмування, безумовно, є винятковою.

Так, кидати винятки - це гарна ідея. Киньте їх рано, кидайте їх часто, кидайте їх жадібно.

Я знаю, що існує дискусія про "винятки проти тверджень", яка має виняткову поведінку (зокрема, ті, які вважають, що відображають помилки програмування), які обробляються твердженнями, які можна "скласти" під час виконання, а не налагодження / тестування складових. Але кількість продуктивності, витраченої на кілька додаткових перевірок на правильність, мінімальна для сучасного обладнання, і будь-які додаткові витрати набагато перевищують значення правильних, непошкоджених результатів. Я ніколи насправді не зустрічав кодову програму програми, для якої я хотів би (більшість) перевірок видалити під час виконання.

Мені хочеться сказати, що я не хотів би багато зайвих перевірок і умов у вузьких циклах чисельно інтенсивного коду ... але це насправді там, де генерується багато числових помилок, і якщо їх не буде зроблено, пошириться назовні впливати на всі результати. Так що навіть там перевірки варто робити. Насправді, деякі з найкращих, найефективніших чисельних алгоритмів засновані на оцінці помилок.

Останнє місце, щоб бути дуже усвідомленим додатковим кодом, - це дуже чутливий код, коли додаткові умови можуть спричинити затримки трубопроводу. Отже, в середині операційної системи, СУБД та інші ядра проміжного програмного забезпечення, а також обробка зв'язку / протоколів низького рівня. Але знову ж таки, деякі місця, які найчастіше спостерігаються помилки, і їх ефекти (безпека, правильність та цілісність) є найбільш згубними.

Я знайшов одне вдосконалення - не кидати лише винятки базового рівня. IllegalArgumentExceptionце добре, але по суті може походити з будь-якого місця. Для додавання спеціальних винятків на більшості мов не потрібно багато. Про свій модуль по роботі з персоналом скажіть:

public class PersonArgumentException extends IllegalArgumentException {
    public MyException(String message) {
        super(message);
    }
}

Потім, коли хтось бачить PersonArgumentException, зрозуміло, звідки вона береться. Існує акт збалансування того, скільки спеціальних винятків ви хочете додати, тому що ви не хочете без потреби множувати сутності (Оккамова бритва). Часто достатньо лише декількох спеціальних винятків для сигналізації "цей модуль не отримує потрібних даних!" або "цей модуль не може робити те, що повинен робити!" таким чином, що є специфічним та адаптованим, але не настільки точним, що вам доведеться повторно реалізувати всю ієрархію винятків. Я часто стикаюся з тим невеликим набором спеціальних винятків, починаючи з винятків акцій, потім сканую код і розумію, що "ці N місця збільшують винятки з акцій, але вони зводяться до ідеї вищого рівня, що вони не отримують дані їм потрібно; хай '

Невдача якнайшвидше - це чудово під час налагодження програми. Я пам’ятаю особливу помилку сегментації у застарілій програмі C ++: місце, де виявлено помилку, не має нічого спільного з місцем її введення (нульовий покажчик щасливо переміщувався з одного місця в інше в пам’яті, перш ніж нарешті викликав проблему ). Сліди стека не можуть допомогти вам у цих випадках.

Так, так, захисне програмування - це дійсно ефективний підхід до швидкого виявлення та виправлення помилок. З іншого боку, це може переборщити, особливо з нульовими посиланнями.

Наприклад, у вашому конкретному випадку: якщо будь-яка з посилань є недійсною, запит NullReferenceExceptionбуде кинуто на наступне твердження при спробі досягти віку однієї людини. Тут вам не потрібно перевіряти речі самостійно: нехай система лежить у цих помилках та викидає винятки, тому вони існують .

Для більш реалістичного прикладу ви можете використовувати assertзаяви, які:

1. Коротше писати та читати:

       assert p1 : "p1 is null";
       assert p2 : "p2 is null";
   

2. Розроблені спеціально для вашого підходу. У світі, де у вас є і твердження, і винятки, ви можете їх розрізнити так:

   • Ствердження стосуються помилок програмування ("/ * цього ніколи не повинно відбуватися * /"),
   • Винятки становлять випадкові випадки (виняткові, але ймовірні ситуації)

Таким чином, викриваючи ваші припущення щодо входів та / або стану вашої програми із твердженнями, дайте можливість наступному розробникові трохи зрозуміти мету вашого коду.

Статичний аналізатор (наприклад, компілятор) також може бути щасливішим.

Нарешті, твердження можна видалити з розгорнутої програми за допомогою одного перемикача. Але взагалі не варто сподіватися на підвищення ефективності з цим: перевірки тверджень під час виконання є незначними.

Наскільки мені відомо, різні програмісти віддають перевагу тому чи іншому рішенню.

Перше рішення, як правило, є кращим, оскільки воно є більш стислим, зокрема, вам не доведеться перевіряти однакові умови знову і знову на різних функціях.

Я знаходжу друге рішення, наприклад

public void registerPerson(Person person){
    if(person == null) throw new IllegalArgumentException("Input person is null.");
    persons.add(person);
    notifyRegisterObservers(person); // sends the person object to all kinds of objects.
}

більш солідний, бо

1. Він виявляє помилку якнайшвидше, тобто коли registerPerson()викликається, а не коли нульовий виняток вказівника кидається десь у стек виклику. Налагодження стає набагато простіше: всі ми знаємо, наскільки недійсне значення може пройти через код, перш ніж воно проявиться як помилка.
2. Це зменшує зв'язок між функціями: registerPerson()не робить жодних припущень щодо того, які інші функції в кінцевому підсумку будуть використовувати personаргумент та як вони будуть його використовувати: рішення, яке nullє помилкою, приймається та реалізується локально.

Отже, особливо якщо код досить складний, я, як правило, віддаю перевагу цьому другому підходу.

Загалом, так, добре "рано провалюватися". Однак у вашому конкретному прикладі явний IllegalArgumentExceptionне забезпечує суттєвого покращення порівняно з a NullReferenceException- тому що обидва об'єкти, над якими функціонують, вже передаються як аргументи функції.

Але давайте розглянемо дещо інший приклад.

class PersonCalculator {
    PersonCalculator(Person p) {
        if (p == null) throw new ArgumentNullException("p");
        _p = p;
    }

    void Calculate() {
        // Do something to p
    }
}

Якщо б не було перевірки аргументів у конструкторі, ви отримали б NullReferenceExceptionпри дзвінку Calculate.

Але зламаний фрагмент коду не був ні Calculateфункцією, ні споживачем Calculateфункції. Розбитий фрагмент коду був кодом, який намагається сконструювати PersonCalculatorз нулем Person- тому ми хочемо, щоб сталося виключення.

Якщо ми видалимо цю явну перевірку аргументів, вам доведеться з’ясувати, чому NullReferenceExceptionсталося, коли Calculateвикликався. І відстеження, чому об’єкт був побудований з nullлюдиною, може бути хитромудрим, особливо якщо код, що конструює калькулятор, не наближений до коду, який насправді викликає Calculateфункцію.

Не в наведених прикладах.

Як ви кажете, кидання явно не приносить вам великої ваги, коли ви збираєтесь отримати виняток незабаром після цього. Багато хто буде стверджувати, що краще мати явний виняток з хорошим повідомленням, хоча я не згоден. У попередньо випущених сценаріях слід стека досить хороший. У сценаріях після випуску сайт дзвінків часто може надавати кращі повідомлення, ніж всередині функції.

Друга форма - це надто багато інформації для функції. Ця функція не обов'язково повинна знати, що інші функції будуть вводитись при нульовому введенні. Навіть якщо вони роблять кидок на вході нульовий Тепер , він стає дуже клопітно реорганізувати слід , що зупинка є випадок з перевіркою нульовий є поширення по всьому коду.

Але загалом слід кидатись рано, як тільки визначиш, що щось пішло не так (при повазі до ДУХОГО). Вони, мабуть, не є великими прикладами цього.

У вашій прикладі функції я вважаю за краще, щоб ви не перевіряли і просто дозволяли це NullReferenceExceptionстатися

Для одного немає сенсу пропускати туди нуль у будь-якому випадку, тож я з’ясую проблему одразу на основі кидання а NullReferenceException.

По-друге, це те, що якщо кожна функція викидає дещо різні винятки, виходячи з того, які дані очевидно неправильних даних були надані, то досить скоро у вас є функції, які можуть викидати 18 різних типів винятків, і досить скоро ви виявите, що говорите, що це занадто багато роботи для вирішення, і просто придушення всіх винятків у будь-якому випадку.

Насправді ви нічого не можете зробити, щоб допомогти ситуації помилки проектування у вашій функції, тому просто дозвольте відмовитись, не змінюючи її.