Расхождение в конструкции: проверка безопасности - PullRequest
1 голос
/ 04 декабря 2010

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

Мой товарищ по команде использует проверки типов аргументов почти везде:

function someFunction( a, b,c )
   if a == nil then return end

   --Some stuff here

   if type( b ) ~= "function" then
      Error( "blah" )
   end

   --More here

   if someTable[ c ] == nil then someTable[ c ] = {}
end

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

В общем, я бы сделал это так:

function someFunction( a, b,c )
   --More here

   if someTable[ c ] == nil then someTable[ c ] = {}
end

Я пропускаю почти все проверки типов / аргументов и выполняю только те, у кого есть большие шансы на фактическое выполнение.

  • Теперь мы не уверены, какое решение лучше, и решили спросить вас: проверка безопасности в Lua - да или нет?

Ответы [ 6 ]

2 голосов
/ 04 декабря 2010

Я не знаком с Луа, но Википедия, кажется, думает, что она напечатана уткой.Я собираюсь провести аналогию с Python, поэтому простите меня, если это не подходит.

В Python функции разрабатываются по принципу, что им нужен объект, который соответствует определенным критериям.Если вы передаете объект, отличный от того, который предполагал первоначальный автор, при условии, что он соответствует критериям функции, он должен работать.Идея в том, что «если это выглядит как утка, ходит как утка и крякает как утка, то это утка».(Отсюда и название.) Тем не менее, есть несколько редких случаев, когда вам нужен объект определенного типа, но это не общий случай.

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

1 голос
/ 04 декабря 2010

Я печатаю проверки публичных функций в моем API.Но не только для внутренних функций.Хорошая проверка типов:

function ( a , b )
    assert ( type ( a ) == "number" , "Invalid a" )

    b = b or {}
    assert ( type ( b ) == "table" , "B must be a table" )

    c = assert ( type ( c ) == "string" ) and c or "default"
end

Имейте в виду, однако, что у lua также есть некоторая «утиная» типизация: если все, что требуется для объекта, может быть вызвано, то таблица с методом __call должна быть допустимой,То же самое для индексируемого объекта: таблица и пользовательские данные могут быть проиндексированы (не говоря уже о других типах).

0 голосов
/ 28 декабря 2010

Вам нужно проверять типы там, где это важно (и не следует проверять, где это не важно). Обычно я проверяю тип большинства аргументов общедоступной функции и добавляю проверку везде, где при отладке я сталкиваюсь с ошибкой типа.

Чтобы сократить проверки типов, я использую небольшую вспомогательную функцию arguments():

https://github.com/lua-nucleo/lua-nucleo/blob/master/lua-nucleo/args.lua

Пример:

https://github.com/lua-aplicado/lua-aplicado/blob/master/lua-aplicado/filesystem.lua#L63-66

local write_file = function(filename, new_data)
  arguments(
      "string", filename,
      "string", new_data
    )

  local file, err = io.open(filename, "w")
  if not file then
    return nil, err
  end

  file:write(new_data)
  file:close()
  file = nil

  return true
end
0 голосов
/ 04 декабря 2010

Теперь мы не уверены, какое решение лучше, и решили спросить вас: проверка безопасности в Lua - да или нет?

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

С другой стороны, если вы создаете библиотеку / API для использования другими, очень уместно сделать проверку типов. Для пользователя вашей библиотеки, который не знает о внутренностях, очень полезно знать, когда он передает неправильные аргументы.

0 голосов
/ 04 декабря 2010

Полагаю, это зависит от того, что вы планируете делать дальше: если другие люди действительно будут писать код Lua для работы с вашим кодом, было бы полезно проверить аргументы (или сделать это возможным, используя что-то вроде enableDebug). Что-то полезное, что я нашел вчера, это DecoratorsAndDocstrings , который позволяет документировать / проверять функции без изменения реализации.

Еще одна идиома, используемая для этой цели:

argument = argument or default -- or
argument = type(argument)=="number" and argument or error'I should get a number'
0 голосов
/ 04 декабря 2010

Я тоже не знаю Lua, и немного неясно, спрашиваете ли вы только о проверке аргумента types [type (b) ~ = "function"] или вы хотите проверитьих значения тоже [a == nil], но вот что я делаю:

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

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

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

Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.
...