Названня: Чи варто жертвувати стислістю для ясності?

Наприклад, наступна функція проходить через масив, який містить ім'я та помилки поля введення. Це робиться, перевіряючи ім'я поля, що підтверджує, а потім натискаючи інформацію про помилку до масиву недійсних полів.

Чи краще бути коротким і написати це:

addInvalidField (field, message) {
  const foundField = this.invalidFields.find(value => {
    return value.name === field.name
  })
  const errors = foundField.errors
  if (!errors.some(error => error.name === message)) {
    errors.push({ name: message, message })
  }
},

Або бути більш конкретним, як це?

addInvalidField (validatingField, message) {
  const foundField = this.invalidFields.find(invalidField => {
    return validatingField.name === invalidField.name
  })
  if (!foundField.errors.some(foundFieldError => foundFieldError.name === message)) {
    fouldField.errors.push({ name: message, message })
  }
},

Якщо стислість може бути принесена в жертву заради ясності, вона повинна. Але якщо багатослівність можна принести в жертву для ясності, ще краще.

addInvalidField (field, message) {
  const foundInvalidField = this.invalidFields.find(x => x.name === field.name)
  if (!foundInvalidField.errors.some(x => x.name === message)) {
    foundInvalidField.errors.push({ name: message, message })
  }
},

Коли змінна живе лише до тих пір, як один рядок, вона може бути дуже короткою. FoundInvalidFieldвикористовується в трьох рядках і є основою цієї роботи. Це заслуговує пояснювальної назви.

Як завжди, контекст - король.

Я фактично прихильний ваш перший приклад коду.

Чітко видно, що робить код, просто читаючи його. Зберігаючи назви змінних якомога менше, ви зробите код ще простішим для читання. Більш описові назви змінних знадобляться лише в тому випадку, якщо ваші функції будуть довші, ваші змінні були більш численні та / або використовували змінну (и) у більшій області коду.

Це тому, що ви зберегли свої функції короткими, що ви також можете тримати свої імена змінних короткими. За інших рівних умов менше код завжди краще.

Я думаю, що я згоден з дядьком Бобом про те, щоб віддавати перевагу ясності, не маючи зайвої багатослівності . У показаних вами прикладах я б сказав, що наміри другого є більш чіткими, не зазнаючи зайвої багатослівності . Крім того, було б простіше знайти саме той фрагмент при пошуку, хоча за базою коду, invalidFieldніж для value.

Ну я цитую тут чистий код (пропустіть його, якщо вам набридло проповідь дядька Боба (чого я ні):

Використовуйте назви розкриття намірів

Неважко сказати, що імена повинні розкривати наміри. Що ми хочемо вразити на вас, це те, що ми серйозно ставимося до цього. Вибір хороших імен вимагає часу, але економить більше, ніж потрібно. Тож подбайте про свої імена та змініть їх, коли знайдете кращі. Усі, хто читає ваш код (включаючи вас), будуть щасливішими, якщо ви зробите це.

Уникайте дезінформації

Програмісти повинні уникати хибних доказів, які затьмарюють значення коду. Ми повинні уникати слів, закріплені значення яких відрізняються від наших

Зробіть змістовні відмінності

Програмісти створюють проблеми для себе, коли вони пишуть код виключно для задоволення компілятора чи інтерпретатора.

Використовуйте пошукові імена

Використовуйте імена, які допоможуть вам зробити grep -iIR whateveryouaresearching . (не чистий код, тут CC говорив лише про змінні однієї літери).

Уникайте розумового картографування

Читачі не повинні подумки переводити ваші імена на інші імена, які вони вже знають. Ця проблема, як правило, випливає з вибору використовувати ні проблемні доменні терміни, ні умови доменного рішення.

Використовуйте проблемні доменні імена

Коли для того, що ви робите, немає «програміста-есе», використовуйте ім’я з проблемного домену. Принаймні програміст, який підтримує ваш код, може запитати у доменного експерта, що це означає.

Я завжди вирішую бути більш описовим в наші дні - завершення коду IDE означає, що вам не доведеться писати описові імена змінних, щоб я не бачив зворотного боку.

Ще в доісториці у вас були обмеження щодо змінних імен, а використання значущих імен змінних насправді може спричинити помірну вартість (наприклад, у BBC BASIC, використовуючи цілі статичні змінні A% тощо), було набагато дешевше, ніж використання значущого цілого числа - і в системі з частотою 1 МГц процесор, заощаджуючи кілька циклів тактового циклу в циклі, що фактично має значення)

Другий варіант виглядає, що я здивований. Коли я дивлюся лише на підпис, мені цікаво, чи поле вже відомо як недійсне? Або він буде попередньо перевірений (як його називають validatingField), щоб з’ясувати, чи справді він недійсний? Тож ця не просто зайва інформація тут, але додаткова інформація здається дещо оманливою. Цей вид «ясності» не зрозуміліший, його навпаки.

Насправді, коли я побачив вашу першу функцію, мене це теж спантеличило. Я запитав себе, чому чорт виконує вашу функцію просто з поля, але потім не використовує її і шукає іншого в invalidFields? Шукати поле, схоже, має набагато більше сенсу, коли введено лише ім’я поля, наприклад:

addInvalidField (fieldname, message) {
  const foundField = this.invalidFields.find(value => {
    return value.name === fieldname
  })
  const errors = foundField.errors
  if (!errors.some(error => error.name === message)) {
    errors.push({ name: message, message })
  }
}

Однак, я думаю, Боб Мартін, ймовірно, піде на крок далі і зробить код більш багатослівним - для більшої чіткості - в іншому напрямку. Типовий рефакторинг за принципом книги "Чистий код", мабуть, виглядатиме так:

addInvalidField (fieldname, message) {
  const foundField = findInvalidField(fieldName)
  addMessageForInvalidField(foundField,message)
}

з трьома додатковими функціями

  findInvalidField(fieldname){
    return this.invalidFields.find(value => { return value.name === fieldname })
  }

  addMessageForInvalidField(field,message){
    const errors = field.errors
    if (!doesErrorsContain(message)) {
      errors.push({ name: message, message })
    }
  }

  doesErrorsContain(message){
     return errors.some(error => error.name === message)
  }

Це спірне питання, якщо воно окупиться зайти так далеко за принципом єдиної відповідальності. Насправді є деякі плюси і мінуси. Моя особиста точка зору полягає в тому, що оригінальний код є "досить чистим" для більшості виробничих кодів, але реконструйований - краще.

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

Взагалі немає правильної відповіді в називанні. Багато людей, коли їм дано такий самий набір завдань, будуть називати отримані функції та змінні зовсім по-різному. Звичайно, ви хочете, щоб інші, хто читав ваш код, розуміли, але довше не завжди означає, що щось зрозуміліше. Якщо ваш код щільніший, він повинен бути тоді, тоді знадобиться більше часу, щоб зрозуміти, що навіть кожен рядок ваших функцій є настільки чітким і описовим, як це може бути.

Особисто мені більше подобається перший приклад. Це прямо і до речі, навіть коли змінні не мають таких описових імен, як у другому прикладі. Чесно кажучи, імена змінних у другому прикладі не набагато зрозуміліші, ніж перші, на мою думку, а зберігання функції коротке полегшує розуміння самої функції.

Зрештою, що краще буде залежати від вас і того, з ким ви працюєте. Зрештою, саме це буде читати та підтримувати.