У чистому коді автор наводить приклад

assertExpectedEqualsActual(expected, actual)

проти

assertEquals(expected, actual)

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

Тому що це більше набирати та більше читати

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

Багато розробників використовують IDE

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

Кодування аргументів вводить дублювання та сполучення

Імена параметрів повинні вже документувати, якими вони є. Записуючи імена у назві методу, ми дублюємо цю інформацію і в підписі методу. Ми також створюємо зв'язок між назвою методу та параметрами. Скажіть expectedі actualзаплутайте наших користувачів. Перехід від assertEquals(expected, actual)до assertEquals(planned, real)не вимагає зміни коду клієнта за допомогою функції. Перехід від assertExpectedEqualsActual(expected, actual)до assertPlannedEqualsReal(planned, real)означає неоднозначну зміну API. Або ми не змінюємо ім'я методу, що швидко стає заплутаним.

Використовуйте типи замість неоднозначних аргументів

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

class Expected<T> {
    private T value;
    Expected(T value) { this.value = value; }
    static Expected<T> is(T value) { return new Expected<T>(value); }
}

class Actual<T> {
    private T value;
    Actual(T value) { this.value = value; }
    static Actual<T> is(T value) { return new Actual<T>(value); }
}

static assertEquals(Expected<T> expected, Actual<T> actual) { /* ... */ }

// How it is used
assertEquals(Expected.is(10), Actual.is(x));

Потім це можна застосувати на рівні компілятора і гарантує, що ви не зможете їх повернути назад. Підходячи з іншого кута, це по суті те, що робить бібліотека Hamcrest для тестів.

Ви запитуєте про тривалу дискусію в програмуванні. Скільки багатослів’я добре? Як загальну відповідь, розробники виявили, що зайвого багатослівного іменування аргументів не варто.

Багатослівність не завжди означає більшу чіткість. Розглянемо

copyFromSourceStreamToDestinationStreamWithoutBlocking(fileStreamFromChoosePreferredOutputDialog, heuristicallyDecidedSourceFileHandle)

проти

copy(output, source)

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

Існує довга історія додавання багатослівності. Наприклад, є загальнопопулярна " угорська нотація ", яка дала нам чудові назви lpszName. Це, як правило, впало в сторону загального програмного забезпечення. Однак додавання символів в імена змінних - членів (наприклад , mNameчи m_Nameабо name_) продовжує мати популярність в деяких колах. Інші це повністю відкинули. Мені трапляється працювати над кодовою базою фізичного моделювання, чиї документи стилю кодування вимагають, щоб будь-яка функція, яка повертає вектор, повинна вказувати кадр вектора у виклику функції ( getPositionECEF).

Можливо, вас зацікавлять деякі мови, які популярні Apple. Objective-C включає назви аргументів як частину підпису функції (Функція [atm withdrawFundsFrom: account usingPin: userProvidedPin]записана в документації як withdrawFundsFrom:usingPin:. Ось назва функції). Свіфт прийняв подібний набір рішень, вимагаючи від вас ввести імена аргументів у функції call ( greet(person: "Bob", day: "Tuesday")).

Автор "Чистого кодексу" вказує на законну проблему, однак запропоноване ним рішення є неелегантним. Зазвичай існують кращі способи вдосконалення незрозумілих назв методів.

Він має рацію, що assertEquals(з бібліотек тестових одиниць стилю xUnit) не дає зрозуміти, який аргумент очікуваний, а який фактичний. Це теж мене покусало! Багато тестових бібліотек відзначили проблему та ввели альтернативні синтаксиси, як-от:

actual.Should().Be(expected);

Або подібне. Що, безумовно, набагато чіткіше, assertEqualsале і набагато краще, ніж assertExpectedEqualsActual. І це також набагато більше композиційний.

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

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

1. Чи є якась інша функція, на якій вона могла б враховувати арійність та ім'я?
   Ні, тому сама назва досить зрозуміла.
2. Чи мають типи якесь значення?
   Ні, тому давайте їх ігнорувати. Ви це вже робили? Добре.
3. Чи симетричний він у своїх аргументах?
   Майже, при помилці повідомлення ставить кожне представлення аргументів на своє місце.

Отже, давайте подивимось, чи мала ця різниця якесь значення, і чи не охоплено існуючими сильними умовами.

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

Чи впорядковані аргументи відповідають умові?
Здається, так і є. Хоча це в кращому випадку здається слабкою умовою.

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

Часто це не додає ніякої логічної ясності.

Порівняйте "Додати" з "AddFirstArgumentToSecondArgument".

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

Ще одне "Додати" з трьома аргументами?

або

"ДодатиFirstAndSecondAndThirdArgument"?

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

Я хотів би додати ще щось, на що натякають інші відповіді, але я не думаю, що це було згадано прямо:

@puck каже: "Все ще немає гарантії, що перший згаданий аргумент у назві функції справді є першим параметром".

@cbojar каже: "Використовуйте типи замість неоднозначних аргументів"

Проблема полягає в тому, що мови програмування не розуміють імен: вони просто трактуються як непрозорі, атомні символи. Отже, як і у коментарях до коду, не обов'язково існує кореляція між тим, що названа функцією, і як вона насправді функціонує.

Порівняйте assertExpectedEqualsActual(foo, bar)з деякими альтернативами (з цієї сторінки та з інших країн), наприклад:

# Putting the arguments in a labelled structure
assertEquals({expected: foo, actual: bar})

# Using a keyword arguments language feature
assertEquals(expected=foo, actual=bar)

# Giving the arguments different types, forcing us to wrap them
assertEquals(Expected(foo), Actual(bar))

# Breaking the symmetry and attaching the code to one of the arguments
bar.Should().Be(foo)

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

Коли я стикаюся з такою проблемою або передбачаю її, перш ніж я засмучусь на своєму комп’ютері, я спочатку замикаюся, щоб запитати, чи взагалі «справедливо» звинувачувати машину. Іншими словами, чи було дано машині достатньо інформації, щоб відрізнити те, що я хочу, від того, що я просив?

Виклик, як-от, assertEqual(expected, actual)має стільки ж сенсу, як assertEqual(actual, expected)нам легко змішати їх, а машина може оратись вперед і робити неправильну справу. Якщо ми використовуємо assertExpectedEqualsActualзамість цього, це може змусити нас менше помилитися, але це не дає більше інформації машині (вона не може зрозуміти англійську мову, а вибір імені не повинен впливати на семантику).

Те, що робить «структуровані» підходи більш кращими, як аргументи ключових слів, мічені поля, різні типи тощо, - це те, що додаткова інформація також читається машиною , тому ми можемо встановити на машині неправильні звички та допомогти нам робити все правильно. Справа assertEqualне надто погана, оскільки єдиною проблемою будуть неточні повідомлення. Більш зловісний приклад може бути String replace(String old, String new, String content), який легко сплутати з тим, String replace(String content, String old, String new)що має зовсім інше значення. Простим засобом було б взяти пару [old, new], яка б помилками викликала помилку негайно (навіть без типів).

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

Це також пов'язано з "булевою сліпотою", де ми обчислюємо купу булевих (або цифр тощо) в одній частині коду, але при спробі їх використання в іншій не зрозуміло, що вони насправді представляють, чи ми їх переплутали і т. д. Порівняйте це, наприклад, з різними переліками, які мають описові назви (наприклад, LOGGING_DISABLEDа не false) і які викликають повідомлення про помилку, якщо ми їх змішуємо.

оскільки це знімає необхідність пам’ятати, куди йдуть аргументи

Це насправді? Все ще немає гарантії, що перший згаданий аргумент у назві функції справді є першим параметром. Тож краще погляньте на це (або дозвольте вашому IDE це зробити) та залишайтеся з розумними іменами, ніж сліпо покладайтеся на досить дурне ім’я.

Якщо ви читаєте код, ви можете легко побачити, що відбувається, коли параметри названі такими, якими вони повинні бути. copy(source, destination)набагато простіше зрозуміти, ніж подібне copyFromTheFirstLocationToTheSecondLocation(placeA, placeB).

Чому кодери не приймають перше, якщо воно, як стверджує автор, чіткіше, ніж друге?

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

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

copyFromSourceToDestination( // "...ahh yes, the source directory goes first"

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

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

copy(sourceDir, destinationDir); // "...makes sense"

Напруженість цього переможе більшість програмістів, і мені особисто це легше читати.

EDIT: Як зазначав @Blrfl, параметри кодування не є "інтуїтивно зрозумілими", адже вам потрібно запам'ятати в першу чергу назву функції. Для цього потрібно шукати посилання функцій або отримати допомогу від IDE, яка, швидше за все, надасть інформацію про впорядкування параметрів.