Является ли хорошей практикой называть возвращаемую переменную «результатом»? [закрыто]

Является ли хорошей практикой вызывать переменную, возвращаемую методом с именем переменной result?

Например:

public Zorglub calculate() {
    Zorglub result = [...]
    [...]
    return result;
}

Или я должен назвать его по типу?

public Zorglub calculate() {
    Zorglub zorglub = [...]
    [...]
    return zorglub;
}

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

Я в основном думаю о Java.

Если это переменная метода, это действительно зависит от читабельности.

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

Перекрестное чтение облегчается, если переменная названа result. Это проясняет ваше намерение.

Если мне нужна возвращаемая переменная (что на самом деле происходит редко), я всегда вызываю ее retи всегда определяю ее прямо под заголовком функции. У функции уже есть имя, которое говорит о том, что она возвращает.

Если бы myFunctionя мог, я мог бы назвать его возвращаемую переменную, myFunctionReturnValueчтобы сказать точно то же самое, только я должен был бы сказать это явно каждый раз. Поскольку функции обычно должны быть короткими, такой явности не требуется. И даже если я потеряю след, я могу перейти к объявлению и попаду прямо под определение функции.

Но любое другое имя, которое неявно (как retили result) или явно (как myFunctionReturnValueили myFunctionResult) не указывает, что текущая переменная возврата функции является слишком общим.

В вашем втором примере zorglubэто ужасный выбор. Все объявления действительно говорят мне, что вы создали переменную, имя которой равно аннотации типа, найденной прямо рядом с именем. Это так же полезно, как int someIntили Zorglub z.

В вашем первом примере, когда я смотрю на код, я сначала вижу имя функции, которая говорит мне, что эта функция вычисляет a Zorglub. Когда я читаю вторую строку, я вижу: «Хорошо, вот zorglub, который будет возвращен, но он, очевидно, не может быть возвращен сразу и, следовательно, хранится в resultпеременной» (как примечание: если вы не собираясь переназначать значение, тогда лучше всего объявить переменную final, чтобы сообщить об этом), а затем я подумаю «так что теперь давайте посмотрим, что произойдет с ним, прежде чем оно будет возвращено». В отличие от первого примера, мне не нужно читать дальше, чтобы узнать, что это переменная, которая будет возвращена и что я хочу следовать в теле функции, если я хочу ее понять.

Возможно, вы захотите прочитать о спартанском программировании , которое скорее связано с вашим вопросом.

Во втором примере вы связываете тип результата с тем, что он есть .

Zorglub zorglub;

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

double variance;

например, дает мне представление о том, что означает возвращаемое значение , с точки зрения семантики программы. Это может быть или не быть более понятным, чем просто вызов его result, в зависимости от размера метода - это вызов для каждого метода IMO.

Если вы играете со многими объектами Zorglub в своих методах, вы «можете» ошибиться и вернуть неправильный, или / и у вас может возникнуть соблазн назвать другие zorglub1, zorglub2и т. Д.

Если вы назовете это result, у вас нет шансов совершить такую ​​ошибку. Кроме того, я считаю, что это хорошее имя; Я также видел returnedValueили returnedObjectнесколько раз, это также ясно, хотя и немного долго.

Лично мне не совсем удобно использовать resultв качестве имени переменной. Справедливо, это говорит мне о том, что соответствующее значение является результатом некоторых вычислений - однако, я предполагаю, что это верно для (или более) 90% переменных / полей, используемых в программе.

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

Поэтому я предпочитаю, чтобы мои методы были короткими и чистыми, и называли мои переменные, чтобы выразить значение значения, которое они содержат, а не его локальную роль внутри метода включения. Однако (например, в устаревшем коде), Zorglub resultбезусловно, легче понять, чем Zorglub zorglub.

Я лично использую имя resultдля значения, которое будет возвращено из функции / метода. Это делает явным, что это возвращаемое значение. Называть его по типу не представляется полезным, поскольку может быть несколько переменных одного и того же типа.

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

«Результат» или «зорглуб».

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

я должен назвать это его типом?

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

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

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

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

Мне нравится комбинировать их, показывает, что это такое и что оно должно быть возвращено.

так что в вашем примере это будет результат Zorglub

если то, что это на самом деле не имеет значения, то это будет просто результат (не resultString)

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

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

Когда я работал в C ++, и я думаю, что это применимо к Java, я это делал.

например

int Width() const
{
    Requires(....);
    Requires(....);

    //calculation

    Ensures(...);
    Ensures(...);
    return Result;
}

Это проектирование по контракту, так как блок обеспечения должен быть в конце метода. Но возвращение должно быть последним. У нас было правило, что return Result был единственным, что могло следовать за блоком обеспечения.

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

def removeOccurence [A] (slice: Seq[A], original: Seq[A]) = {
  @scala.annotation.tailrec
  def remove (leftOriginal: Seq[A], result: Seq[A]) : Seq[A] =
    trimStart (slice, leftOriginal) match {
      case (h :: tail) => remove (tail, h +: result)
      case (Nil)       => result.reverse
    }
    remove (original, Nil)
}

Но чаще я использую «carry» и «sofar», которые я видел в дикой природе и которые в большинстве случаев несут идею еще лучше.

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

Третья причина уже была изложена, но у меня есть небольшое отклонение: вы пишете метод, который выполняет какую-то работу, скажем, он оценивает форму '' max ''.

def max = {
  val result = somethingElseToDo
  if (foo) result else default 
}

Вместо того, чтобы вызывать результат '' result '', мы можем назвать его '' max '', но в некоторых языках вы можете опустить круглые скобки при вызове метода, поэтому max будет рекурсивным вызовом самого метода.

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

В Object Pascal это не выбор. Вы должны присвоить значение Resultпеременной где-то в коде функции.

Пример:

function AddIntegers( A,B: Integer): Integer;
begin
  Result := A + B; 
end; 

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

Конечно, если это очень простое выражение в языке, производном от C, я не стану объявлять переменную результата - возвращая выражение напрямую.

дело не только в том, что вы называете результатом (я имею в виду «r»), но и в том, как его использовать. например, если вы собираетесь иметь возвращаемую переменную, то каждый оператор return должен возвращать ее. не иметь «вернуть г;» в конце, но разбросайте такие вещи, как 'return m * x + b; "во всем методе / функции. use" r = m * x + b; вернуть г; "вместо.

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