变量
Variables are places that store values. There are three kinds of variables in Lua: global variables, local variables, and table fields.
A single name can denote a global variable or a local variable (or a function's formal parameter, which is a particular kind of local variable):
var ::= Name
Name denotes identifiers, as defined in §2.1.
Any variable is assumed to be global unless explicitly declared as a local (see §2.4.7). Local variables are lexically scoped: local variables can be freely accessed by functions defined inside their scope (see §2.6).
Before the first assignment to a variable, its value is nil.
变量分三种类型 全局（默认），本地（local 修饰），表中的域，变量在赋值之前 值是nil
Square brackets are used to index a table:
var ::= prefixexp `[´ exp `]´
The meaning of accesses to global variables and table fields can be changed via metatables. An access to an indexed variable t[i] is equivalent to a call gettable_event(t,i). (See §2.8 for a complete description of the gettable_event function. This function is not defined or callable in Lua. We use it here only for explanatory purposes.)
The syntax var.Name is just syntactic sugar for var["Name"]:
var ::= prefixexp `.´ Name
All global variables live as fields in ordinary Lua tables, called environment tables or simply environments (see §2.9). Each function has its own reference to an environment, so that all global variables in this function will refer to this environment table. When a function is created, it inherits the environment from the function that created it. To get the environment table of a Lua function, you call getfenv. To replace it, you call setfenv. (You can only manipulate the environment of C functions through the debug library; (see §5.9).)
An access to a global variable x is equivalent to _env.x, which in turn is equivalent to
gettable_event(_env, "x")
where _env is the environment of the running function. (See §2.8 for a complete description of the gettable_event function. This function is not defined or callable in Lua. Similarly, the _env variable is not defined in Lua. We use them here only for explanatory purposes.)
var.Name=var["Name"]
2.4.1 – Chunks
The unit of execution of Lua is called a chunk. A chunk is simply a sequence of statements, which are executed sequentially. Each statement can be optionally followed by a semicolon:
chunk ::= {stat [`;´]}
There are no empty statements and thus ';;' is not legal.
Lua handles a chunk as the body of an anonymous function with a variable number of arguments (see §2.5.9). As such, chunks can define local variables, receive arguments, and return values.
A chunk can be stored in a file or in a string inside the host program. To execute a chunk, Lua first pre-compiles the chunk into instructions for a virtual machine, and then it executes the compiled code with an interpreter for the virtual machine.
Chunks can also be pre-compiled into binary form; see program luac for details. Programs in source and compiled forms are interchangeable; Lua automatically detects the file type and acts accordingly.
Lua中一行代码叫chunk ，可以保存在文件内，也可以为一个嵌入式的代码中的一个字符串，块在执行之前 会执行预编译，然后在虚拟机上解释执行,可以选择性的以分号结束
2.4.2 – Blocks
A block is a list of statements; syntactically, a block is the same as a chunk:
block ::= chunk
A block can be explicitly delimited to produce a single statement:
stat ::= do block end
Explicit blocks are useful to control the scope of variable declarations. Explicit blocks are also sometimes used to add a return or break statement in the middle of another block (see §2.4.4).
一组语句构成一个 Block
2.4.3 – Assignment
Lua allows multiple assignments. Therefore, the syntax for assignment defines a list of variables on the left side and a list of expressions on the right side. The elements in both lists are separated by commas:
stat ::= varlist `=´ explist
varlist ::= var {`,´ var}
explist ::= exp {`,´ exp}
Expressions are discussed in §2.5.
Before the assignment, the list of values is adjusted to the length of the list of variables. If there are more values than needed, the excess values are thrown away. If there are fewer values than needed, the list is extended with as many nil's as needed. If the list of expressions ends with a function call, then all values returned by that call enter the list of values, before the adjustment (except when the call is enclosed in parentheses; see §2.5).
The assignment statement first evaluates all its expressions and only then are the assignments performed. Thus the code
i = 3
i, a[i] = i+1, 20
sets a[3] to 20, without affecting a[4] because the i in a[i] is evaluated (to 3) before it is assigned 4. Similarly, the line
x, y = y, x
exchanges the values of x and y, and
x, y, z = y, z, x
cyclically permutes the values of x, y, and z.
The meaning of assignments to global variables and table fields can be changed via metatables. An assignment to an indexed variable t[i] = val is equivalent to settable_event(t,i,val). (See §2.8 for a complete description of the settable_event function. This function is not defined or callable in Lua. We use it here only for explanatory purposes.)
An assignment to a global variable x = val is equivalent to the assignment _env.x = val, which in turn is equivalent to
settable_event(_env, "x", val)
where _env is the environment of the running function. (The _env variable is not defined in Lua. We use it here only for explanatory purposes.)
在Lua中支持变量和值在一个语句中完成多个赋值操作，变量和值 以等号=分开左右两部分，多个变量之间用逗号分开，多个值之间也用逗号分开， 如果右侧存在表达式，则先计算表达式，再完成给左侧变量赋值 如果变量的个数比值 （或表达式） 的个数多，侧从左到右匹配不到的变量将赋nil,如果等号右侧的值（表达式）的个数多于变量的个数，那么多佘的值将被丢弃。 例如：
标签：function,--,variables,学习,Lua,values,variable,chunk From： https://www.cnblogs.com/hztech/p/17179359.html