如何优化Lua中循环结构以提升OpenResty脚本性能？解析循环展开、JIT加速、内存复用等核心技术

-- 传统数值循环（优化前）
for i = 1, 1000000 do
    local temp = math.sqrt(i) * 2  -- 每次循环都执行数学运算
    ngx.say("Result:", temp)       -- 在循环体内调用网络IO
end

-- 优化后的数值循环
local sqrt = math.sqrt  -- 预加载函数到局部变量
local say = ngx.say     -- 缓存API方法
local result_cache = {} -- 预先生成结果表

for i = 1, 1e6 do
    result_cache[i] = sqrt(i) * 2  -- 批量计算存储
end

for _, v in ipairs(result_cache) do
    say("Result:", v)  -- 集中处理输出
end

-- 低效的字典遍历
local user_ratings = {
    ["user_1001"] = 4.5,
    -- ...此处省略999个键值对...
    ["user_2000"] = 3.8
}

-- 优化前
for k, v in pairs(user_ratings) do
    if string.sub(k, 1, 5) == "user_" then  -- 每次循环都执行字符串截取
        ngx.log(ngx.INFO, "User rating:", v)
    end
end

-- 优化后
local prefix = "user_"
local log = ngx.log
local INFO = ngx.INFO
local sub = string.sub

for k, v in pairs(user_ratings) do
    if sub(k, 1, #prefix) == prefix then  -- 使用预存长度比较
        log(INFO, "User rating:", v)      -- 使用局部变量替换全局方法
    end
end

-- 危险操作示范
function process_data()
    for i = 1, 10000 do
        data = load_from_db()  -- 污染全局变量
        -- ...处理逻辑...
    end
end

-- 安全优化方案
local data_processor = {
    process = function(self)
        local data_cache = {}  -- 局部变量存储
        for i = 1, 10000 do
            data_cache[i] = self:load_data()
            -- ...处理逻辑...
        end
    end,
    load_data = function(self)
        -- 数据库查询逻辑
    end
}

-- 冗余操作示例
for _, product in ipairs(products) do
    local final_price = product.base_price 
                        * (1 + tax_rate) 
                        * discount_factor  -- 多层计算
    update_inventory(product.id)           -- 库存操作
    log_transaction(product.sku)           -- 日志记录
end

-- 优化拆分方案
-- 阶段一：批量计算价格
local price_list = {}
for i, product in ipairs(products) do
    price_list[i] = product.base_price 
                    * (1 + tax_rate) 
                    * discount_factor
end

-- 阶段二：批量处理库存
for _, product in ipairs(products) do
    update_inventory(product.id)
end

-- 阶段三：集中记录日志
local skus = {}
for _, product in ipairs(products) do
    table.insert(skus, product.sku)
end
log_transaction_batch(skus)

local table_pool = {}
local MAX_POOL_SIZE = 100

function get_table()
    if #table_pool > 0 then
        return table.remove(table_pool)
    end
    return {}
end

function recycle_table(tbl)
    if #table_pool < MAX_POOL_SIZE then
        for k in pairs(tbl) do
            tbl[k] = nil
        end
        table.insert(table_pool, tbl)
    end
end

-- 使用示例
local buffer = get_table()
for i = 1, 1e5 do
    buffer[i] = i * math.pi
end
process_data(buffer)
recycle_table(buffer)

-- 启用JIT优化
jit.on()

local sum = 0
-- 适合JIT编译的循环结构
for i = 1, 1000000 do
    sum = sum + i ^ 0.5  -- 简单数学运算
end

-- 需要避免的模式
local dynamic_func = loadstring("return " .. math.random(100))
for i = 1, 1000000 do
    sum = sum + dynamic_func()  -- 动态代码破坏JIT优化
end

local cjson = require "cjson.safe"
local bid_requests = get_batch_requests()

-- 优化前
local responses = {}
for _, req in ipairs(bid_requests) do
    local parsed = cjson.decode(req)
    local bid = calculate_bid(parsed)
    table.insert(responses, cjson.encode(bid))
end

-- 优化后
local responses = table.new(#bid_requests, 0)
local decode = cjson.decode
local encode = cjson.encode
for i = 1, #bid_requests do
    local parsed = decode(bid_requests[i])
    responses[i] = encode(calculate_bid(parsed))
end

-- 字符串拼接引发的灾难
local result = ""
for i = 1, 10000 do
    result = result .. tostring(i)  -- 产生大量临时字符串
end

-- 优化方案
local buffer = {}
for i = 1, 10000 do
    buffer[#buffer+1] = tostring(i)
end
result = table.concat(buffer)

function create_handlers()
    local handlers = {}
    for i = 1, 1000 do
        handlers[i] = function()  -- 每个闭包都捕获循环变量
            process(i)
        end
    end
    return handlers
end

-- 优化方案
local function create_handler(index)
    return function()
        process(index)
    end
end

for i = 1, 1000 do
    handlers[i] = create_handler(i)
end