Java стандарт кодирования / лучшие практики-соглашение об именовании для меток break / continue

Я не понимаю, откуда взялось это правило "don't use labels". При выполнении нетривиальной циклической логики тест на разрыв или продолжение не всегда аккуратно находится в конце окружающего блока.

outer_loop:
for (...) {
  //  some code
  for (...) {
    //  some code
    if (...)
      continue outer_loop;
    //  more code
  }
  //  more code
}

Да, такие случаи случаются постоянно. Что люди предлагают мне использовать вместо этого? Логическое условие вроде этого?

for (...) {
  //  some code
  boolean continueOuterLoop = false;
  for (...) {
    //  some code
    if (...) {
      continueOuterLoop = true;
      break;
    }
    //  more code
  }
  if (continueOuterLoop)
    continue;
  //  more code
}

Фу! Рефакторинг его как метода также не облегчает этого:

boolean innerLoop (...) {
  for (...) {
    //  some code
    if (...) {
      return true;
    }
    //  more code
  }
  return false;
}

for (...) {
  //  some code
  if (innerLoop(...))
    continue;
  //  more code
}

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

Так почему же вы все против ярлыков? Приведите мне некоторые веские доводы и практические Альтернативы для приведенного выше случая.

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

Конвенция заключается в том, чтобы полностью избегать ярлыков.

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

for ( ;/*stuff*/; ) 
{
    lotsOfCode();

    if ( !isEnough() )
    {
        moreCode();
    }
}

Edit: увидев фактический код, о котором идет речь ( здесь), я думаю, что использование меток, вероятно, лучший способ сделать код читаемым. В большинстве случаев использование ярлыков является неправильным подходом, в данном случае, я думаю, что это нормально.

Стиль кода Sun Java, по-видимому, предпочитает именовать метки так же, как переменные, то есть регистр верблюда с первой буквой в нижнем регистре.

Соглашение, которое я больше всего видел, - это просто случай верблюда, как имя метода...

myLabel:

но я также видел этикетки с префиксом подчеркивания

_myLabel:

или с лабораторией...

labSomething:

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

Поскольку ярлыки так редко бывают полезны, оказывается, что нет четкого соглашения. Спецификация языка Java имеет один пример с метками, и они находятся в non_cap.

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

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

пример кода wrt Сэди :

Ты отдал

outerloop:
for (...) {
  //  some code
  for (...) {
    //  some code
    if (...)
      continue outerloop;
    //  more code
  }
  //  more code
}

В качестве примера. Вы делаете хороший вывод. Мое лучшее предположение было бы:

public void lookMumNoLabels() {
  for (...) {
    // some code
    doMoreInnerCodeLogic(...);
  }
}

private void doMoreInnerCodeLogic(...) {
   for (...) {
      // some code
      if (...) return;
   }
}

Но были бы примеры, когда такой вид рефакторинга не соответствует правильной логике, которую вы делаете.

Convetion/best practice все равно будет не использовать их вообще и рефакторировать код так, чтобы он был более читабельным, используя метод extract as.

Они своего рода Гото из Java - не уверен, есть ли они у C#. Я никогда не использовал их на практике, я не могу придумать случая, когда их избегание не привело бы к гораздо более удобочитаемому коду.

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

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

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

МО, твое предположение неверно. Вопрос не должен быть таким: "как мне их форматировать?'

Ваш вопрос должен быть таким: "у меня есть код, который имеет большое количество логики внутри циклов - как я могу сделать его более читаемым?'

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