第七章：错误处理与协程

错误处理和协程是 Lua 编程中两个重要的高级主题。本章将深入探讨如何有效地处理错误，以及如何使用协程来管理复杂的控制流。

7.1 错误类型和异常

Lua 中的错误可以分为两种主要类型：语法错误和运行时错误。

语法错误

语法错误在代码编译阶段就会被检测到。例如：

print("Hello, World"  -- 缺少右括号

这会导致一个语法错误。

运行时错误

运行时错误发生在程序执行过程中。例如：

local x = 10
print(x.nonexistent)  -- 尝试访问不存在的字段

这会导致一个运行时错误。

7.2 错误处理机制

Lua 提供了几种处理错误的机制。

assert 函数

assert 函数用于检查条件，如果条件为假，则抛出错误：

local function divide(a, b)
    assert(b ~= 0, "Division by zero!")
    return a / b
end

print(divide(10, 2))  -- 输出: 5
print(divide(10, 0))  -- 错误: Division by zero!

error 函数

error 函数用于显式抛出错误：

local function processPositiveNumber(n)
    if n <= 0 then
        error("Number must be positive")
    end
    return n * 2
end

pcall 和 xpcall 函数

pcall 用于捕获错误：

local success, result = pcall(function()
    error("An error occurred")
end)

if not success then
    print("Caught an error: " .. result)
end

xpcall 允许你提供一个错误处理函数：

local function errorHandler(err)
    print("Error occurred: " .. err)
    return err
end

xpcall(function()
    error("Something went wrong")
end, errorHandler)

7.3 异常处理最佳实践

使用描述性的错误消息
在适当的抽象级别处理错误
考虑使用表来创建结构化的错误对象

local function createError(code, message)
    return {code = code, message = message}
end

local function riskyOperation()
    -- 某些操作
    if somethingWrong then
        error(createError(500, "Internal error occurred"))
    end
end

local success, result = pcall(riskyOperation)
if not success then
    print("Error " .. result.code .. ": " .. result.message)
end

7.4 协程的基本概念

协程是一种协作式多任务处理的方式，允许执行被挂起和恢复。

协程 vs 线程

协程是协作式的，而线程是抢占式的
协程更轻量级，不需要同步机制

7.5 创建和管理协程

创建协程

local co = coroutine.create(function()
    for i = 1, 5 do
        print("coroutine", i)
        coroutine.yield()
    end
end)

恢复和暂停协程

coroutine.resume(co)  -- 输出: coroutine 1
coroutine.resume(co)  -- 输出: coroutine 2
print(coroutine.status(co))  -- 输出: suspended

7.6 协程的高级应用

使用协程实现简单的并发

local function task(name)
    for i = 1, 3 do
        print(name, "is working", i)
        coroutine.yield()
    end
end

local t1 = coroutine.create(function() task("Task 1") end)
local t2 = coroutine.create(function() task("Task 2") end)

for i = 1, 3 do
    coroutine.resume(t1)
    coroutine.resume(t2)
end

协程在游戏开发中的应用

local function enemyAI()
    while true do
        print("Enemy is searching")
        coroutine.yield()
        print("Enemy is attacking")
        coroutine.yield()
    end
end

local enemy = coroutine.create(enemyAI)

-- 游戏循环
for i = 1, 5 do
    print("Game tick", i)
    coroutine.resume(enemy)
end

7.7 错误处理和协程的结合

在协程中处理错误：

local co = coroutine.create(function()
    error("An error inside coroutine")
end)

local success, error_msg = coroutine.resume(co)
if not success then
    print("Coroutine failed:", error_msg)
end

7.8 实践项目：简单的任务调度器

让我们实现一个基于协程的简单任务调度器：

local scheduler = {}
local tasks = {}

function scheduler.addTask(task)
    local co = coroutine.create(task)
    table.insert(tasks, co)
end

function scheduler.run()
    while #tasks > 0 do
        for i = #tasks, 1, -1 do
            local co = tasks[i]
            local success, error_msg = coroutine.resume(co)
            if not success then
                print("Task failed:", error_msg)
                table.remove(tasks, i)
            elseif coroutine.status(co) == "dead" then
                table.remove(tasks, i)
            end
        end
    end
end

-- 使用调度器
scheduler.addTask(function()
    for i = 1, 3 do
        print("Task 1:", i)
        coroutine.yield()
    end
end)

scheduler.addTask(function()
    for i = 1, 2 do
        print("Task 2:", i)
        coroutine.yield()
    end
end)

scheduler.run()

练习

扩展任务调度器，添加优先级和超时功能。
实现一个使用协程的简单的生产者-消费者模型。
创建一个模拟回调地狱的场景，然后使用协程重写它以展示协程如何简化异步代码。

通过本章的学习，你应该能够有效地处理 Lua 程序中的错误，并利用协程来管理复杂的控制流。

这些技能对于编写健壮和高效的 Lua 程序至关重要。