Должен ли я переместить условие разрыва в поле условия, если это возможно, внутри цикла for? [закрыто]

Иногда мне нужны циклы, которые нуждаются в перерыве:

for(int i=0;i<array.length;i++){
    //some other code
    if(condition){
        break;
    }
}

Мне неудобно писать

if(condition){
    break;
}

потому что он потребляет 3 строки кода. И я обнаружил, что цикл можно переписать так:

                                   ↓
for(int i=0;i<array.length && !condition;i++){
    //some other code
}

Поэтому мой вопрос заключается в том, является ли хорошей практикой перемещение условия в поле условия, чтобы уменьшить количество строк кода, если это возможно?

Те два примера, которые вы привели, не являются функционально эквивалентными. В оригинале тест условия выполняется после раздела «некоторый другой код», тогда как в модифицированной версии он выполняется первым в начале тела цикла.

Код никогда не должен быть переписан с единственной целью уменьшения количества строк. Очевидно, это хороший бонус, когда он работает таким образом, но это никогда не должно делаться за счет читабельности или правильности.

Я не покупаю аргумент, что «он потребляет 3 строки кода» и, следовательно, это плохо. В конце концов, вы можете написать это так:

if (condition) break;

и просто потреблять одну строку.

Если он ifпоявляется в середине цикла, он, конечно, должен существовать как отдельный тест. Однако, если этот тест появляется в конце блока, вы создали цикл, который имеет тест продолжения на обоих концах цикла, возможно, добавляя сложности к коду. Имейте в виду, что иногда if (condition)проверка может иметь смысл только после выполнения блока.

Но предположим, что это не так, приняв другой подход:

for(int i=0;i<array.length && !condition;i++){
    //some other code
}

условия выхода сохраняются вместе, что может упростить вещи (особенно, если « какой-то другой код » длинный).

Там нет правильного ответа здесь, конечно. Так что помните об идиомах языка, о правилах кодирования вашей команды и т. Д. Но в целом, я бы выбрал подход единого теста, когда это имеет функциональный смысл.

Этот вопрос вызвал споры почти столько же времени, сколько программирование. Чтобы бросить свою шляпу в кольцо, я бы выбрал версию с breakусловием и вот почему (для этого конкретного случая):

forПетля просто есть указание перебора значений в цикле. Кодирование нарушающего условия внутри этого просто портит логику ИМО.

Наличие отдельного breakэлемента делает кристально ясным, что во время обычной обработки значения являются такими, как указано в forцикле, и обработка должна продолжаться, за исключением случаев, когда возникает условие.

В качестве предыстории я начал с кодирования a break, затем поместил условие в forцикл на годы (под руководством исключительного программиста), а затем вернулся к breakстилю, потому что он казался намного чище (и был преобладающим стилем в различные кодовые тома, которые я потреблял).

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

forЦиклы предназначены для итерации по чему-то ¹ - они не просто заголовки, которые можно найти в заголовке - три выражения имеют очень конкретные значения:

• Первый предназначен для инициализации итератора . Это может быть индекс, указатель, объект итерации или что-то еще - при условии, что он используется для итерации .
• Второй - для проверки, достигли ли мы конца.
• Третий - для продвижения итератора.

Идея состоит в том, чтобы отделить обработку итераций ( как выполнять итерацию) от логики внутри цикла ( что делать в каждой итерации). Во многих языках обычно есть цикл for-each, который освобождает вас от деталей итерации, но даже если ваш язык не имеет такой конструкции или если ее нельзя использовать в вашем сценарии - вы все равно должны ограничить заголовок цикла к итерационной обработке.

Итак, вы должны спросить себя - ваше условие об обработке итерации или о логике внутри цикла? Скорее всего, речь идет о логике внутри цикла, поэтому ее следует проверять внутри цикла, а не в заголовке.

¹ В отличие от других циклов, которые «ждут», чтобы что-то произошло. Цикл for/ foreachдолжен иметь концепцию «списка» элементов для итерации, даже если этот список ленивый, бесконечный или абстрактный.

Я рекомендую использовать версию с if (condition). Это более читабельно и легче для отладки. Написание 3 дополнительных строк кода не сломает ваши пальцы, но поможет следующему человеку понять ваш код.

Если вы перебираете коллекцию, в которой некоторые элементы должны быть пропущены, я рекомендую новую опцию:

• Отфильтруйте свою коллекцию перед итерацией

И Java, и C # делают это относительно тривиально. Я не удивлюсь, если бы в C ++ был способ создать причудливый итератор, чтобы пропустить некоторые неприменимые элементы. Но на самом деле это вариант, только если ваш язык поддерживает его, и причина, по которой вы используете его, breakзаключается в том, что существуют условия того, обрабатываете ли вы элемент или нет.

В противном случае есть очень веская причина сделать ваше условие частью цикла for - при условии, что его первоначальная оценка верна.

• Легче увидеть, когда цикл заканчивается рано

Я работал над кодом, где ваш цикл for занимает несколько сотен строк с несколькими условными выражениями и сложной математической схемой. Проблемы, с которыми вы сталкиваетесь при этом:

• break команды, похороненные в логике, трудно найти, а иногда и удивляют
• Отладка требует прохождения каждой итерации цикла, чтобы действительно понять, что происходит
• Большая часть кода не имеет легко обратимых рефакторингов или модульных тестов, чтобы помочь с функциональной эквивалентностью после переписывания

В этой ситуации я рекомендую следующие рекомендации в порядке предпочтения:

• Фильтр сбора для устранения необходимости применения , breakесли это возможно
• Сделайте условной частью условия цикла for
• Разместите условные обозначения breakв верхней части цикла, если это возможно
• Добавьте многострочный комментарий, чтобы обратить внимание на разрыв и почему он там есть.

Эти рекомендации всегда зависят от правильности вашего кода. Выберите вариант, который наилучшим образом отражает намерения и улучшит ясность вашего кода.

Я настоятельно рекомендую придерживаться подхода наименьшего удивления, если вы не получите значительную выгоду, поступая иначе.

Люди не читают каждую букву при чтении слова, и они не читают каждое слово при чтении книги - если они умеют читать, они смотрят на контуры слов и предложений и позволяют своему мозгу заполнить остальные ,

Так что, скорее всего, случайный разработчик предположит, что это просто стандарт для цикла и даже не смотрит на него:

for(int i=0;i<array.length&&!condition;i++)

Если вы хотите использовать этот стиль независимо, я рекомендую изменить части, for(int i=0;i<и ;i++)это скажет читателю, что это стандарт для цикла.

Еще одна причина, по которой стоит пойти if- breakэто то, что вы не всегда можете использовать свой подход с forусловием. Вы должны использовать if- breakкогда условие прерывания слишком сложное, чтобы его можно было скрыть внутри forоператора, или полагается на переменные, которые доступны только внутри forцикла.

for(int i=0;i<array.length&&!((someWidth.X==17 && y < someWidth.x/2) || (y == someWidth.x/2 && someWidth.x == 18);i++)

Так что, если вы решите пойти с if- break, вы прикрыты. Но если вы решили использовать for-условия, вы должны использовать сочетание if- breakи for-условий. Чтобы быть последовательным, вам придется перемещать условия назад и вперед между for-условиями и if- breakвсякий раз, когда условия меняются.

Ваше преобразование предполагает, что все, что conditionоценивается, trueпри входе в цикл. Мы не можем комментировать правильность этого в этом случае, потому что это не определено.

Добившись успеха в «сокращении строк кода» здесь, вы можете перейти к

for(int i=0;i<array.length;i++){
    // some other code
    if(condition){
        break;
    }
    // further code
}

и применить то же преобразование, достигнув

for(int i=0;i<array.length && !condition;i++){
    // some other code
    // further code
}

Что является недопустимым преобразованием, как вы сейчас безоговорочно делаете, further codeгде раньше не делали.

Гораздо более безопасная схема преобразования заключается в извлечении some other codeи оценке conditionотдельной функции.

bool evaluate_condition(int i) // This is an horrible name, but I have no context to improve it
{
     // some other code
     return condition;
}

for(int i=0;i<array.length && !evaluate_condition(i);i++){
    // further code
}

TL; DR. Делай то, что лучше всего в твоих конкретных обстоятельствах.

Давайте возьмем этот пример:

for ( int i = 1; i < array.length; i++ ) 
{
    if(something) break;
    // perform operations
}

В этом случае мы не хотим, чтобы какой-либо код в цикле for выполнялся, если он somethingравен true, поэтому перенос теста somethingв поле условия является разумным.

for ( int i = 1; i < array.length && !something; i++ )

Опять же, в зависимости от того, somethingможно ли установить значение trueперед циклом, но не внутри него, это может дать больше ясности:

if(!something)
{
    for ( int i = 1; i < array.length; i++ )
    {...}
}

Теперь представьте это:

for ( int i = 1; i < array.length; i++ ) 
{
    // perform operations
    if(something) break;
    // perform more operations
}

Мы посылаем очень четкое сообщение там. Если somethingво время обработки массива становится истинным, то на этом этапе откажитесь от всей операции. Чтобы переместить чек в поле условия, необходимо сделать:

for ( int i = 1; i < array.length && !something; i++ ) 
{
    // perform operations
    if(!something)
    {
        // perform more operations
    }
}

Возможно, «сообщение» стало мутным, и мы проверяем состояние отказа в двух местах - что, если состояние отказа меняется, и мы забываем одно из этих мест?

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

Напишите код так, чтобы он читался хорошо (это, очевидно, несколько субъективно) и кратко. За пределами драконовского набора правил кодирования все «правила» имеют исключения. Напишите, что, по вашему мнению, лучше всего отражает принятие решения, и сведите к минимуму вероятность ошибок в будущем.

Хотя это может быть привлекательным, потому что вы видите все условия в заголовке цикла и breakможете сбивать с толку внутри больших блоков, forцикл - это шаблон, в котором большинство программистов ожидают циклы в некотором диапазоне.

Тем более что добавление дополнительного условия прерывания может привести к путанице, и будет сложнее увидеть, является ли оно функционально эквивалентным.

Часто хорошей альтернативой является использование цикла whileили, do {} whileкоторый проверяет оба условия, предполагая, что в вашем массиве есть хотя бы один элемент.

int i=0
do {
    // some other code
    i++; 
} while(i < array.length && condition);

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

Это плохо, так как код предназначен для чтения людьми - неидиоматические forциклы часто сбивают с толку, что означает, что ошибки, скорее всего, скрываются здесь, но исходный код, возможно, можно было улучшить, сохранив его и то и другое. коротко и читабельно.

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

array.find(item -> item.valid)

Это должно заметно сократить время решения и упростить его, поскольку ваш код говорит именно то, что вам нужно.

Несколько причин, по моему мнению, говорит, что вы не должны.

1. Это снижает удобочитаемость.
   
2. Вывод может не совпадать. Однако это можно сделать с помощью do...whileцикла (не while), поскольку условие проверяется после выполнения некоторого кода.
   

Но вдобавок ко всему, рассмотрим это,

for(int i=0;i<array.length;i++){

    // Some other code
    if(condition1){
        break;
    }

    // Some more code
    if(condition1){
        break;
    }

    // Some even more code
}

Теперь, вы действительно можете достичь этого, добавив эти условия в это forусловие?

Я думаю, что удаление breakможет быть хорошей идеей, но не для сохранения строк кода.

Преимущество написания без него breakсостоит в том, что пост-условие цикла является очевидным и явным. Когда вы закончите цикл и выполните следующую строку программы, ваше условие цикла i < array.length && !conditionдолжно быть ложным. Следовательно, либо iбыл больше или равен длине вашего массива, либо conditionимеет значение true.

В версии с breakесть скрытая ошибка. Условие цикла говорит о том, что цикл завершается, когда вы запускаете какой-то другой код для каждого действительного индекса массива, но на самом деле существует breakоператор, который может завершить цикл до этого, и вы не увидите его, пока не просмотрите код цикла очень осторожно. А у автоматических статических анализаторов, в том числе оптимизирующих компиляторов, могут возникнуть проблемы с определением того, каковы пост-условия цикла.

Это было первоначальной причиной, по которой Эдгар Дейкстра написал «Goto считает опасным». Это не было вопросом стиля: нарушение цикла затрудняет формальное рассуждение о состоянии программы. Я написал множество break;утверждений в своей жизни, и однажды, будучи взрослым, я даже написал goto(чтобы разорвать несколько уровней критичного к производительности внутреннего цикла и затем перейти к другой ветви дерева поиска). Тем не менее, у меня гораздо больше шансов написать условный returnоператор из цикла (который никогда не запускает код после цикла и, следовательно, не может испортить его постусловия), чем a break.

постскриптум

На самом деле, для рефакторинга кода с тем же поведением может потребоваться больше строк кода. Ваш рефакторинг может быть действительным для какого-то другого кода или если мы сможем доказать, что он conditionбудет начинаться с false. Но ваш пример в общем случае эквивалентен:

if ( array.length > 0 ) {
  // Some other code.
}
for ( int i = 1; i < array.length && !condition; i++ ) {
  // Some other code.
}

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

Я признаю, что это был не основной вопрос вашего вопроса, и вы держали его в простоте.

Да, но ваш синтаксис нетрадиционен и, следовательно, плох (тм)

Надеюсь, ваш язык поддерживает что-то вроде

while(condition) //condition being a condition which if true you want to continue looping
{
    do thing; //your conditionally executed code goes here
    i++; //you can use a counter if you want to reference array items in order of index
}

Если вы обеспокоены тем, что слишком сложное forутверждение трудно прочитать, это определенно является серьезной проблемой. Потеря вертикального пространства также является проблемой (хотя и менее критичной).

(Лично мне не нравится правило, что ifоператоры должны всегда иметь фигурные скобки, что в значительной степени является причиной потери вертикального пространства здесь. Обратите внимание, что проблема заключается в потере вертикального пространства. Использование вертикального пространства со значимыми линиями не должно быть проблемой.)

Один из вариантов - разделить его на несколько строк. Это определенно то, что вам следует делать, если вы используете действительно сложные forоператоры с несколькими переменными и условиями. (Это лучше для меня использовать вертикальное пространство, давая как можно больше строк чего-то значимого.)

for (
   int i = 0, j = 0;
   i < array.length && !condition;
   i++, j++
) {
   // stuff
}

Лучшим подходом может быть попытка использовать более декларативную и менее императивную форму. Это будет зависеть от языка, или вам может потребоваться написать свои собственные функции, чтобы включить такого рода вещи. Это также зависит от того, что на conditionсамом деле. Предположительно он должен быть в состоянии изменить как-то, в зависимости от того, что находится в массиве.

array
.takeWhile(condition)  // condition can be item => bool or (item, index) => bool
.forEach(doSomething); // doSomething can be item => void or (item, index) => void

Одна вещь, которая была забыта: когда я вырываюсь из цикла (не делаю все возможные итерации, независимо от того, как он реализован), обычно бывает так, что я не только хочу выйти из цикла, я также хочу знать, почему это произошло , Например, если я ищу элемент X, я не только вырываюсь из цикла, я также хочу знать, что X был найден и где он находится.

В этой ситуации наличие условия вне цикла вполне естественно. Итак, я начинаю с

bool found = false;
size_t foundIndex;

и в цикле я напишу

if (condition) {
    found = true;
    foundIndex = i;
    break;
}

с петлей для

for (i = 0; i < something && ! found; ++i)

Теперь проверка условия в цикле вполне закономерна. Наличие оператора "break" зависит от того, есть ли дальнейшая обработка в цикле, которую вы хотите избежать. Если какая-то обработка необходима, а другая нет, у вас может быть что-то вроде

if (! found) { ... }

где-то в вашей петле.