Который является лучшей практикой - для цикла с повреждением или условного цикла?

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

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

, Но я подписываюсь на не, заставляют меня думать модель о кодировании.

Моя общая позиция:

, Если это имеет использование счетчика цикла для () (как то, в то время как цикл с условием продолжения делает).

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

Некоторый пример код C#:

class Program
{
   static bool IsBaxterInMilwaukee(IList<WhoAndWhere> peopleAndPlaces)
   {
      foreach (WhoAndWhere personAndPlace in peopleAndPlaces)
      {
         if (personAndPlace.Name == "Baxter" 
            && personAndPlace.Location == "Milwaukee")
         {
            return true;
         }
      }
      return false;
   }

   static void Main(string[] args)
   {
      List<WhoAndWhere> somePeopleAndPlaces = new List<WhoAndWhere>();
      somePeopleAndPlaces.Add(new WhoAndWhere("Fred", "Vancouver"));
      somePeopleAndPlaces.Add(new WhoAndWhere("Baxter", "Milwaukee"));
      somePeopleAndPlaces.Add(new WhoAndWhere("George", "London"));

      if (IsBaxterInMilwaukee(somePeopleAndPlaces))
      {
         // BarkTwice()
         Console.WriteLine("Bark twice");
      }
   }

   public class WhoAndWhere
   {
      public WhoAndWhere(string name, string location)
      {
         this.Name = name;
         this.Location = location;
      }

      public string Name { get; private set; }
      public string Location { get; private set; }
   }

}

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

В JS:

if(myArray.some(function(o) { o.name == "baxter" && o.location == "milwaukee" }))
  barkTwice();

или с некоторым utils Вашего собственного

if(myArray.containsMatch({name:"baxter",location:"milwaukee"})
  barkTwice();

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

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

И хорошо иметь все, что необходимо знать (grokwise) о правилах циклов в одной строке наверху "для" цикла. Я также склонен помещать переключатель "по умолчанию" сначала в тесты по той же причине.

, Но непротиворечивость и ясность ovveriding соображение. YMMV, конечно.

У меня есть фон C++ и таким образом, у меня все еще есть моменты, где я пытаюсь "думать как компилятор". Циклы с условием продолжения имеют тенденцию приводить к более трудному коду, и таким образом, для циклов только когда-либо рассматривались, если Вы знали, что собирались выполнить итерации по каждому элементу в массиве, каждый раз.

РЕДАКТИРОВАНИЕ: Я теперь полагаю, что это - излишество при использовании .NET или независимо от того, что Вы не собираетесь восполнять VM наверху с несколькими жесткими циклами. Я действительно думаю, помня, "почему" из определенных методов хорошая вещь все же.

Существует два аспекта проблемы:

• , Что , чтобы сделать (например: найдите, содержит ли один из объектов указанного человека в месте)
• Как , чтобы сделать это (например: используйте индекс, выполните итерации и т.д.)

, Оба из примеров смешивают два, и твердо понять что от как . Лучшее было бы то, если мы могли бы выразить в коде только что часть. Вот пример (c# 3.5), который делает это использование , шаблон спецификации

// what we are looking for?
IsPersonInLocation condition = new IsPersonInLocation("baxter", "milwaukee");

// does the array contain what we are looking for?
bool found = myArray.Find(item => condition.IsSatifiedBy(item));

// do something if the condition is satisfied
if (found) {
    barkTwice();
}

Для полноты вот является определением класса для условия:

class IsPersonInLocation {
    public string Person { get; set; }
    public string Location { get; set; }
    public IsPersonInLocation(string person, string location) {
        this.Person = person;
        this.Location = location;
    }
    bool IsSatifiedBy(item) {
        return item["name"] == this.Person
            && item["location"] == this.Location;
    }
}

Это во многом зависит от того, каковы определенные обстоятельства. Но в Вашем примере, Вы хотите обойти массив ограниченной длины, и использование для цикла помогает сделать это и принять меры против убегания конца. В Вашем примере цикла с условием продолжения необходимо сделать собственное постепенное увеличение - который может быть проблематичным, если Вы хотели использовать continue оператор, чтобы пропустить в следующий цикл - и сделать более сложное условное выражение (который, между прочим, имеет ошибку; я думаю, что Вы имели в виду && i != arrayLen). Необходимо просто сделать дополнительный код для выполнения эффекта, которые для циклов помогают обеспечить.

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

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

Я сказал бы, что повреждение, более ясное (даже если Вы вставляете комментарий, почему Вы убегаете из цикла), по моему скромному мнению, цикл с условием продолжения не ясен, я пошел бы для повреждения

повреждение считают "структурированным goto" и нужно использовать экономно. Используйте его, если это - меньшее из зла.

Избегают , продолжаются еще больше.

Редактирование: Так как я получил довольно много комментариев и некоторый downvotes, я добавлю некоторые ссылки поддержки

стандарт кодирования C/C++ А

И более слабый оператор для Java (см..52)

Я вижу перерыв в обоих циклах, который корректен?

Так или иначе:

• я выбрал бы цикл FOR, когда существует известное число (максимальное количество) повторений, прежде чем цикл запустится.
• я выбрал бы WHILE иначе.
• В ДЛЯ цикла я использую ПОВРЕЖДЕНИЕ свободно.
• В Цикле с условием продолжения я предпочитаю использовать сложное условие вместо ПОВРЕЖДЕНИЯ (если это возможно).

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

, Вероятно, лучшей вещью, которую Вы хотите здесь, является модификация Вашего while цикл:

while(!isBaxterInMilwaukee || i < arrayLen) {
  if(myArray[i]["name"] == "baxter" && myArray[i]["location"] == "milwaukee") {
    isBaxterInMilwaukee == true;
    barkTwice()
  } else {
    i++;
  }
}

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

ETA: Вероятно, должен быть i < arrayLen в while цикл иначе, он перестал работать в первый раз через, если входное значение не совпадает с целевым значением...

Существует концептуальное различие между двумя. for циклы для итерации по дискретным наборам и while, циклы для повторения операторов на основе условия. Другие языки добавляют в finally пункты и конструкции цикличного выполнения как foreach или until. Они имеют тенденцию иметь значительно меньше традиционное for циклы.

В любом случае, правило, что я использую, состоит в том, что for циклы выполняют итерации и while повторение циклов. Если Вы видите что-то как:

while (counter <= end) {
   // do really cool stuff
   ++counter;
}

Тогда Вы, вероятно, более обеспечены с for цикл, так как Вы выполняете итерации. Однако циклы как:

for (int tryCount=0; tryCount<2; ++tryCount) {
    if (someOperation() == SUCCESS) {
       break;
    }
}

должен быть записан как [1 111] циклы, так как они действительно повторяют что-то, пока условие не верно.

мысль, не используя break, так как это столь же злое как goto , довольно бессмысленна. Как можно выровнять по ширине выдачу исключения тогда? Это - просто нелокальный и недетерминированный goto! Между прочим, это не напыщенная речь против обработки исключений, просто наблюдения.

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

var i:int;

var isBaxterInMilwaukee:Boolean;    

isBaxterInMilwaukee = false;

for (i = 0; i < arrayLen && !isBaxterInMilwaukee; i++)
{
    if (myArray[i]["name"] == "baxter"
        && myArray[i]["location"] == "milwaukee")
    {
        isBaxterInMilwaukee = true;

        barkTwice();
    }
}

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

Я сказал бы, что это зависит. В этом случае цикл с повреждением кажется более ясным мне.

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

Эта проблема была бы подобна наличию return операторы, которые глубоки в теле метода, где они легко не определяются (а не переменная установки a retVal и возвращающийся в конце метода). С маленьким методом это кажется прекрасным, но чем больше это становится, тем более сбивающее с толку это будет.

Это не эффективность операционной вещи, это - вещь пригодности для обслуживания.

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

Я определенно пошел бы с for+break. ‘for’ является немедленно опознаваемой идиомой для “iterate по sequence”, и легче понять “iterate по последовательности; закончите рано если значение found”, чем объединенное условие цикла-и-остановки.

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

• , в то время как условие (! isBaxterInMilwaukee || я == arrayLen),  —  did Вы означают “ (! (isBaxterInMilwaukee || я == arrayLen)) ”?

• оператор завершения является ненужным при использовании оконечной переменной цикла.

Лично я нахожу, что простое ‘break’ намного более легкое читает, чем попытка отследить оконечную переменную цикла.