Стандарт кодирования Java / лучшие практики - соглашение об именах для меток прерывания / продолжения

Иногда помеченные прерывания или продолжения могут сделать код более читаемым.

OUTERLOOP: for ( ;/*stuff*/; ) {
    //...lots of code

    if ( isEnough() ) break OUTERLOOP;
    //...more code
}

Мне было интересно, каковы были общие правила для этикеток. Все заглавные буквы? первая шапка?

Ответов (10)

Решение

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

Согласие / лучшая практика по-прежнему заключалась бы в том, чтобы не использовать их вообще и реорганизовать код, чтобы он был более читабельным с использованием метода extract as.

Соглашение заключается в том, чтобы вообще избегать ярлыков.

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

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

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

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

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;
   }
}

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

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

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

Мо, твоя посылка неверна. Вопрос не должен быть в том, «как мне их отформатировать?»

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

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

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

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

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

myLabel:

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

_myLabel:

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

labSomething:

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

Я не понимаю, откуда взялось это правило «не использовать ярлыки». При выполнении нетривиальной логики цикла тест на прерывание или продолжение не всегда аккуратно заканчивается в конце окружающего блока.

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
}

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

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

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

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

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

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