Lua обработка ошибок

---

Need for Error Handling

Error handling is quite critical since real-world operations often require the use of complex operations, which includes file operations, database transactions and web service calls.

In any programming, there is always a requirement for error handling. Errors can be of two types which includes,

• Syntax errors
• Run time errors

Syntax Errors

Syntax errors occur due to improper use of various program components like operators and expressions. A simple example for syntax error is shown below.

a == 2

As you know, there is a difference between the use of a single «equal to» and double «equal to». Using one instead of the other can lead to an error. One «equal to» refers to assignment while a double «equal to» refers to comparison. Similarly, we have expressions and functions having their predefined ways of implementation.

Another example for syntax error is shown below −

for a= 1,10
   print(a)
end

When we run the above program, we will get the following output −

lua: test2.lua:2: 'do' expected near 'print'

Syntax errors are much easier to handle than run time errors since, the Lua interpreter locates the error more clearly than in case of runtime error. From the above error, we can know easily that adding a do statement before print statement is required as per the Lua structure.

Run Time Errors

In case of runtime errors, the program executes successfully, but it can result in runtime errors due to mistakes in input or mishandled functions. A simple example to show run time error is shown below.

function add(a,b)
   return a+b
end

add(10)

When we build the program, it will build successfully and run. Once it runs, shows a run time error.

lua: test2.lua:2: attempt to perform arithmetic on local 'b' (a nil value)
stack traceback:
	test2.lua:2: in function 'add'
	test2.lua:5: in main chunk
	[C]: ?

This is a runtime error, which had occurred due to not passing two variables. The b parameter is expected and here it is nil and produces an error.

Assert and Error Functions

In order to handle errors, we often use two functions − assert and error. A simple example is shown below.

local function add(a,b)
   assert(type(a) == "number", "a is not a number")
   assert(type(b) == "number", "b is not a number")
   return a+b
end

add(10)

When we run the above program, we will get the following error output.

lua: test2.lua:3: b is not a number
stack traceback:
	[C]: in function 'assert'
	test2.lua:3: in function 'add'
	test2.lua:6: in main chunk
	[C]: ?

The error (message [, level]) terminates the last protected function called and returns message as the error message. This function error never returns. Usually, error adds some information about the error position at the beginning of the message. The level argument specifies how to get the error position. With level 1 (the default), the error position is where the error function was called. Level 2 points the error to where the function that called error was called; and so on. Passing a level 0 avoids the addition of error position information to the message.

pcall and xpcall

In Lua programming, in order to avoid throwing these errors and handling errors, we need to use the functions pcall or xpcall.

The pcall (f, arg1, …) function calls the requested function in protected mode. If some error occurs in function f, it does not throw an error. It just returns the status of error. A simple example using pcall is shown below.

function myfunction ()
   n = n/nil
end

if pcall(myfunction) then
   print("Success")
else
	print("Failure")
end

When we run the above program, we will get the following output.

Failure

The xpcall (f, err) function calls the requested function and also sets the error handler. Any error inside f is not propagated; instead, xpcall catches the error, calls the err function with the original error object, and returns a status code.

A simple example for xpcall is shown below.

function myfunction ()
   n = n/nil
end

function myerrorhandler( err )
   print( "ERROR:", err )
end

status = xpcall( myfunction, myerrorhandler )
print( status)

When we run the above program, we will get the following output.

ERROR:	test2.lua:2: attempt to perform arithmetic on global 'n' (a nil value)
false

As a programmer, it is most important to ensure that you take care of proper error handling in the programs you write. Using error handling can ensure that unexpected conditions beyond the boundary conditions are handled without disturbing the user of the program.

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

Любые языки программирования, требуется обработка ошибок. Типы ошибок являются:

• Ошибка синтаксиса
• Ошибка выполнения

---

Ошибка синтаксиса

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

-- test.lua 文件
a == 2

Приведенный выше код выполняется в результате:

lua: test.lua:2: syntax error near '=='

Как вы можете видеть, было больше, чем за синтаксической ошибки, а «=» знак следуют два знака «=» отличается. А «=» является выражение присваивания два «=» является операция сравнения.

Другой пример:

for a= 1,10
   print(a)
end

Выше программа появится следующие ошибки:

lua: test2.lua:2: 'do' expected near 'print'

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

for a= 1,10
do
   print(a)
end

---

Ошибка выполнения

Запуск программы может выполнять ошибки нормально, но он выводит сообщение об ошибке. Ниже приведены примеры, так как входные параметры, ошибки, ошибки выполнения программы:

function add(a,b)
   return a+b
end

add(10)

Когда мы скомпилировать и запустить следующий код, компилятор может быть успешным, но во время выполнения будет производить следующее сообщение об ошибке:

lua: test2.lua:2: attempt to perform arithmetic on local 'b' (a nil value)
stack traceback:
	test2.lua:2: in function 'add'
	test2.lua:5: in main chunk
	[C]: ?

Следующее сообщение об ошибке вызвано тем, что программа не хватает параметра Ь.

---

Обработка ошибок

Мы можем использовать две функции: ошибки и утверждают для обработки ошибок. Примерами могут служить следующие:

local function add(a,b)
   assert(type(a) == "number", "a 不是一个数字")
   assert(type(b) == "number", "b 不是一个数字")
   return a+b
end
add(10)

Выше программа появится следующие ошибки:

lua: test.lua:3: b 不是一个数字
stack traceback:
	[C]: in function 'assert'
	test.lua:3: in local 'add'
	test.lua:6: in main chunk
	[C]: in ?

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

функция ошибок

Синтаксис:

error (message [, level])

: Завершает функцию которая выполняется, и возвращает содержимое сообщения в виде сообщения об ошибке (функция ошибки никогда не вернется)

Как правило, ошибка будет некоторая дополнительная информация о сообщении об ошибке в положении головы.

Параметр Level указывает положение, чтобы получить не так:

• Уровень = 1 [по умолчанию]: Для вызова ошибки (файл + номер строки)
• Level = 2: функция, которая вызывает функцию ошибки, указанную
• Уровень = 0: не добавляйте место ошибки

---

PCALL и xpcall, отлаживать

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

PCALL получать функцию, и вы хотите передать параметр последнего, и выполняется, результат: есть ошибка, нет ошибки, или значение, возвращаемое истинным или ложным, errorinfo.

Синтаксис выглядит следующим образом

if pcall(function_name, ….) then
-- 没有错误
else
-- 一些错误
end

Простой пример:

> =pcall(function(i) print(i) end, 33)
33
true
   
> =pcall(function(i) print(i) error('error..') end, 33)
33
false        stdin:1: error..

> function f() return false,2 end
> if f() then print '1' else print '0' end
0

PCALL в «защищенном режиме», чтобы вызвать первый аргумент, поэтому PCALL функция захвата может выполнять какие-либо ошибки.

Как правило, при возникновении ошибки, она надеется, что в конечном итоге с большим количеством информации отладки, а не только там, где произошла ошибка. Но PCALL возвращается, она разрушила часть содержимого вызова Чжань.

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

отладки библиотека предоставляет два общих обработчика ошибок:

• debug.debug: Lua обеспечивают подсказку, что позволяет пользователям распространять неправильные причины
• debug.traceback: Согласно Чжань вызова построить расширенное сообщение об ошибке

> = Xpcall (функция (я) печати (я) ошибка ( ‘ошибка ..’) конец, функция () печати (debug.traceback)) конец (33) 33 стопка отслеживающий: STDIN: 1: в функции [C]: в функции ‘ошибки’ STDIN: 1: в функции [C]: в функции ‘xpcall’ STDIN: 1: в главном фрагменте [C] В ложном нолю

xpcall Пример 2:

function myfunction ()
   n = n/nil
end

function myerrorhandler( err )
   print( "ERROR:", err )
end

status = xpcall( myfunction, myerrorhandler )
print( status)

Выше программа появится следующие ошибки:

ERROR:	test2.lua:2: attempt to perform arithmetic on global 'n' (a nil value)
false

Использование pcall

pcall означает «защищенный вызов». Он используется для добавления обработки ошибок в функции. pcall работает аналогично try-catch на других языках. Преимущество pcall заключается в том, что полное выполнение скрипта не прерывается, если возникают ошибки в функциях, вызываемых с помощью pcall . Если ошибка внутри функции, вызванной с помощью pcall возникает ошибка, и остальная часть кода продолжает выполнение.

---

Синтаксис:

pcall( f , arg1,···)

---

Возвращаемые значения:

Возвращает два значения

1. status (boolean)

• Возвращает true, если функция была выполнена без ошибок.
• Возвращает false, если внутри функции возникла ошибка.

1. возвращаемое значение функции или сообщение об ошибке, если в функциональном блоке произошла ошибка.

---

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

local function executeFunction(funcArg, times) then
    for i = 1, times do
        local ran, errorMsg = pcall( funcArg )
        if not ran then
            error("Function errored on run " .. tostring(i) .. "n" .. errorMsg)
        end
    end
end

Когда заданные ошибки функции при запуске 3, сообщение об ошибке будет понятно пользователю, что оно не исходит от вашей функции, а от функции, которая была предоставлена ​​нашей функции. Кроме того, учитывая это, фантастический BSoD может быть уведомлен о пользователе. Однако это зависит от приложения, которое реализует эту функцию, поскольку API, скорее всего, этого не сделает.

Пример A — Исполнение без pcall

function square(a)
  return a * "a"    --This will stop the execution of the code and throws an error, because of the attempt to perform arithmetic on a string value
end

square(10);

print ("Hello World")    -- This is not being executed because the script was interrupted due to the error

Пример B — Исполнение с pcall

function square(a)
  return a * "a"
end

local status, retval = pcall(square,10);

print ("Status: ", status)        -- will print "false" because an error was thrown.
print ("Return Value: ", retval)  -- will print "input:2: attempt to perform arithmetic on a string value"
print ("Hello World")    -- Prints "Hello World"

Пример. Выполнение безупречного кода.

function square(a)
  return a * a
end

local status, retval = pcall(square,10);

print ("Status: ", status)        -- will print "true" because no errors were thrown 
print ("Return Value: ", retval)  -- will print "100"
print ("Hello World")    -- Prints "Hello World"

Предполагая, что мы имеем следующую функцию:

function foo(tab)
  return tab.a
end -- Script execution errors out w/ a stacktrace when tab is not a table

Давайте немного поправим

function foo(tab)
  if type(tab) ~= "table" then
    error("Argument 1 is not a table!", 2)
  end
  return tab.a
end -- This gives us more information, but script will still error out

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

function foo(tab)
    if type(tab) ~= "table" then return nil, "Argument 1 is not a table!" end
    return tab.a
end -- This never crashes the program, but simply returns nil and an error message

Теперь у нас есть функция, которая ведет себя так, мы можем делать такие вещи:

if foo(20) then print(foo(20)) end -- prints nothing
result, error = foo(20)
if result then print(result) else log(error) end

И если мы хотим, чтобы программа потерпела крах, если что-то пошло не так, мы все равно можем это сделать:

result, error = foo(20)
if not result then error(error) end

К счастью, нам даже не нужно писать все это каждый раз; lua имеет функцию, которая выполняет именно это

result = assert(foo(20))

Необходимость обработки ошибок

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

В любом программировании всегда есть требование обработки ошибок. Ошибки могут быть двух типов, включая:

• Синтаксические ошибки
• Ошибки времени выполнения

Ошибки синтаксиса

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

a == 2

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

Другой пример синтаксической ошибки показан ниже —

for a= 1,10
   print(a)
end

Когда мы запустим вышеуказанную программу, мы получим следующий результат —

lua: test2.lua:2: 'do' expected near 'print'

Синтаксические ошибки намного легче обрабатывать, чем ошибки времени выполнения, поскольку интерпретатор Lua обнаруживает ошибку более четко, чем в случае ошибки времени выполнения. Из приведенной выше ошибки мы можем легко узнать, что в соответствии со структурой Lua требуется добавление оператора do перед оператором печати.

Ошибки времени выполнения

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

function add(a,b)
   return a+b
end

add(10)

Когда мы построим программу, она будет успешно построена и запущена. После запуска показывает ошибку времени выполнения.

lua: test2.lua:2: attempt to perform arithmetic on local 'b' (a nil value)
stack traceback:
	test2.lua:2: in function 'add'
	test2.lua:5: in main chunk
	[C]: ?

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

Функции утверждения и ошибки

Для обработки ошибок мы часто используем две функции: assert и error. Ниже показан простой пример.

local function add(a,b)
   assert(type(a) == "number", "a is not a number")
   assert(type(b) == "number", "b is not a number")
   return a+b
end

add(10)

Когда мы запустим указанную выше программу, мы получим следующий вывод ошибки.

lua: test2.lua:3: b is not a number
stack traceback:
	[C]: in function 'assert'
	test2.lua:3: in function 'add'
	test2.lua:6: in main chunk
	[C]: ?

В error (message [, level])завершает вызов последней защищенной функции и возвращает сообщение как сообщение об ошибке. Ошибка этой функции никогда не возвращается. Обычно ошибка добавляет некоторую информацию о позиции ошибки в начале сообщения. Аргумент уровня указывает, как получить позицию ошибки. При уровне 1 (по умолчанию) позиция ошибки — это место, где была вызвана функция ошибки. Уровень 2 указывает на ошибку, где была вызвана функция, вызвавшая ошибку; и так далее. Передача уровня 0 позволяет избежать добавления в сообщение информации о местоположении ошибки.

pcall и xpcall

В программировании на Lua, чтобы избежать появления этих ошибок и ошибок обработки, нам необходимо использовать функции pcall или xpcall.

В pcall (f, arg1, …)функция вызывает запрошенную функцию в защищенном режиме. Если в функции f возникает какая-то ошибка, она не вызывает ошибки. Он просто возвращает статус ошибки. Ниже показан простой пример использования pcall.

function myfunction ()
   n = n/nil
end

if pcall(myfunction) then
   print("Success")
else
	print("Failure")
end

Когда мы запустим вышеуказанную программу, мы получим следующий результат.

Failure

В xpcall (f, err)функция вызывает запрошенную функцию, а также устанавливает обработчик ошибок. Любая ошибка внутри f не распространяется; вместо этого xpcall перехватывает ошибку, вызывает функцию err с исходным объектом ошибки и возвращает код состояния.

Ниже показан простой пример для xpcall.

function myfunction ()
   n = n/nil
end

function myerrorhandler( err )
   print( "ERROR:", err )
end

status = xpcall( myfunction, myerrorhandler )
print( status)

Когда мы запустим вышеуказанную программу, мы получим следующий результат.

ERROR:	test2.lua:2: attempt to perform arithmetic on global 'n' (a nil value)
false

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