Це принцип стилю кодування - наприклад, принцип єдиного виходу
Люди, які все ще заважають на виїзд з одним або кількома виїздами, все ще застрягли в кінці 1960-х. Тоді така дискусія була важливою, оскільки ми знаходилися в зародковому стані структурованого програміста, і було досить багато табору, який заявив, що висновки, що стоять за теоремою Структурної програми Бома-Якопіні, не були загальноприйнятними для всіх конструкцій програмування.
Це щось, що мало би вирішити вже давно. Ну, це було врегульовано (майже 4 десятиліття, якщо бути точним, як в Академії, так і в галузі), але люди (ті, хто абсолютно проти чи проти) не звертали уваги.
Щодо решти моїх відповідей, то це все відносно (що не в програмному забезпеченні?):
Так. Більшу частину часу для загального випадку, із застереженнями, характерними для крайових справ та мовних програмних конструкцій.
Завжди чи просто іноді?
Більшість часу.
Скільки різниці це насправді?
Залежить.
Читаний код проти нечитабельного коду. Підвищена складність (про яку ми повинні знати на сьогоднішній день збільшує ймовірність введення помилок) проти більш простої складності (і ерго, менша ймовірність помилок.) Мови, компілятори яких не додають неявного повернення (скажімо, Pascal, Java або C #), і ті, які за замовчуванням до int (C і C ++).
Зрештою, це вміння, відточене у людини / години за клавіатурою. Іноді нормально мати кілька повернених висловлювань, як тут (у деяких псевдокодах Pascal'esque):
function foo() : someType
begin
if( test1 == true )
then
return x;
end
doSomethignElseThatShouldnHappenIfTest1IsTrue();
return somethingElse();
end;
Намір зрозумілий, а алгоритм досить малий і досить нехитрий, що не гарантує створення змінної 'flag', яка містить кінцеве значення повернення, яке використовується в одній точці повернення. Алгоритм може бути помилковим, але його структура досить проста, що зусилля на виявлення помилки (швидше за все) незначні.
Іноді це не так (тут використовується псевдокод, подібний С):
switch(someVal)
{
case v1 : return x1;
case v2 : return x2:
case v3 : doSomething(); // fall-through
case v4: // fall-through
case v5: // fall-through
case v6: return someXthingie;
...
...
default:
doSomething(); // no return statement yet
}
Тут алгоритм не має простої структури, і оператор перемикання (такий у стилі С) дозволяє проходити кроки, що проходять, які можуть бути, а можуть і не робитись навмисно як частина алгоритму.
Можливо, алгоритм правильний, але погано написаний.
А може, зовнішніми силами, що перевищують можливості програміста, це фактичне (і правильне) подання законно необхідного алгоритму.
Можливо, це неправильно.
Щоб розкрити істину будь-якого з цього, потрібно набагато більше зусиль, ніж у попередньому прикладі. І в цьому криється те, що я дуже вірю (зауважте, що я не маю жодних формальних досліджень, щоб підтвердити це):
Припускаючи фрагмент коду, який вважається правильним:
Кілька операторів повернення підвищують читабельність та простоту такого фрагмента коду, якщо фрагмент являє собою простий алгоритм із суттєво простою структурою потоку. Під простим, я не маю на увазі малого, але маю на увазі зрозуміле або самодоказ , те, що не вимагає непропорційних зусиль читання (ні спонукання людей до блювоти, проклинання чиєїсь матері чи ковтання кулі, коли їм доведеться її читати. )
Один оператор повернення збільшує читабельність та простоту такого фрагмента коду, якщо значення повернення або обчислюється під час виконання алгоритму, або якщо кроки в алгоритмі, відповідальні за його обчислення, можуть бути об'єднані в одне місце в межах структури алгоритму. .
Один оператор повернення зменшує читабельність і простоту такого фрагмента коду, якщо він вимагає присвоєння одній або більше змінним прапорів, при цьому розташування таких призначень не є рівномірно розташованими в алгоритмі.
Кілька операторів повернення знижують читабельність та простоту такого фрагмента коду, якщо висловлювання повернення не є рівномірно розподіленими по алгоритму, і якщо вони розмежовують взаємовиключні блоки коду, не однакові за розміром чи структурою між собою.
Це тісно пов'язане зі складністю фрагмента коду, про який йдеться. А це в свою чергу пов'язане з цикломатичними заходами та комплексною комплексністю. З цього можна було спостерігати наступне:
Чим більший розмір підпрограми або функції, тим більша і складніша її структура потоку внутрішнього управління, і тим більша ймовірність, що перед вами виникне питання про те, чи використовувати декілька операторів повернення або кілька.
Висновок такий: нехай ваші функції будуть малі, роблячи одне і лише одне (і все це робити добре). Якщо вони демонструють номінально малі показники складності в цикломатичному стилі та в півсторонніх ступенях, не тільки вони повинні бути найбільш вірогідними і виконувати завдання, зрозумілі, їх внутрішні структури також будуть відносно зрозумілими.
Тоді, і тільки тоді ви зможете досить легко і не втрачаючи багато сну, ви можете вирішити, чи використовувати одне повернення і кілька повернень, не ризикуючи ввести помилки з будь-яким вибором.
Можна також поглянути на все це і припустити, що коли люди борються з питанням одноразових повернень або декількох повернень, це тому, що - або через недосвідченість, дурість або відсутність трудової етики - вони не пишуть чистий код і схильні писати жахливі функції з повним ігноруванням цикломатичних та піклувальних заходів.