Lua Academy · 课时

tostring 和 len

Q: 「__tostring 和 __len」这节课中我会学到什么？

通过元方法控制字符串表示形式和 # 运算符的行为。 你通过在浏览器中直接运行的动手代码来练习 Lua Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

通过元方法控制字符串表示形式和 # 运算符的行为。

__tostring 和 __len 是 CoddyKit 上的免费 Lua Academy 课时。这是第 4 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Lua Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Lua Academy 课程共包含 4 节课。

__tostring 元方法

调用 tostring(obj) 时会调用 __tostring，print() 也会调用它（print() 会对每个参数调用 tostring）。定义它可以为自定义对象提供易于人类阅读的表示形式。

local Point = {}
Point.__index = Point
Point.__tostring = function(p)
  return string.format("Point(%.2f, %.2f)", p.x, p.y)
end

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

local p = Point.new(3.14, 2.72)
print(p)            -- Point(3.14, 2.72)
print(tostring(p))  -- Point(3.14, 2.72)

用于序列的 __len

对带有此元方法的表应用 # 运算符时，会调用 __len。在 Lua 5.2 及更高版本中，表始终会调用 __len；在 5.1 中，只有用户数据会调用它。您可以使用它为自定义容器定义“长度”。

local Queue = {}
Queue.__index = Queue
Queue.__len = function(q) return q._tail - q._head + 1 end

function Queue.new()
  return setmetatable({_data={},_head=1,_tail=0}, Queue)
end
function Queue:push(v)
  self._tail = self._tail + 1
  self._data[self._tail] = v
end
function Queue:pop()
  if self._head > self._tail then return nil end
  local v = self._data[self._head]
  self._head = self._head + 1
  return v
end

local q = Queue.new()
q:push("a"); q:push("b"); q:push("c")
print(#q)   -- 3

用于调试的丰富 __tostring

优秀的 __tostring 应包含类型名称和关键字段。对于嵌套对象，请递归调用 tostring。与默认的 "table: 0x..." 输出相比，这会让调试轻松得多。

local function tableToString(t, depth)
  depth = depth or 0
  if depth > 3 then return "{...}" end
  local parts = {}
  for k, v in pairs(t) do
    if type(v) == "table" then
      parts[#parts+1] = k.."="..tableToString(v, depth+1)
    else
      parts[#parts+1] = k.."="..tostring(v)
    end
  end
  return "{"..table.concat(parts,", ").."}"
end

local obj = {name="test", data={x=1,y=2}, active=true}
print(tableToString(obj))

__len 与 # 运算符

对于没有 __len 元方法的表，#t 会查找序列的某个边界（其中 t[i] ~= nil 且 t[i+1] == nil）。如果表中存在空缺，结果将无法预测。__len 让您可以定义权威且一致的长度。

-- Table with hole: # is unpredictable
local t = {10, 20, nil, 40}
print(#t)  -- could be 2 or 4, undefined!

-- Custom container with authoritative length
local SafeList = {}
SafeList.__index = SafeList
SafeList.__len = function(s) return s._size end

function SafeList.new()
  return setmetatable({_data={}, _size=0}, SafeList)
end
function SafeList:add(v)
  self._size = self._size + 1
  self._data[self._size] = v
end
local s = SafeList.new()
s:add(1); s:add(nil); s:add(3)
print(#s)   -- 3 (always correct)

错误消息中的 __tostring

当您使用错误对象（用表而不是字符串表示）时，定义 __tostring 可以让错误在传播并转换为字符串时显示为易读的错误消息。

local function makeError(code, msg)
  return setmetatable(
    {code=code, message=msg},
    {__tostring = function(e)
      return string.format("Error[%d]: %s", e.code, e.message)
    end}
  )
end

local ok, err = pcall(function()
  error(makeError(404, "resource not found"))
end)

if not ok then
  -- err is the error object (table)
  print(tostring(err))  -- may show table address...

继承中的 __tostring

使用基于原型的面向对象编程时，请在类元表上定义 __tostring。所有实例都会自动使用该类的 __tostring，因为实例的元表就是类表。

local Animal = {}
Animal.__index = Animal
Animal.__tostring = function(a)
  return string.format("%s(%s)", a._type or "Animal", a.name or "?")
end

function Animal.new(name, atype)
  return setmetatable({name=name, _type=atype}, Animal)
end

local cat = Animal.new("Whiskers", "Cat")
local dog = Animal.new("Rex", "Dog")
print(cat)  -- Cat(Whiskers)
print(dog)  -- Dog(Rex)

使用 len 和 tostring 实现集合

在一个类型中结合使用 __len 和 __tostring，即可实现完整且易于使用的集合。

local Set = {}
Set.__index = Set
Set.__len = function(s) return s._size end
Set.__tostring = function(s)
  local items = {}
  for k in pairs(s._data) do items[#items+1]=tostring(k) end
  table.sort(items)
  return "Set{" .. table.concat(items,", ") .. "}"
end

function Set.new(...)
  local obj = setmetatable({_data={},_size=0}, Set)
  for _, v in ipairs({...}) do
    if not obj._data[v] then obj._data[v]=true; obj._size=obj._size+1 end
  end
  return obj
end

local s = Set.new(3,1,4,1,5,9,2,6)
print(#s)         -- 7 (duplicates removed)
print(tostring(s)) -- Set{1, 2, 3, 4, 5, 6, 9}

同时使用两者的数值对象

创建一个分数类型：使用 __tostring 负责显示，使用 __len 返回数字位数（或某个特定领域的度量值）。

local Frac = {}
Frac.__index = Frac

local function gcd(a,b) return b==0 and a or gcd(b,a%b) end

function Frac.new(n,d)
  local g = gcd(math.abs(n), math.abs(d))
  return setmetatable({n=n//g, d=d//g}, Frac)
end

Frac.__tostring = function(f)
  if f.d==1 then return tostring(f.n) end
  return f.n .. "/" .. f.d
end

Frac.__add = function(a,b)
  return Frac.new(a.n*b.d + b.n*a.d, a.d*b.d)
end

local a = Frac.new(1,2)
local b = Frac.new(1,3)
print(a + b)   -- 5/6

覆盖默认的 print 行为

Lua 的 print 会对每个参数调用 tostring，并使用制表符分隔参数。定义 __tostring 后，您的对象就能在任何使用 tostring 的打印语句、错误消息或字符串插值中以有意义的形式显示。

local Color = {}
Color.__index = Color
Color.__tostring = function(c)
  return string.format("#%02X%02X%02X", c.r, c.g, c.b)
end

function Color.new(r,g,b)
  return setmetatable({r=r,g=g,b=b}, Color)
end

local red   = Color.new(255,0,0)
local green = Color.new(0,255,0)
local blue  = Color.new(0,0,255)

print(red, green, blue)
-- #FF0000  #00FF00  #0000FF

Lua 5.3+ 中的 __name

Lua 5.3+ 支持元表中的 __name 字段，默认错误消息会使用它来标识类型。虽然它不会直接影响 tostring()，但当您对该类型执行无效操作时，它会出现在运行时错误消息中。

local MyType = {}
MyType.__index = MyType
MyType.__name = "MyType"   -- used in error messages
MyType.__tostring = function(t)
  return "MyType(" .. tostring(t.value) .. ")"
end

local obj = setmetatable({value=42}, MyType)
print(obj)             -- MyType(42)

-- Error message will say "MyType" instead of "table"
-- pcall(function() local x = obj + 1 end)

快速检查

什么时候会调用 __tostring？

回顾：tostring 和 len

总结：

__tostring：由 tostring() 和 print() 调用
__len：由 #obj 调用；为自定义容器提供权威长度
在类表上定义 __tostring，即可应用于所有实例
当原始表结构无法提供正确的 # 结果时，使用 __len
__name（5.3+）会在错误消息中标识类型

常见问题解答

「tostring 和 len」课时是免费的吗？

是的 — 「__tostring 和 __len」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Lua Academy 课程的其余内容，请升级到 CoddyKit PRO。 Lua Academy 课程共包含 4 节课。

「tostring 和 len」这节课中我会学到什么？

通过元方法控制字符串表示形式和 # 运算符的行为。你通过在浏览器中直接运行的动手代码来练习 Lua Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Lua Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Lua Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 4 节课，共 4 节。

「tostring 和 len」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Lua Academy 课中编写并运行代码吗？

能。每节 Lua Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Lua Academy