Lua 语法核心特点

Lua 语法核心特点

1. 轻量简洁：关键字极少，只有约 20 个。

2. 动态类型：变量没有类型，值才有类型。你可以直接写 a = 10，然后再写 a = "hello"。

3. 解释执行：通常不需要编译，由 Lua 解释器直接运行。

4. “可嵌入性”：设计初衷就是作为嵌入式扩展语言，能轻松与 C/C++、Java、C# 等主程序交互。

5. “多重编程范式”：支持过程式、面向对象（通过 table 和 function）、函数式编程。

一、基础语法结构

1. 注释

注释是代码中不会被解释器执行的部分，用于说明。

lua

-- 这是单行注释

--[[
    这是多行注释
    可以写很多内容
]]

2. 标识符与关键字

• 标识符：变量、函数的名字。规则：以字母或下划线开头，后跟字母、数字、下划线。区分大小写（myVar 和 myvar 是不同的）。

• 关键字（保留字）：以下这些单词不能用作标识符。

  text

  and       break     do        else      elseif
  end       false     for       function  goto
  if        in        local     nil       not
  or        repeat    return    then      true
  until     while

3. 变量与数据类型

变量无需声明，赋值即创建。未赋值的变量值为 nil。

使用 type() 函数可以获取值的类型：

lua

print(type("Hello"))  -- > string
print(type(10.4))     -- > number
print(type(print))    -- > function
print(type(true))     -- > boolean
print(type(nil))      -- > nil
print(type({}))       -- > table

二、核心语法详解

1. 控制流

a) 条件语句 (if, elseif, else)

lua

local score = 85

if score >= 90 then
    print("优秀")
elseif score >= 70 then -- 注意是 elseif，不是 else if
    print("良好")
else
    print("再接再厉")
end -- 必须以 end 结尾

注意：Lua 中 只有 nil 和 false 被视为假，数字 0 和空字符串 "" 都被视为真。

b) 循环语句

• while 循环：

  lua

  local i = 1
  while i <= 5 do
      print(i)
      i = i + 1
  end

• repeat 循环（相当于 do...while）：

  lua

  local i = 1
  repeat
      print(i)
      i = i + 1
  until i > 5 -- 直到条件为真时停止

• for 循环：

  • 数字 for：

    lua

    -- 从 1 开始，到 5 结束，步长为 1
    for i = 1, 5, 1 do
        print(i)
    end
    -- 输出：1 2 3 4 5
    
    -- 步长可为负
    for i = 5, 1, -1 do
        print(i)
    end
    -- 输出：5 4 3 2 1

  • 泛型 for（用于遍历表）：

    lua

    local t = {"a", "b", "c"}
    -- ipairs 用于遍历序列（连续数字索引的数组）
    for index, value in ipairs(t) do
        print(index, value)
    end
    -- 输出：
    -- 1   a
    -- 2   b
    -- 3   c
    
    local p = {name="Lua", version="5.4"}
    -- pairs 用于遍历所有键值对
    for key, value in pairs(p) do
        print(key, value)
    end
    -- 输出（顺序可能不同）：
    -- name    Lua
    -- version 5.4

2. 函数 (Function)

函数使用 function 关键字定义。

• 定义与调用：

  lua

  -- 定义
  function greet(name)
      return "Hello, " .. name .. "!" -- .. 是字符串连接符
  end
  
  -- 调用
  local message = greet("World")
  print(message) -- > Hello, World!

• 匿名函数与高阶函数：

  lua

  -- 匿名函数赋值给变量
  local add = function(a, b)
      return a + b
  end
  print(add(5, 3)) -- > 8
  
  -- 函数作为参数（高阶函数）
  function calculate(x, y, operation)
      return operation(x, y)
  end
  
  local result = calculate(10, 2, function(a, b) return a * b end)
  print(result) -- > 20

• 多返回值：

  lua

  function getDimensions()
      return 1024, 768
  end
  
  local width, height = getDimensions()
  print(width, height) -- > 1024  768

3. 表 (Table) - Lua 的核心

Table 是 Lua 中唯一的数据结构，它非常灵活。

• 作为数组（列表）：

  lua

  local fruits = {"apple", "banana", "cherry"}
  print(fruits[1]) -- 注意：Lua 索引通常从 1 开始！ > apple
  print(#fruits)   -- # 运算符获取数组部分的长度 > 3

• 作为字典（映射）：

  lua

  local person = {
      name = "Alice",
      age = 30,
      ["home address"] = "123 Main St" -- 如果键包含特殊字符，需要用方括号和引号
  }
  print(person.name)          -- > Alice (点操作符，键必须是合法标识符)
  print(person["age"])        -- > 30   (方括号操作符，更通用)
  print(person["home address"]) -- > 123 Main St

• 混合使用：

  lua

  local mixed = {
      "value1",           -- 自动获得索引 1
      "value2",           -- 自动获得索引 2
      key1 = "value3",    -- 键值对
      key2 = "value4"
  }
  print(mixed[1], mixed.key1) -- > value1  value3

三、重要概念

1. 作用域与 local 关键字

默认情况下，变量是全局的！ 使用 local 关键字来创建局部变量，这是一个非常重要的最佳实践。

lua

globalVar = "I am global" -- 全局变量（避免使用）
local localVar = "I am local" -- 局部变量

function test()
    local funcVar = "Visible only in this function"
    print(funcVar)
end

test()
print(globalVar) -- 可以访问
print(localVar)  -- 可以访问
-- print(funcVar) -- 错误！funcVar 在这里不存在

2. 模块化

你可以将代码写在不同的 .lua 文件中，然后用 require 函数加载它们。

• mymodule.lua:

  lua

  local M = {} -- 创建一个空的表来表示模块
  
  function M.sayHello()
      print("Hello from module!")
  end
  
  local privateFunction = function()
      -- 这是一个私有函数，外部无法访问
  end
  
  return M -- 返回这个表

• main.lua:

  lua

  local mymodule = require("mymodule") -- 加载模块（省略.lua扩展名）
  mymodule.sayHello() -- > Hello from module!

总结

Lua 的语法精髓在于：

1. 简单：关键字少，结构清晰。

2. 灵活：table 一统天下，既可作数组也可作字典。

3. 实用：多返回值、匿名函数、泛型 for 循环等特性让代码写起来非常高效。

4. 明确：使用 local 明确作用域，使用 require 实现模块化。

要掌握 Lua，最重要的就是多练习使用 table 和 function，并时刻牢记使用 local 来声明变量。