Отступ кода для объявления входов /выходов в массиве

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

var equals = [
                //input                         //output
                ["name:(John Smith)",           "name:(John~ Smith~)"   ],
                ["name:Jon~0.1",                "name:Jon~0.1"          ],
                ["Jon",                         "Jon~"                  ],
                ["Jon Smith~0.1",               "Jon~ Smith~0.1"        ],
                ["Jon AND Bob",                 "Jon~ AND Bob~"         ],
                ["Jon AND Bob~0.1",             "Jon~ AND Bob~0.1"      ],
                ["Steve^9 Jon", ]               "Steve^9 Jon~"          ]

            ];

Я отформатировал его как таковой, поэтому его легко сравнивать и читать. Однако это нетрадиционно.

Это плохая идея?

28 голосов | спросил dwjohnston 23 Jam1000000amThu, 23 Jan 2014 02:44:38 +040014 2014, 02:44:38

3 ответа


27

Аргумент против выравнивания в стиле таблицы в коде

За исключением , когда редактор /IDE помогает поддерживать выравнивание с небольшой работой от программиста, и , все те, кто работает с кодом, имеют тот же объект, горизонтальный, как выравнивание в коде - это больше проблем, чем это стоит, по этим причинам:

  • Операции поиска /замены на всей базе кода (как при переименовании переменной или метода) будут иметь тенденцию оставлять такой код в беспорядке, который требует ручной очистки.

  • Любой, чей редактор /IDE не упрощает горизонтальное выравнивание, потратит много времени на удаление пространства или DEL, чтобы выстроить элементы при добавлении или удалении записи.

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

По этим причинам я склонен мириться с уродством:

 var equals = [ //input, output
   ["name:(John Smith)", "name:(John~ Smith~)"],
   ["name:Jon~0.1", "name:Jon~0.1"],
   //...
 ];

или, как @ChrisW предлагает:

 var equals = [ //input, output
   [
     "name:(John Smith)",
     "name:(John~ Smith~)"
   ],
   [
     "name:Jon~0.1",
     "name:Jon~0.1"
   ],
   //...
 ];

Но, может быть, данные не хотят находиться в коде

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

ответил Wayne Conrad 23 Jam1000000amThu, 23 Jan 2014 02:55:04 +040014 2014, 02:55:04
12

Вопрос мнения, всегда сложный.

С точки зрения DRY, ваш код должен использоваться для создания документации, например, «какие варианты использования поддерживает эта подпрограмма» или «Каковы значения отображения между y и z».

Таким образом, я определенно выравниваю свои таблицы, однако я также склоняюсь к выравниванию запятой, и я склоняюсь к выравниванию двух пространств в, а не по всему пути справа от var.

Другими словами, что-то вроде этого:

var equals =                                            
  [                                                       
    //input               //output
    ["name:(John Smith)", "name:(John~ Smith~)"],
    ["name:Jon~0.1"     , "name:Jon~0.1"       ],
    ["Jon"              , "Jon~"               ],
    ["Jon Smith~0.1"    , "Jon~ Smith~0.1"     ],
    ["Jon AND Bob"      , "Jon~ AND Bob~"      ],
    ["Jon AND Bob~0.1"  , "Jon~ AND Bob~0.1"   ],
    ["Steve^9 Jon"      , "Steve^9 Jon~"       ]         
  ];       
ответил konijn 23 Jam1000000amThu, 23 Jan 2014 03:49:43 +040014 2014, 03:49:43
3

С точки зрения чистого обзора кода, не обращаясь к прямому вопросу «Должен ли я форматировать мои тестовые данные в блочном виде», но вместо этого это лучший способ записать эти данные в первую очередь?

Если вы думаете о написании модульного теста, то это более удобочитаемо /поддерживаемо:

    var equals =                                            
  [                                                       
    //input               //output
    ["name:(John Smith)", "name:(John~ Smith~)"],
    ["name:Jon~0.1"     , "name:Jon~0.1"       ],
    ["Jon"              , "Jon~"               ],
    ["Jon Smith~0.1"    , "Jon~ Smith~0.1"     ],
    ["Jon AND Bob"      , "Jon~ AND Bob~"      ],
    ["Jon AND Bob~0.1"  , "Jon~ AND Bob~0.1"   ],
    ["Steve^9 Jon"      , "Steve^9 Jon~"       ]         
  ]; 

foreach(var item in equals){
Assert.Equal(Sut.Process(item.Key), item.Value)
}

Или, может быть, вам просто нужно написать свои утверждения /тесты:

Assert.Equal(Sut.Process("name:(John Smith)"), "name:(John~ Smith~)")
Assert.Equal(Sut.Process("name:Jon~0.1"), "name:Jon~0.1")
etc

Если вы считаете, что вам следует использовать список, используйте структурированный тип в отличие от массива, так как, хотя он больше набирает текст, его легче читать:

    var params =
    [{
         Input: "name:(John Smith)",
         Output: "name:(John~ Smith~)"
    },{
         Input: "name:Jon~0.1",
         Output: "name:Jon~0.1"
    }]

for(var expect in params){
    Assert.Equal(Sut.Process(expect.Input), expect.Output)
}

Нет никакого преимущества форматировать ваши данные так, как вы делаете, ЕСЛИ вы используете редактор, который управляет этим для вас. Читаемость не сильно улучшена (учитывая, что я имею более низкое разрешение экрана, чем вы, я даже не вижу его), и работа по поддержанию такого форматирования намного превосходит преимущества этого. Согласованные тесты должны быть максимально читабельными, поэтому массив, вероятно, не самый лучший вариант для записи этих данных.

ответил Mitchell Lee 15 MaramSat, 15 Mar 2014 02:27:22 +04002014-03-15T02:27:22+04:0002 2014, 02:27:22

Похожие вопросы

Популярные теги

security × 330linux × 316macos × 2827 × 268performance × 244command-line × 241sql-server × 235joomla-3.x × 222java × 189c++ × 186windows × 180cisco × 168bash × 158c# × 142gmail × 139arduino-uno × 139javascript × 134ssh × 133seo × 132mysql × 132