简单之美：Lua Table

local t = {
  1, 2, 3,           -- 这三个会被当成数组，下标自动是 1, 2, 3
  name = "walter",   -- 这是哈希的字符串键
  [10] = "ten",       -- 这是哈希的稀疏整数键
}

print(t[1])      --> 1
print(t.name)    --> walter
print(t[10])     --> ten

local t = {10, 20, 30, name = "walter"}

for i, v in ipairs(t) do
  print(i, v)
end
-- 1  10
-- 2  20
-- 3  30
-- 遇到 name 这种非连续整数键，直接跳过，而且一旦中间断了（遇到 nil）就停

for k, v in pairs(t) do
  print(k, v)
end
-- 1  10
-- 2  20
-- 3  30
-- name  walter
-- 顺序不保证，但保证遍历到所有键

local t = {1, 2, nil, 4}
print(#t)  -- 可能是 2，也可能是 4，官方文档明确说这是未定义行为

setmetatable(t, mt)   -- 给 table t 设置元表 mt
getmetatable(t)        -- 取出 t 当前的元表，没有则返回 nil

local defaults = {timeout = 30, retries = 3}

local config = setmetatable({timeout = 60}, {
  __index = defaults,
})

print(config.timeout)  --> 60（自己有，不查元表）
print(config.retries)  --> 3（自己没有，查元表的 defaults）

local function readonly(t)
  return setmetatable({}, {
    __index = t,
    __newindex = function(_, k, v)
      error("attempt to modify read-only table, key = " .. tostring(k), 2)
    end,
  })
end

local ro = readonly({a = 1, b = 2})
print(ro.a)     --> 1
ro.c = 3        --> 报错：attempt to modify read-only table, key = c

local Vector = {}
Vector.__index = Vector

function Vector.new(x, y)
  return setmetatable({x = x, y = y}, Vector)
end

Vector.__add = function(a, b)
  return Vector.new(a.x + b.x, a.y + b.y)
end

Vector.__tostring = function(v)
  return string.format("(%d, %d)", v.x, v.y)
end

local v1 = Vector.new(1, 2)
local v2 = Vector.new(3, 4)
print(v1 + v2)  --> (4, 6)，触发 __add 和 __tostring 两个元方法

-- 基类 Animal
local Animal = {}
Animal.__index = Animal

function Animal.new(name, sound)
  local self = setmetatable({}, Animal)
  self.name = name
  self.sound = sound
  return self
end

function Animal:speak()
  print(self.name .. " says " .. self.sound)
end

-- 子类 Dog，继承 Animal
local Dog = setmetatable({}, {__index = Animal})
Dog.__index = Dog

function Dog.new(name)
  local self = Animal.new(name, "Woof")
  return setmetatable(self, Dog)
end

function Dog:fetch()
  print(self.name .. " fetches the ball")
end

local d = Dog.new("Rex")
d:speak()   --> Rex says Woof（自己没有 speak，沿着 __index 链查到 Animal）
d:fetch()   --> Rex fetches the ball

local new_tab = require("table.new")
local clear_tab = require("table.clear")

-- table.new(narr, nhash)：预先分配好数组部分 narr 个槽位、
-- 哈希部分 nhash 个槽位，避免插入过程中反复扩容搬迁
local t = new_tab(100, 0)
for i = 1, 100 do
  t[i] = i * i
end

-- table.clear(t)：清空表里所有键值对，但保留已经分配好的内存
-- 不触发重新分配，适合反复复用的"池化"表
clear_tab(t)

local clone = require("table.clone")
local isarray = require("table.isarray")
local nkeys = require("table.nkeys")
local isempty = require("table.isempty")

local t = {1, 2, 3}
local t2 = clone(t)          -- 浅拷贝一份新表，和 t 互不影响

print(isarray({1, 2, 3}))    --> true（数组部分连续、哈希部分为空）
print(isarray({a = 1}))      --> false
print(nkeys({1, 2, a = 1}))  --> 3（数组 2 个 + 哈希 1 个，不管有没有空洞都能数对）
print(isempty({}))           --> true

http {
    lua_shared_dict limiter 10m;   # 声明一块 10MB 的共享内存区域，取名 limiter

    server {
        location /api {
            access_by_lua_block {
                local limiter = ngx.shared.limiter
                local key = "req_count:" .. ngx.var.remote_addr

                -- incr 是原子自增：key 不存在时用 init 初始化成 0 再加
                local count, err = limiter:incr(key, 1, 0, 60)
                if not count then
                    ngx.log(ngx.ERR, "incr failed: ", err)
                    return
                end

                if count > 100 then
                    ngx.exit(ngx.HTTP_TOO_MANY_REQUESTS)
                end
            }

            proxy_pass http://backend;
        }
    }
}

local queue = ngx.shared.my_queue

queue:rpush("jobs", "task-1")   -- 从队尾塞入
queue:rpush("jobs", "task-2")
print(queue:llen("jobs"))        --> 2

local job = queue:lpop("jobs")   -- 从队头弹出，FIFO
print(job)                        --> task-1

@startmindmap
<style>
mindmapDiagram {
  node {
    BackgroundColor #F8F9FA
    RoundCorner 10
    Padding 10
    FontSize 13
  }
  :depth(0) {
    BackgroundColor #1E3A5F
    FontColor white
    FontSize 18
    FontStyle bold
  }
  :depth(1) {
    FontSize 15
    FontStyle bold
  }
  :depth(2) {
    FontSize 13
  }
}
</style>

* 简单之美：Lua Table
** Table 本体
*** 数组部分：连续整数键
*** 哈希部分：其余所有键
*** # 对空洞表未定义
*** ipairs vs pairs
** 元表 metatable
*** setmetatable / getmetatable
*** __index / __newindex
*** 运算符重载 __add __eq __tostring
*** 唯一的扩展机制
** 面向对象
*** Lua 本身不是 OO
*** __index 链 = 原型链
*** 冒号语法糖 self
** LuaJIT 扩展
*** table.new 预分配
*** table.clear 清空复用
** OpenResty 扩展
*** table.isarray
*** table.nkeys
*** table.isempty
*** table.clone
** 共享内存字典
*** ngx.shared.DICT
*** 原子计数 incr
*** 队列 lpush/rpush/lpop/rpop
*** 只能存标量
@endmindmap