Должна ли функция иметь только один оператор возврата?

Никто не упомянул и не цитировал Code Complete, поэтому 9X_coding-standards я сделаю это.

17,1 возврат

Сведите к минимуму количество возвратов в каждой программе. Труднее понять процедуру, если, читая 9X_language-independent ее внизу, вы не подозреваете, что она вернулась 9X_code-style где-то наверху.

Используйте return, когда он улучшает читаемость. В некоторых подпрограммах, узнав 9X_coding-convention ответ, вы хотите немедленно вернуть его 9X_coding-style вызывающей подпрограмме. Если подпрограмма 9X_spaghetti-code определена таким образом, что не требует 9X_coding-style очистки, незамедлительный возврат означает, что 9X_programming-style вам нужно написать больше кода.

Я бы сказал, что было бы невероятно неразумно 9X_clean-code принимать произвольное решение против нескольких 9X_spaghetti-code точек выхода, поскольку я обнаружил, что 9X_coding-standards этот метод полезен на практике снова и снова, на самом 9X_programming-style деле я часто рефакторил существующий код для большей ясности . Мы можем 9X_programming-style сравнить два подхода таким образом: -

string fooBar(string s, int? i) { string ret = ""; if(!string.IsNullOrEmpty(s) && i != null) { var res = someFunction(s, i); bool passed = true; foreach(var r in res) { if(!r.Passed) { passed = false; break; } } if(passed) { // Rest of code... } } return ret; } 

Сравните 9X_clean-code это с кодом, в котором разрешены несколько точек 9X_language-agnostic выхода:-

string fooBar(string s, int? i) { var ret = ""; if(string.IsNullOrEmpty(s) || i == null) return null; var res = someFunction(s, i); foreach(var r in res) { if(!r.Passed) return null; } // Rest of code... return ret; } 

Я думаю, что последнее значительно 9X_spaghetti-code яснее. Насколько я могу судить, критика 9X_coding-guidelines множественных точек выхода в наши дни является 9X_coding-standards довольно архаичной точкой зрения.

В настоящее время я работаю над кодовой 9X_coding-style базой, в которой два человека, работающие 9X_language-independent над ней, слепо придерживаются теории «единой 9X_programming-style точки выхода», и я могу сказать вам, исходя 9X_coding-guidelines из своего опыта, что это ужасная ужасная 9X_coding-guidelines практика. Это чрезвычайно усложняет поддержку 9X_coding-convention кода, и я покажу вам, почему.

С теорией «единой 9X_coding-guidelines точки выхода» вы неизбежно получите код, который 9X_language-agnostic выглядит так:

function() { HRESULT error = S_OK; if(SUCCEEDED(Operation1())) { if(SUCCEEDED(Operation2())) { if(SUCCEEDED(Operation3())) { if(SUCCEEDED(Operation4())) { } else { error = OPERATION4FAILED; } } else { error = OPERATION3FAILED; } } else { error = OPERATION2FAILED; } } else { error = OPERATION1FAILED; } return error; } 

Это не только делает код очень 9X_programming-style трудным для понимания, но теперь говорят, что 9X_coding-convention позже вам нужно вернуться и добавить операцию 9X_code-style между 1 и 2. ваших условий if/else и фигурных 9X_programming-style скобок сопоставляются правильно.

Этот метод 9X_language-independent делает поддержку кода чрезвычайно сложной 9X_coding-guidelines и подверженной ошибкам.

Structured programming говорит, что у вас должен быть только один 9X_language-agnostic оператор return для каждой функции. Это 9X_language-agnostic сделано для ограничения сложности. Многие 9X_spaghetti-code люди, такие как Мартин Фаулер, утверждают, что 9X_language-independent проще писать функции с несколькими операторами 9X_language-independent возврата. Он представляет этот аргумент 9X_spaghetti-code в написанной им классической книге refactoring. Это 9X_coding-standards хорошо работает, если вы следуете другим 9X_language-independent его советам и пишете небольшие функции. Я 9X_coding-style согласен с этой точкой зрения, и только 9X_code-style строгие сторонники структурного программирования 9X_code-style придерживаются одного оператора возврата 9X_coding-guidelines для каждой функции.

Как отмечает Кент Бек при обсуждении защитных 9X_clean-code предложений в Implementation Patterns создание подпрограммы с одной 9X_code-style точкой входа и выхода...

"должно было 9X_clean-code предотвратить возможную путаницу при прыжках 9X_coding-style в и из многих места в той же программе. Это 9X_spaghetti-code сделало здравый смысл применительно к 9X_coding-guidelines FORTRAN или написаны программы на ассемблере с 9X_clean-code большим количеством глобальных данных, где 9X_coding-convention даже понимание того, какие заявления были выполненная 9X_spaghetti-code была тяжелая работа ... с небольшими методами 9X_code-style и в основном локальными данными, это излишне 9X_coding-guidelines консервативно."

Я считаю, что функция, написанная 9X_clean-code с помощью защитных предложений, намного 9X_code-style проще для понимания, чем один длинный вложенный 9X_coding-standards набор операторов if then else.

В функции, которая не имеет побочных эффектов, нет 9X_coding-guidelines веских причин иметь более одного возврата, и 9X_programming-style вы должны писать их в функциональном стиле. В 9X_coding-standards методе с побочными эффектами все более последовательно 9X_programming-style (индексировано по времени), поэтому вы пишете 9X_spaghetti-code в императивном стиле, используя оператор 9X_coding-style return как команду для прекращения выполнения.

Другими 9X_clean-code словами, по возможности отдавайте предпочтение 9X_spaghetti-code этому стилю

return a > 0 ? positively(a): negatively(a); 

над этим

if (a > 0) return positively(a); else return negatively(a); 

Если вы обнаружите, что 9X_coding-guidelines пишете несколько уровней вложенных условий, вероятно, есть 9X_coding-style способ реорганизовать это, например, используя 9X_coding-convention список предикатов. Если вы обнаружите, что 9X_clean-code ваши if и else синтаксически далеко друг 9X_language-agnostic от друга, вы можете разбить это на более 9X_coding-standards мелкие функции. Условный блок, занимающий 9X_programming-style более одного экрана текста, трудно читать.

Не 9X_spaghetti-code существует жесткого правила, применимого 9X_coding-style ко всем языкам. Что-то вроде наличия одного 9X_language-agnostic оператора возврата не сделает ваш код хорошим. Но 9X_language-independent хороший код, как правило, позволяет вам 9X_programming-style писать свои функции таким образом.

Я видел это в стандартах кодирования для 9X_programming-style C++, которые были пережитком C, как если 9X_coding-style бы у вас не было RAII или другого автоматического 9X_spaghetti-code управления памятью, вам приходилось бы очищать 9X_spaghetti-code каждый возврат, что либо означает сокращение 9X_programming-style и- вставка очистки или перехода (логически 9X_coding-guidelines то же самое, что и «наконец» в управляемых 9X_code-style языках), оба из которых считаются дурным 9X_coding-style тоном. Если вы практикуете использование 9X_spaghetti-code интеллектуальных указателей и коллекций 9X_language-independent в C++ или другой системе автоматической 9X_coding-standards памяти, то для этого нет веских причин, и 9X_programming-style все зависит от удобочитаемости и, скорее, от 9X_coding-style суждения.

Я склоняюсь к мысли, что операторы return 9X_coding-standards в середине функции плохи. Вы можете использовать 9X_programming-style return для создания нескольких защитных 9X_language-independent предложений в верхней части функции и, конечно, без 9X_language-independent проблем сообщать компилятору, что возвращать 9X_coding-guidelines в конце функции, но возвращает в середине функции. можно 9X_coding-guidelines легко пропустить и затруднить интерпретацию 9X_coding-convention функции.

Есть ли веские причины, по которым лучше 9X_coding-guidelines иметь только один оператор возврата в функции?

Да, есть:

• Единая точка выхода - отличное место для утверждения ваших пост-условий.
• Часто бывает полезно установить точку останова отладчика на один возврат в конце функции.
• Меньшее количество возвратов означает меньшую сложность. Линейный код обычно проще для понимания.
• Если попытка упростить функцию до одного возвращаемого значения вызывает сложность, то это стимул к рефакторингу в сторону более мелких, более общих и простых для понимания функций.
• Если вы используете язык без деструкторов или не используете RAII, то однократный возврат сокращает количество мест, которые вам нужно очистить.
• Некоторые языки требуют единой точки выхода (например, Pascal и Eiffel).

Вопрос 9X_coding-guidelines часто формулируется как ложная дихотомия 9X_language-agnostic между множественными возвратами или глубоко 9X_language-agnostic вложенными операторами if. Почти всегда 9X_clean-code есть третье решение, которое является очень 9X_coding-standards линейным (без глубокого вложения) только 9X_spaghetti-code с одной точкой выхода.

Обновление: очевидно, MISRA guidelines promote single exit тоже.

Чтобы 9X_coding-style быть ясным, я не говорю, что всегда неправильно 9X_coding-guidelines иметь несколько возвратов. Но, учитывая 9X_coding-convention эквивалентные в остальном решения, есть 9X_coding-standards много веских причин предпочесть вариант 9X_coding-standards с одним возвратом.

Наличие единственной точки выхода дает преимущество 9X_spaghetti-code при отладке, поскольку позволяет установить 9X_code-style единственную точку останова в конце функции, чтобы 9X_language-independent увидеть, какое значение фактически будет 9X_coding-style возвращено.

Обычно я стараюсь иметь только одну точку 9X_coding-standards выхода из функции. Однако бывают случаи, когда 9X_programming-style это на самом деле приводит к созданию более 9X_coding-style сложного тела функции, чем необходимо, и 9X_coding-style в этом случае лучше иметь несколько точек 9X_language-independent выхода. Это действительно должно быть «вынесением 9X_coding-guidelines суждения», основанным на полученной сложности, но 9X_coding-standards целью должно быть как можно меньше точек 9X_spaghetti-code выхода, не жертвуя при этом сложностью и 9X_spaghetti-code понятностью.

Я бы предпочел один выход, если только это 9X_spaghetti-code не усложняет ситуацию. Я обнаружил, что 9X_clean-code в некоторых случаях несколько существующих 9X_coding-style точек могут маскировать другие более серьезные 9X_language-independent проблемы проектирования:

public void DoStuff(Foo foo) { if (foo == null) return; } 

Увидев этот код, я 9X_coding-guidelines бы сразу спросил:

• Является ли 'foo' когда-либо нулевым?
• Если да, то сколько клиентов DoStuff когда-либо вызывали функцию с нулевым значением 'foo'?

В зависимости от ответов 9X_programming-style на эти вопросы может быть, что

1. проверка бессмысленна, так как она никогда не бывает истинной (т.е. это должно быть утверждение)
2. проверка выполняется очень редко, поэтому может быть лучше изменить эти конкретные вызывающие функции, так как они, вероятно, все равно должны выполнять какие-то другие действия.

В обоих приведенных 9X_coding-convention выше случаях код, вероятно, можно переработать 9X_spaghetti-code с утверждением, чтобы гарантировать, что 9X_clean-code 'foo' никогда не будет нулевым, а соответствующие 9X_language-agnostic вызывающие объекты будут изменены.

Есть две 9X_coding-style другие причины (конкретные, я думаю, для 9X_coding-standards кода C++), когда множественные существования 9X_coding-style могут фактически иметь отрицательный эффект. Это размер 9X_coding-convention кода и оптимизация компилятора.

Объект C++, не 9X_coding-guidelines относящийся к POD, в области видимости на 9X_programming-style выходе из функции будет вызывать свой деструктор. Там, где 9X_clean-code есть несколько операторов возврата, может 9X_programming-style случиться так, что в области видимости будут 9X_code-style разные объекты, и поэтому список вызываемых 9X_code-style деструкторов будет другим. Поэтому компилятору 9X_spaghetti-code необходимо генерировать код для каждого 9X_clean-code оператора return:

void foo (int i, int j) { A a; if (i > 0) { B b; return ; // Call dtor for 'b' followed by 'a' } if (i == j) { C c; B b; return ; // Call dtor for 'b', 'c' and then 'a' } return 'a' // Call dtor for 'a' } 

Если размер кода является 9X_language-independent проблемой, возможно, этого стоит избегать.

Другая 9X_clean-code проблема связана с «оптимизацией именованного 9X_language-independent возвращаемого значения» (также известной 9X_programming-style как Copy Elision, ISO C++ '03 12.8/15). C++ позволяет 9X_code-style реализации пропустить вызов конструктора 9X_code-style копирования, если это возможно:

A foo () { A a1; // do something return a1; } void bar () { A a2 ( foo() ); } 

Просто взяв 9X_coding-style код как есть, объект «a1» создается в «foo», а 9X_coding-style затем его копирующая конструкция вызывается 9X_code-style для создания «a2». Однако исключение копирования 9X_clean-code позволяет компилятору построить 'a1' в том 9X_language-agnostic же месте стека, что и 'a2'. Поэтому нет 9X_clean-code необходимости «копировать» объект при возврате 9X_coding-standards функции.

Множественные точки выхода усложняют 9X_programming-style работу компилятора, пытающегося обнаружить 9X_language-agnostic это, и, по крайней мере, для относительно 9X_language-agnostic недавней версии VC++ оптимизация не выполнялась 9X_spaghetti-code там, где тело функции имело несколько возвратов. См. Named Return Value Optimization in Visual C++ 2005 для 9X_language-agnostic более подробной информации.

Нет, потому что we don't live in the 1970s any more. Если ваша функция достаточно 9X_coding-style длинная, чтобы возникла проблема с многократным 9X_clean-code возвратом, она слишком длинная.

(Не говоря 9X_clean-code уже о том, что любая многострочная функция 9X_code-style на языке с исключениями в любом случае будет 9X_programming-style иметь несколько точек выхода.)

Я заставляю себя использовать только один 9X_coding-convention оператор return, поскольку он в некотором смысле 9X_coding-standards генерирует запах кода. Позвольте мне объяснить:

function isCorrect($param1, $param2, $param3) { $toret = false; if ($param1 != $param2) { if ($param1 == ($param3 * 2)) { if ($param2 == ($param3 / 3)) { $toret = true; } else { $error = 'Error 3'; } } else { $error = 'Error 2'; } } else { $error = 'Error 1'; } return $toret; } 

(Условия являются произвольными ...)

Чем 9X_clean-code больше условий, чем крупнее функция, тем 9X_programming-style труднее ее читать. Так что, если вы настроены 9X_coding-guidelines на запах кода, вы поймете это и захотите 9X_programming-style провести рефакторинг кода. Два возможных 9X_language-independent решения:

• Многократный возврат
• Реорганизация в отдельные функции

Множественные возвраты

function isCorrect($param1, $param2, $param3) { if ($param1 == $param2) { $error = 'Error 1'; return false; } if ($param1 != ($param3 * 2)) { $error = 'Error 2'; return false; } if ($param2 != ($param3 / 3)) { $error = 'Error 3'; return false; } return true; } 

Отдельные функции

function isEqual($param1, $param2) { return $param1 == $param2; } function isDouble($param1, $param2) { return $param1 == ($param2 * 2); } function isThird($param1, $param2) { return $param1 == ($param2 / 3); } function isCorrect($param1, $param2, $param3) { return !isEqual($param1, $param2) && isDouble($param1, $param3) && isThird($param2, $param3); } 

Конечно, он длиннее и немного запутан, но 9X_language-independent в процессе такого рефакторинга функции мы

• создал ряд многоразовых функций,
• сделал функцию более удобочитаемой, а
• функции сосредоточены на том, почему значения верны.

Наличие единой точки выхода снижает Cyclomatic Complexity и, следовательно, в теории снижает 9X_coding-guidelines вероятность появления ошибок в коде при 9X_language-independent его изменении. Однако практика подсказывает, что 9X_coding-style необходим более прагматичный подход. Поэтому 9X_clean-code я стремлюсь иметь одну точку выхода, но 9X_coding-standards разрешаю своему коду иметь несколько, если 9X_coding-style это более читабельно.

Есть хорошие вещи, которые можно сказать 9X_language-independent о единственной точке выхода, и есть плохие 9X_coding-convention вещи, которые можно сказать о неизбежном 9X_spaghetti-code "arrow" программировании, которое возникает в результате.

При 9X_coding-convention использовании нескольких точек выхода во 9X_coding-style время проверки ввода или распределения ресурсов 9X_clean-code я стараюсь очень заметно размещать все «выходы 9X_language-independent с ошибками» в верхней части функции.

Как 9X_clean-code в статье Spartan Programming в «SSDSLPedia», так и в статье 9X_programming-style the single function exit point в «Вики-сайте Portland Pattern Repository» есть 9X_spaghetti-code некоторые проницательные аргументы по этому 9X_code-style поводу. Также, конечно, есть этот пост для 9X_coding-standards рассмотрения.

Если вам действительно нужна 9X_coding-convention единая точка выхода (на любом языке, не 9X_code-style поддерживающем исключения), например, для 9X_coding-guidelines освобождения ресурсов в одном месте, я считаю, что 9X_coding-guidelines тщательное применение goto будет хорошим; см., например, этот 9X_coding-style довольно надуманный пример (сжатый для экономии 9X_language-agnostic места на экране):

int f(int y) { int value = -1; void *data = NULL; if (y < 0) goto clean; if ((data = malloc(123)) == NULL) goto clean; /* More code */ value = 1; clean: free(data); return value; } 

Лично я в целом не люблю 9X_language-agnostic программирование стрелок больше, чем множественные 9X_coding-style точки выхода, хотя и то, и другое полезно 9X_code-style при правильном применении. Лучше всего, конечно, структурировать 9X_coding-convention вашу программу так, чтобы она не требовала 9X_language-independent ни того, ни другого. Обычно помогает разбиение 9X_spaghetti-code вашей функции на несколько частей :)

Хотя 9X_coding-guidelines при этом я все равно получаю несколько точек 9X_language-independent выхода, как в этом примере, где какая-то 9X_language-agnostic более крупная функция была разбита на несколько 9X_coding-guidelines более мелких функций:

int g(int y) { value = 0; if ((value = g0(y, value)) == -1) return -1; if ((value = g1(y, value)) == -1) return -1; return g2(y, value); } 

В зависимости от проекта 9X_code-style или руководств по кодированию большую часть 9X_coding-style стандартного кода можно заменить макросами. В 9X_clean-code качестве примечания, такое разбиение делает 9X_code-style функции g0, g1, g2 очень простыми для тестирования 9X_language-independent по отдельности.

Очевидно, что в объектно-ориентированном 9X_coding-convention языке и языке с поддержкой исключений я 9X_code-style бы не стал использовать такие операторы 9X_coding-standards if (или вообще не использовал бы их, если 9X_language-independent бы мне это сошло с рук с небольшими усилиями), и 9X_language-independent код был бы намного более простым. И не стреловидный. И 9X_language-agnostic большинство неокончательных возвратов, вероятно, будут 9X_coding-convention исключениями.

Короче говоря;

• Несколько возвратов лучше, чем много возвратов
• Более одного возврата лучше, чем огромные стрелки, и guard clauses в целом нормально.
• Исключения могут/должны, по возможности, заменить большинство «защитных оговорок».

Я бы сказал, что у вас должно быть столько, сколько 9X_coding-convention требуется, или любые, которые делают код 9X_spaghetti-code чище (например, guard clauses).

Лично я никогда не слышал/не 9X_clean-code видел никаких «лучших практик», говорящих 9X_coding-standards о том, что у вас должен быть только один 9X_coding-style оператор возврата.

По большей части я стремлюсь 9X_spaghetti-code выйти из функции как можно быстрее, основываясь 9X_coding-convention на логическом пути (защитные предложения 9X_coding-convention — отличный пример этого).

Я считаю, что многократные возвраты обычно 9X_clean-code хороши (в коде, который я пишу на C#). Стиль 9X_clean-code с однократным возвратом - это пережиток 9X_coding-convention C. Но вы, вероятно, не пишете на C.

Не существует закона, требующего только одну точку выхода для метода на всех языках программирования. Некоторые 9X_coding-style люди настаивают на превосходстве этого стиля, а 9X_spaghetti-code иногда возводят его в категорию «правила» или 9X_coding-convention «закона», но это убеждение не подтверждается 9X_coding-guidelines никакими доказательствами или исследованиями.

Использование 9X_language-independent нескольких стилей возврата может быть плохой 9X_programming-style привычкой в ​​коде C, где ресурсы должны 9X_coding-standards быть явно освобождены от распределения, но 9X_language-independent в таких языках, как Java, C#, Python или 9X_coding-guidelines JavaScript, есть такие конструкции, как 9X_programming-style автоматическая сборка мусора и try..finally блоки (и 9X_spaghetti-code блоки using в C#), и этот аргумент неприменим 9X_spaghetti-code - в этих языках очень редко требуется централизованное 9X_language-independent ручное освобождение ресурсов.

Бывают случаи, когда 9X_spaghetti-code одиночный возврат более удобочитаем, и случаи, когда 9X_coding-style это не так. Посмотрите, уменьшает ли это 9X_coding-guidelines количество строк кода, делает ли логику 9X_language-independent более понятной или уменьшает количество 9X_coding-style фигурных скобок и отступов или временных 9X_coding-standards переменных.

Поэтому используйте столько возвратов, сколько 9X_coding-guidelines соответствует вашим художественным чувствам, потому 9X_spaghetti-code что это проблема макета и удобочитаемости, а 9X_code-style не техническая.

Я уже говорил о this at greater length on my blog.

Вы знаете пословицу: красота в глазах смотрящего.

Некоторые люди клянутся 9X_code-style NetBeans, некоторые - IntelliJ IDEA, некоторые - Python, а некоторые 9X_clean-code - PHP.

В некоторых магазинах вы можете потерять 9X_coding-guidelines работу, если будете настаивать на этом:

public void hello() { if (....) { .... } } 

Вопрос 9X_clean-code в наглядности и удобстве обслуживания.

Я 9X_code-style пристрастился к использованию логической 9X_coding-convention алгебры для сокращения и упрощения логики 9X_coding-standards и использования конечных автоматов. Однако 9X_coding-standards были коллеги из прошлого, которые считали, что 9X_code-style мое использование «математических методов» в 9X_language-independent кодировании неприемлемо, потому что оно 9X_programming-style не было бы видимым и поддерживаемым. И это 9X_language-agnostic было бы плохой практикой. Извините, люди, но 9X_coding-convention методы, которые я использую, очень заметны 9X_language-independent и удобны для меня - потому что, когда я 9X_language-agnostic вернусь к коду шесть месяцев спустя, я лучше 9X_coding-guidelines пойму код, увидев беспорядок из пресловутых 9X_clean-code спагетти.

Привет, приятель (как говорил бывший 9X_programming-style клиент), делай, что хочешь, лишь бы ты знал, как 9X_coding-standards это исправить, когда мне нужно, чтобы ты 9X_language-agnostic это исправил.

Я помню, 20 лет назад моего 9X_language-agnostic коллегу уволили за то, что сегодня назвали 9X_coding-convention стратегией agile development. У него был тщательно продуманный 9X_clean-code план действий. Но его менеджер кричал на 9X_coding-style него: «Вы не можете постепенно предоставлять 9X_coding-standards пользователям функции! Вы должны придерживаться 9X_spaghetti-code waterfall». Он ответил менеджеру, что инкрементальная 9X_code-style разработка будет более точной в соответствии 9X_coding-guidelines с потребностями клиентов. Он верил в разработку 9X_language-independent для нужд клиентов, но менеджер верил в кодирование 9X_coding-style в соответствии с «требованиями клиента».

Мы 9X_code-style часто виноваты в нарушении нормализации 9X_code-style данных, границ MVP и MVC. Мы встраиваем вместо 9X_coding-convention построения функции. Мы используем ярлыки.

Лично 9X_code-style я считаю, что PHP - плохая практика, но 9X_spaghetti-code что я знаю? Все теоретические аргументы 9X_clean-code сводятся к тому, чтобы попытаться выполнить 9X_coding-style один набор правил

качество = точность, ремонтопригодность и 9X_coding-standards рентабельность.

Все остальные правила уходят 9X_coding-convention на второй план. И, конечно же, это правило 9X_coding-guidelines никогда не исчезает:

Лень - достоинство хорошего программист.

Я склоняюсь к использованию защитных предложений 9X_coding-style для раннего возврата и выхода в конце метода. Правило 9X_language-independent единого входа и выхода имеет историческое 9X_language-independent значение и было особенно полезно при работе 9X_spaghetti-code с устаревшим кодом, который занимал 10 страниц 9X_spaghetti-code формата A4 для одного метода C++ с множественными 9X_language-independent возвратами (и множеством дефектов). В последнее 9X_spaghetti-code время общепринятой хорошей практикой является 9X_coding-convention использование небольших методов, что снижает 9X_programming-style сопротивление пониманию множественных выходов. В 9X_coding-guidelines следующем примере Kronoz, скопированном 9X_language-agnostic сверху, вопрос заключается в том, что происходит 9X_coding-convention в // Остальной код ...?:

void string fooBar(string s, int? i) { if(string.IsNullOrEmpty(s) || i == null) return null; var res = someFunction(s, i); foreach(var r in res) { if(!r.Passed) return null; } // Rest of code... return ret; } 

Я понимаю, что этот пример несколько 9X_coding-style надуманный, но у меня возникнет соблазн 9X_coding-guidelines реорганизовать цикл foreach в оператор LINQ, который 9X_coding-guidelines затем можно было бы рассматривать в качестве 9X_programming-style защитного предложения. Опять же, в надуманном 9X_clean-code примере цель кода не очевидна, и someFunction() может 9X_language-agnostic иметь какой-то другой побочный эффект, или 9X_programming-style результат может быть использован в // остальной части кода .. ..

if (string.IsNullOrEmpty(s) || i == null) return null; if (someFunction(s, i).Any(r => !r.Passed)) return null; 

Предоставление 9X_programming-style следующей отредактированной функции:

void string fooBar(string s, int? i) { if (string.IsNullOrEmpty(s) || i == null) return null; if (someFunction(s, i).Any(r => !r.Passed)) return null; // Rest of code... return ret; } 

Одна хорошая причина, которую я могу придумать, это 9X_programming-style обслуживание кода: у вас есть единая точка 9X_coding-guidelines выхода. Если вы хотите изменить формат результата..., это 9X_language-agnostic намного проще реализовать. Также для отладки 9X_coding-guidelines можно просто воткнуть туда точку останова 9X_spaghetti-code :)

Сказав это, мне однажды пришлось работать 9X_language-independent в библиотеке, где стандарты кодирования 9X_spaghetti-code навязывали «один оператор возврата на функцию», и 9X_coding-convention я нашел это довольно сложным. Я пишу много 9X_language-agnostic кода для числовых вычислений, и часто бывают 9X_programming-style «особые случаи», так что код оказался довольно 9X_clean-code сложным для понимания...

Несколько точек выхода подходят для достаточно 9X_code-style небольших функций, то есть функции, которую 9X_clean-code можно полностью просмотреть на одном отрезке 9X_coding-standards экрана. Если длинная функция также включает 9X_coding-style несколько точек выхода, это признак того, что 9X_coding-convention функцию можно еще больше нарезать.

При этом 9X_coding-convention я избегаю функций с несколькими выходами 9X_spaghetti-code без крайней необходимости. Я чувствовал боль от ошибок, вызванных 9X_language-independent случайным возвратом в какой-то неясной строке 9X_coding-style в более сложных функциях.

Я работал с ужасными стандартами кодирования, которые 9X_coding-style навязывали вам единственный выходной путь, и 9X_code-style результатом почти всегда были неструктурированные 9X_coding-style спагетти, если функция совсем не тривиальна 9X_clean-code — вы в конечном итоге получаете множество 9X_clean-code разрывов и продолжений, которые только мешают.

Моя обычная политика заключается в том, чтобы 9X_clean-code иметь только один оператор возврата в конце 9X_programming-style функции, если только сложность кода не будет 9X_coding-standards значительно уменьшена за счет добавления 9X_spaghetti-code большего количества операторов. На самом 9X_programming-style деле, я скорее поклонник Eiffel, который 9X_coding-guidelines применяет единственное правило возврата, не 9X_spaghetti-code имея оператора возврата (есть только автоматически 9X_coding-style созданная переменная «результат», в которую 9X_coding-style можно поместить ваш результат).

Конечно, есть 9X_clean-code случаи, когда код можно сделать более понятным 9X_coding-convention с несколькими возвратами, чем была бы очевидная 9X_language-independent версия без них. Можно возразить, что требуется 9X_programming-style дополнительная доработка, если у вас есть 9X_clean-code функция, которая слишком сложна для понимания 9X_code-style без нескольких операторов возврата, но иногда 9X_code-style полезно быть прагматичным в таких вещах.

Единая точка выхода при прочих равных условиях 9X_coding-guidelines делает код значительно более читабельным. Но 9X_language-agnostic есть загвоздка: популярная конструкция

resulttype res; if if if... return res; 

— подделка, «res=" ненамного 9X_language-independent лучше, чем «return». Он имеет один оператор 9X_programming-style возврата, но несколько точек, где функция 9X_programming-style фактически заканчивается.

Если у вас есть 9X_coding-convention функция с несколькими возвратами (или "res="s), часто 9X_language-agnostic имеет смысл разбить ее на несколько более 9X_code-style мелких функций с одной точкой выхода.

Если вы получите несколько возвратов, возможно, что-то 9X_spaghetti-code не так с вашим кодом. В противном случае 9X_clean-code я бы согласился, что иногда приятно иметь 9X_code-style возможность возврата из нескольких мест 9X_programming-style в подпрограмме, особенно когда это делает 9X_coding-convention код чище.

Perl 6: плохой пример

sub Int_to_String( Int i ){ given( i ){ when 0 { return "zero" } when 1 { return "one" } when 2 { return "two" } when 3 { return "three" } when 4 { return "four" } ... default { return undef } } } 

лучше было бы написать так

Perl 6: хороший пример

@Int_to_String = qw{ zero one two three four ... } sub Int_to_String( Int i ){ return undef if i < 0; return undef unless i < @Int_to_String.length; return @Int_to_String[i] } 

Обратите внимание, что это всего лишь быстрый пример

Я голосую за однократный возврат в конце 9X_coding-standards в качестве ориентира. Это помогает обычную очистку кода ... Например, взгляните 9X_code-style на следующий код ...

void ProcessMyFile (char *szFileName) { FILE *fp = NULL; char *pbyBuffer = NULL: do { fp = fopen (szFileName, "r"); if (NULL == fp) { break; } pbyBuffer = malloc (__SOME__SIZE___); if (NULL == pbyBuffer) { break; } /*** Do some processing with file ***/ } while (0); if (pbyBuffer) { free (pbyBuffer); } if (fp) { fclose (fp); } } 

Это, вероятно, необычная точка зрения, но 9X_coding-style я думаю, что любой, кто считает, что множественные 9X_language-agnostic операторы return предпочтительнее, никогда 9X_coding-convention не использовал отладчик на микропроцессоре, который 9X_language-independent поддерживает только 4 аппаратных точки останова. ;-)

Хотя 9X_language-agnostic проблемы с «стрелочным кодом» полностью 9X_spaghetti-code верны, одна проблема, которая, кажется, исчезает 9X_language-agnostic при использовании нескольких операторов 9X_code-style возврата, возникает в ситуации, когда вы 9X_code-style используете отладчик. У вас нет удобной 9X_spaghetti-code универсальной позиции, чтобы поставить точку 9X_coding-guidelines останова, чтобы гарантировать, что вы увидите 9X_language-agnostic выход и, следовательно, условие возврата.

Если можно записать только свое мнение, это 9X_spaghetti-code мое:

Я полностью и абсолютно не согласен 9X_coding-style с "теорией единственного оператора возврата" и 9X_coding-convention считаю ее в основном спекулятивной и даже 9X_coding-style деструктивной в отношении читабельности 9X_coding-guidelines кода, логики и описательных аспектов.

Эта 9X_language-independent привычка получать одноразовый возврат даже 9X_language-agnostic плохая для простого процедурного программирования, не 9X_coding-standards говоря уже о более высокоуровневых абстракциях 9X_coding-guidelines (функциональных, комбинаторных и т. д.). И, кроме 9X_clean-code того, я хочу, чтобы весь код, написанный 9X_coding-standards в этом стиле, прошел через специальный анализатор 9X_programming-style перезаписи, чтобы он имел несколько операторов возврата!

Функция 9X_clean-code (если это действительно функция / запрос 9X_language-agnostic в соответствии с примечанием о разделении 9X_coding-guidelines запросов и команд - см., например, язык 9X_coding-standards программирования Eiffel) просто ДОЛЖНА определять 9X_language-agnostic столько точек возврата, сколько сценариев 9X_clean-code потока управления она имеет. Это намного 9X_language-agnostic яснее и математически последовательнее; и 9X_programming-style это способ писать функции (т.е. запросы)

Но я бы 9X_coding-guidelines не стал так агрессивно относиться к сообщениям 9X_programming-style о мутации, которые получает ваш агент - вызовам 9X_coding-style процедур.

Чем больше операторов возврата в функции, тем 9X_coding-style выше сложность этого метода. Если вы обнаружите, что 9X_language-agnostic задаетесь вопросом, не слишком ли много 9X_programming-style у вас операторов возврата, вы можете спросить 9X_language-independent себя, не слишком ли много строк кода в этой 9X_code-style функции.

Но нет, нет ничего плохого в одном/многих 9X_programming-style операторах возврата. В некоторых языках 9X_programming-style это лучше (C++), чем в других (C).

Единственный важный вопрос: «Как сделать 9X_coding-standards код проще, удобнее для чтения и понимания?» Если 9X_coding-convention проще с несколькими возвратами, используйте 9X_clean-code их.

Наличие нескольких точек выхода по сути 9X_coding-style то же самое, что использование GOTO. Плохо это 9X_coding-standards или нет, зависит от того, как вы относитесь 9X_coding-convention к хищникам.

Не имеет смысла всегда требовать один тип возвращаемого 9X_coding-standards значения. Я думаю, что это скорее признак 9X_coding-style того, что что-то нужно упростить. Иногда 9X_coding-standards необходимо иметь несколько возвратов, но 9X_coding-style часто вы можете упростить ситуацию, по крайней 9X_clean-code мере, пытаясь иметь единую точку выхода.

Что ж, может быть, я один из немногих здесь, кто 9X_coding-style достаточно взрослый, чтобы вспомнить одну 9X_code-style из главных причин, по которым так сильно 9X_spaghetti-code продвигали "только одно выражение возврата". Это 9X_programming-style позволяет компилятору генерировать более 9X_clean-code эффективный код. Для каждого вызова функции 9X_language-agnostic компилятор обычно помещает в стек несколько 9X_coding-guidelines регистров, чтобы сохранить их значения. Таким 9X_coding-standards образом, функция может использовать эти 9X_language-agnostic регистры для временного хранения. Когда 9X_clean-code функция возвращается, эти сохраненные регистры 9X_coding-standards должны быть извлечены из стека и обратно 9X_code-style в регистры. Это одна инструкция POP (или 9X_coding-style MOV - (SP), Rn) на регистр. Если у вас есть 9X_language-independent несколько операторов возврата, то либо каждый 9X_code-style из них должен вытолкнуть все регистры (что 9X_code-style увеличивает размер скомпилированного кода), либо 9X_coding-convention компилятор должен отслеживать, какие регистры 9X_coding-standards могли быть изменены, и выталкивать только 9X_coding-convention их (уменьшение размера кода, но увеличивая 9X_code-style время компиляции).

Одна из причин, по которой 9X_coding-guidelines сегодня все еще имеет смысл придерживаться 9X_coding-convention одного оператора return, - это простота 9X_coding-style автоматического рефакторинга. Если ваша 9X_code-style IDE поддерживает рефакторинг извлечения 9X_programming-style методов (выбор диапазона строк и превращение 9X_coding-convention их в метод), это очень сложно сделать, если 9X_spaghetti-code строки, которые вы хотите извлечь, содержат 9X_spaghetti-code в себе оператор return, особенно если вы 9X_language-independent возвращаете значение. .

У вас уже есть несколько неявных операторов 9X_coding-convention возврата, вызванных обработкой ошибок, так 9X_coding-convention что разберитесь с этим.

Однако, как это обычно 9X_coding-style бывает в программировании, есть примеры 9X_language-independent как за, так и против практики многократного 9X_programming-style возврата. Если это делает код более понятным, сделайте 9X_code-style так или иначе. Может помочь использование 9X_coding-standards многих управляющих структур (например, оператор 9X_language-independent case).

В интересах хороших стандартов и лучших отраслевых практик мы должны установить правильное 9X_coding-style количество операторов возврата, которые 9X_language-agnostic будут отображаться во всех функциях. Очевидно, существует 9X_spaghetti-code консенсус против использования одного оператора 9X_coding-guidelines return. Поэтому я предлагаю установить его 9X_language-agnostic на два.

Я был бы признателен, если бы все 9X_coding-convention прямо сейчас просмотрели свой код, нашли 9X_coding-standards любые функции только с одной точкой выхода 9X_language-agnostic и добавили еще одну. Неважно где.

Результатом 9X_programming-style этого изменения, несомненно, станет меньше 9X_spaghetti-code ошибок, большая читабельность и невообразимое 9X_programming-style богатство, падающее с неба на наши головы.

Я предпочитаю один оператор возврата. Одна 9X_spaghetti-code из причин, на которую еще не указывалось, заключается 9X_code-style в том, что некоторые инструменты рефакторинга 9X_clean-code лучше работают для отдельных точек выхода, например 9X_language-agnostic Eclipse JDT extract / встроенный метод.

Бывают случаи, когда это необходимо по соображениям 9X_language-agnostic производительности (иногда я не хочу извлекать 9X_language-independent другую строку кэша по той же потребности, что 9X_clean-code и продолжение; иногда).

Если вы выделяете 9X_spaghetti-code ресурсы (память, дескрипторы файлов, блокировки 9X_language-agnostic и т. д.) без использования RAII, то многократные 9X_coding-style возвраты могут быть подвержены ошибкам и, безусловно, дублируют 9X_language-independent друг друга, поскольку выпуски необходимо 9X_language-independent выполнять вручную несколько раз, и вы должны 9X_coding-convention тщательно отслеживать.

В примере:

function() { HRESULT error = S_OK; if(SUCCEEDED(Operation1())) { if(SUCCEEDED(Operation2())) { if(SUCCEEDED(Operation3())) { if(SUCCEEDED(Operation4())) { } else { error = OPERATION4FAILED; } } else { error = OPERATION3FAILED; } } else { error = OPERATION2FAILED; } } else { error = OPERATION1FAILED; } return error; } 

Я бы написал 9X_spaghetti-code это так:

function() { HRESULT error = OPERATION1FAILED;//assume failure if(SUCCEEDED(Operation1())) { error = OPERATION2FAILED;//assume failure if(SUCCEEDED(Operation3())) { error = OPERATION3FAILED;//assume failure if(SUCCEEDED(Operation3())) { error = OPERATION4FAILED; //assume failure if(SUCCEEDED(Operation4())) { error = S_OK; } } } } return error; } 

Что, безусловно, кажется лучше.

Это 9X_language-agnostic особенно полезно в случае ручного выпуска 9X_clean-code ресурсов, так как где и какие выпуски необходимы, довольно 9X_programming-style просто. Как в следующем примере:

function() { HRESULT error = OPERATION1FAILED;//assume failure if(SUCCEEDED(Operation1())) { //allocate resource for op2; char* const p2 = new char[1024]; error = OPERATION2FAILED;//assume failure if(SUCCEEDED(Operation2(p2))) { //allocate resource for op3; char* const p3 = new char[1024]; error = OPERATION3FAILED;//assume failure if(SUCCEEDED(Operation3(p3))) { error = OPERATION4FAILED; //assume failure if(SUCCEEDED(Operation4(p2,p3))) { error = S_OK; } } //free resource for op3; delete [] p3; } //free resource for op2; delete [] p2; } return error; } 

Если вы 9X_language-independent пишете этот код без RAII (забыв об исключениях!) с 9X_coding-guidelines несколькими выходами, то удаления придется 9X_spaghetti-code записывать несколько раз. Если вы напишете 9X_programming-style его с помощью }else{, тогда становится немного 9X_clean-code некрасиво.

Но RAII делает спорным вопрос 9X_programming-style о множественных выходных ресурсах.

Я использую несколько точек выхода, чтобы 9X_programming-style случай ошибки + обработка + возвращаемое 9X_coding-standards значение были как можно ближе друг к другу.

Таким 9X_programming-style образом, вам нужно проверять условия a, b, c, которые 9X_coding-style должны быть истинными, и вам нужно обрабатывать 9X_programming-style каждое из них по-разному:

if (a is false) { handle this situation (eg. report, log, message, etc.) return some-err-code } if (b is false) { handle this situation return other-err-code } if (c is false) { handle this situation return yet-another-err-code } perform any action assured that a, b and c are ok. 

a, b и c могут 9X_language-agnostic быть разными вещами, например, a — проверка 9X_coding-convention входного параметра, b — проверка указателя 9X_coding-convention на вновь выделенную память, а c — проверка 9X_language-independent значения параметра «a».

Я всегда избегаю многократных операторов 9X_language-agnostic возврата. Даже в небольших функциях. Маленькие 9X_clean-code функции могут становиться больше, а отслеживание 9X_language-agnostic множественных путей возврата затрудняет 9X_language-independent (на мой маленький разум) отслеживание того, что 9X_coding-guidelines происходит. Один возврат также упрощает 9X_spaghetti-code отладку. Я видел, как люди писали, что единственной 9X_coding-convention альтернативой множественным операторам return 9X_code-style является беспорядочная стрелка вложенных 9X_coding-guidelines операторов IF на глубину 10 уровней. Хотя 9X_language-agnostic я уверен, что такое кодирование действительно 9X_spaghetti-code происходит, это не единственный вариант. Я 9X_spaghetti-code бы не стал выбирать между несколькими операторами 9X_coding-guidelines возврата и множеством IF, я бы реорганизовал 9X_clean-code его, чтобы вы исключили оба. Вот как я кодирую. Следующий 9X_language-agnostic код устраняет обе проблемы и, на мой взгляд, очень 9X_spaghetti-code легко читается:

public string GetResult() { string rv = null; bool okay = false; okay = PerformTest(1); if (okay) { okay = PerformTest(2); } if (okay) { okay = PerformTest(3); } if (okay) { okay = PerformTest(4); }; if (okay) { okay = PerformTest(5); } if (okay) { rv = "All Tests Passed"; } return rv; }