添加的内容 删除的内容
无编辑摘要 |
无编辑摘要 |
||
第237行:
表要用一对花括号创建。空表是<code>{}</code>。创建有多个字段的表时,逗号和分号可以分隔表中的各个字段。表的内容可以用以下形式表示:
* <code
* <code
* <code>''[[#Expressions|表达式]]''</code>大致相当于<code
表中的字段用中括号访问,例如<code>table[key]</code>。字符串键(key)同样也可以用作点来表示的[[#name|名字]],例如<code>table.key</code>就与<code>table['key']</code>等价。调用表中的一个函数也可以用冒号,例如<code
{{Anchor|sequence}}
第311行:
以下元表字段可以影响表本身:
; __index
: 如果表访问<code>t[key]</code>返回nil就使用这个。 如果这个字段的值是表,访问就会在这个表中重复进行,例如<code>__index[''键'']</code>(会调用这个表的元表的__index)。 如果这个字段的值是函数,函数就会像<code
; __newindex
: 这个元方法用于将键赋值到表中,即<code
; __call
: 对表应用函数调用语法<code
; {{Anchor|weak tables}}__mode
: 这用于使表保持弱引用(weak references)。 这个值一定是一个字符串。 默认情况下,任何一个值被作为表格中的键或值时是不会被垃圾回收的。 但如果元表字段包含字母k,且没有非弱引用,键可能会被作为垃圾收集。而且如果包含v则值有可能也会作为垃圾收集;其他的情况,对应的键和值都会从表中移除。 注意,如果在表用作元表之后字段被改变,则行为未定义。
第389行:
| / || 除法 || a / b || __div || 除以零不会出错,会返回NaN或者无穷大
|-
| % || 模运算 || a % b || __mod || 定义为<code
|-
| ^ || 幂运算 || a ^ b || __pow || 允许非整数指数
第400行:
Lua的关系运算符是<code>==</code>、<code>~=</code>、<code><</code>、<code>></code>、<code><=</code>和<code>>=</code>。关系运算的结果一定是布尔值(boolean)。
等于号(<code>==</code>)首先比较两个值的种类;如果两个值是不同的种类,结果为假(false)。然后比较值:空值、布尔值、数字和字符串照常比较。对于函数,则是看两个函数是否引用同一个准确的函数对象;像这样检测两个不同的(但作用相同的)匿名函数<code
不等号(<code>~=</code>)与等于号作用相反。
第406行:
对于排序运算符,如果两者都是数字,或者两者都是字符串,则直接进行比较。其次检查元方法:
* <code
* <code
* <code
* <code
如果必需的元方法不可用,会产生错误。
第423行:
对于<code>not</code>,其结果一定是布尔值(true或false)。
注意由<code>and</code>和<code>or</code>组成的简短语句。例如,<code
==== 连接运算符 ====
连接运算符就是两个点(dot),比如<code
注意Lua的字符串是不可变的(immutable),而且Lua不提供任何类型的“字符串构造器(string builder)”,所以反复进行<code
==== 长度运算符 ====
第458行:
# or
在同一级中,二元运算符会从左到右运算,例如<code
{{Anchor|Function calls}}
第562行:
</syntaxhighlight>
[[#select|select()]]函数就是用来作用于这些参数表达式的;特别地,如要获取参数表达式的值的数量,应当使用<code
Lua为将函数声明和赋值提供到变量中提供语法糖;参见[[#Function declaration statements|函数声明语句]]的细节。
第588行:
{{Anchor|block}}
'''语句块(block)'''也是语句序列,就像一个代码块(chunk)。语句块可以被分隔以创建单个语句(statement):<code
==== 赋值 ====
<code
''var-list''是由逗号分隔的变量;''表达式列表''是由逗号分隔的一组一个或多个表达式。所有的表达式都会在赋值之前被求值,所以<code
==== 局部变量定义 ====
<code
<code
局部变量可以在一个[[#block|语句块]]或[[#block|代码块]]内任意地方声明。第一种形式,不需要表达式列表,声明变量但不赋值,所以这些变量都会将nil作为值二中形式,为局部变量赋值,参见上面的[[#Assignments|赋值]]。
注意:局部变量显式声明于local关键字后面,形式为''local 变量名''。比如语句 <code
==== 控制结构 ====
{{Anchor|while}}
<code
只要''表达式''还是(视为)true时,就会反复执行while语句。
{{Anchor|repeat}}
<code
反复执行''语句块'',直到''表达式''(视为)是true。语句块内声明的局部变量可以用于表达式中。
{{Anchor|for}}
<code
<code
for循环的第一种形式会声明一个局部变量,然后从''exp1''以''exp3''的步长到''exp2''重复语句块。注意''exp3''可以省略,相当于1,但是非数字值比如<code>nil</code>和<code>false</code>是错误的。循环开始前,所有的表达式都会先被计算。
第639行:
{{Anchor|iterators}}
<code
第二种形式的for循环会与'''迭代'''函数一起作用。就像在第一种形式里,''表达式列表''会在开始循环之前就赋值了。
第663行:
{{Anchor|if}}
<code
当''表达式1''返回true时执行''语句块1'',否则,当''表达式2''返回true时执行''语句块2'',否则执行''语句块3''。<code
{{Anchor|return}}
<code
返回语句用来返回从函数或者[[#chunk|代码块]](只是一个函数)。''表达式列表''是由逗号分隔开的零个或更多个表达式。
第674行:
Lua实现[[尾调用|尾调用(tail calls)]]。如果表达式列表包含一个函数调用,对那个函数的调用会重新使用当前的堆栈项(stack frame)。这可用于处理调用堆栈的函数,比如<code>[[#getfenv|getfenv()]]</code>和<code>[[#debug.traceback|debug.traceback()]]</code>。
返回语句必须是[[#block|语句块]]的最后一个语句。如果某些原因语句块的中间需要返回,那么可能需要明显的语句块<code
{{Anchor|break}}
第681行:
break语句用来中止一个while、repeat或for循环的执行,并跳到循环后面的语句。
break声明必须是[[#block|语句块(block)]]的最后一个声明。如果某些原因语句块的中间需要中断,那么可能需要明显的语句块<code
==== 函数调用作为语句 ====
第766行:
==== assert ====
<code
如果<code>v</code>是nil或false,抛出错误,<code>message</code>就会用作错误的文本:如果错误文本为nil(或者未指定),则文本是"assertion failed!"(“断言失败!”);如果是字符串或者数字,文字就是那个值;否则assert本身就会抛出错误。
第783行:
==== error ====
<code
用文本<code>message</code>来发出一个错误。
第790行:
==== getfenv ====
<code
注意,这个函数可能会无效,取决于配置中的<code>allowEnvFuncs</code>。
第803行:
==== getmetatable ====
<code
返回这个[[#table|表]]的[[#Metatables|元表]]。其他的类型都会返回nil。
第810行:
==== ipairs ====
<code
返回3个值:迭代函数、表<code>t</code>和0。它是供[[#iterators|<code>for</code>的迭代形式]]使用的:
第822行:
它会迭代数对(1, t[1])、(2,t[2])等,直到t[i]是nil时。
如果<code>__ipairs</code>[[#Metatables|元方法]]存在,那么标准行为会被覆盖,调用会返回与<code
==== next ====
<code
允许遍历表中的键。如果<code>key</code>是nil或者未指定,返回表中的第一个键和值,否则,返回下一个键和值。如果没有更多的键可以用,返回nil。可以通过使用<code
注意键被返回的顺序是没有指定的,即使表有数字的索引(indexes)。如要以数字顺序遍历表,使用[[#for|数字的for]]或[[#ipairs|ipairs]]。
第834行:
==== pairs ====
<code
返回三个值:迭代器函数([[#next|next]]或者类似的)、表<code>t</code>和nil。这是用于[[#iterators|<code>for</code>的迭代器形式]]。
第846行:
这会遍历<code>t</code>中的键值对,就像[[#next|next]]做的那样。参考[[#next|next]]的文档以了解遍历期间修改表的限制。
如果__pairs[[#Metatables|元方法]]存在,那么标准行为会被覆盖,调用会返回与<code
==== pcall ====
<code
用指定的参数在“保护模式”下调用函数<code>f</code>。这意味着如果在调用<code>f</code>时出错,pcall会返回false与错误消息。如果没有错误发生,pcall会返回true与调用返回的所有值。
第866行:
==== rawequal ====
<code
与<code
==== rawget ====
<code
与<code>table[k]</code>相同,只是忽略了所有__index[[#Metatables|元方法]]。
==== rawset ====
<code
与<code
==== select ====
<code
如果<code>index</code>是数字,返回index之后的<code>...</code>中对应位置的数。如果<code>index</code>是字符串"#",返回<code>...</code>中参数的个数。
第899行:
==== setmetatable ====
<code
设置[[#table|表]]的[[#Metatables|元表]],<code>metatable</code>可能是nil,但是必须是清楚地提供的。
第906行:
==== tonumber ====
<code
尝试将<code>value</code>转化为数字。如果已经是数字或者可以转化为数字的字符串,<code>tonumber</code>就会返回这个数字,否则会返回nil。
第915行:
==== tostring ====
<code
将<code>value</code>转化为字符串。参考上方的[[#Data types|数据类型]]以了解各种类型被转换时的细节。
对于表,标准的转换行为可以被__tostring[[#mw.language:formatDate|元方法]]覆盖。如果这个元方法存在,那么调用tostring会返回由<code
==== type ====
<code
以字符串形式返回<code>value</code>的类型<code>"[[#nil|nil]]"</code>、<code>"[[#number|number]]"</code>、<code>"[[#string|string]]"</code>、<code>"[[#boolean|boolean]]"</code>、<code>"[[#table|table]]"</code>或<code>"[[#function|function]]"</code>。
==== unpack ====
<code
从给定的表返回值,像<code
注意如果<code>table</code>不是一个[[#sequence|序列]]且<code>j</code>是nil或未指定,则结果是不确定的,参考[[#Length operator|长度操作符]]以了解详细。
==== xpcall ====
<code
这个很像<code>[[#pcall|pcall]]</code>,只是错误消息在返回之前传递到函数<code>errhandler</code>中。
第953行:
==== debug.traceback ====
<code
以字符串的形式返回调用栈。可选的message参数会被连接到调用栈信息的前面。可选的level参数表示返回多少层调用栈。
第960行:
==== math.abs ====
<code
返回<code>x</code>的绝对值。
==== math.acos ====
<code
返回<code>x</code>的反余弦值(以弧度表示)。
==== math.asin ====
<code
返回<code>x</code>的反正弦值(以弧度表示)。
==== math.atan ====
<code
返回<code>x</code>的反正切值(以弧度表示)。
==== math.atan2 ====
<code
使用两个参数的符号(signs)以找到结果的象限,返回<code>y/x</code>的反正切值(弧度制)。
==== math.ceil ====
<code
返回不小于<code>x</code>的最小整数。
==== math.cos ====
<code
返回<code>x</code>(以弧度表示)的余弦值。
==== math.cosh ====
<code
返回<code>x</code>的双曲余弦值。
==== math.deg ====
<code
将弧度角<code>x</code>转化为角度。
==== math.exp ====
<code
返回<math>e^x</math>。
==== math.floor ====
<code
返回小于或等于<code>x</code>的最大整数。
==== math.fmod ====
<code
返回<code>x</code>除以<code>y</code>的余数,并将商舍入到零。比如,<code>math.fmod( 10, 3 )</code>产生<code>1</code>。
==== math.frexp ====
<code
返回像这样的两个值<code>m</code>和<code>e</code>:
第1,031行:
==== math.ldexp ====
<code
返回<math>m \times 2^e</math>(<code>e</code>是整数)。
==== math.log ====
<code
返回<code>x</code>的自然对数。
==== math.log10 ====
<code
返回<code>x</code>的以10为底的对数。
==== math.max ====
<code
返回其参数的最大值。
第1,053行:
==== math.min ====
<code
返回其参数的最小值。
第1,060行:
==== math.modf ====
<code
返回两个数字,<code>x</code>的整数部分和<code>x</code>的小数部分。比如,<code>math.modf( 1.25 )</code>产生<code>1, 0.25</code>。
第1,068行:
==== math.pow ====
<code
与<code>x^y</code>相同。
==== math.rad ====
<code
将角度<code>x</code>转化为弧度角。
==== math.random ====
<code
返回伪随机数。
第1,092行:
==== math.randomseed ====
<code
以<code>x</code>作为伪随机数生成器的[[伪随机数的种子|种子]]。
第1,099行:
==== math.sin ====
<code
返回 <code>x</code>(以弧度表示)的正弦值。
==== math.sinh ====
<code
返回<code>x</code>的双曲正弦值。
==== math.sqrt ====
<code
返回<code>x</code>的平方根。与<code>x^0.5</code>相同。
==== math.tan ====
<code
返回<code>x</code>(以弧度表示)的正切值。
==== math.tanh ====
<code
返回<code>x</code>的双曲正切值。
第1,131行:
==== os.date ====
<code
: ''[[#mw.language:formatDate|语言库的formatDate]]''可以被用于更加全面的日期格式。
第1,154行:
==== os.difftime ====
<code
返回从<code>t1</code>到<code>t2</code>两个时间的秒数。
==== os.time ====
<code
返回代表当前时间的数字。
第1,168行:
==== require ====
<code
加载指定的模块。
第1,211行:
==== package.seeall ====
<code
将<code>table</code>的__index[[#Metatables|元方法]]设置为[[#_G|_G]]。
第1,222行:
==== string.byte ====
<code
如果字符串被考虑为字节的数组,返回<code>s[i]</code>、<code>s[i+1]</code>、···、<code>s[j]</code>的字节值。<code>i</code>的默认值为1;<code>j</code>的默认值为<code>i</code>。等价于[[#mw.ustring.byte|mw.ustring.byte()]]。
==== string.char ====
<code
接受零个或更多个整数。返回和长度与参数个数相同的字符串,每个字符的字节值等于其对应的参数。
第1,238行:
==== string.find ====
<code
寻找字符串<code>s</code>中<code>[[#Patterns|pattern]]</code>的第一个匹配(match)。如果找到一个匹配,返回<code>s</code>中起止点的序列,否则返回nil。如果匹配模式有捕获物(capture),则在成功的匹配中被捕获的值也会被返回在两个索引之后。
第1,249行:
==== string.format ====
<code
返回变量数字的参数将第一个参数(必须是字符串)格式化后的版本。
第1,269行:
==== string.gmatch ====
<code
返回一个迭代器函数,每次被调用,都会从字符串<code>s</code>中的[[#Patterns|<code>pattern</code>]]返回下一个捕获。如果<code>pattern</code>不会指定捕获,则整个匹配都会在每次调用时产生。
第1,278行:
==== string.gsub ====
<code
将字符串<code>s</code>的所有(或者前<code>n</code>个,如果给定了)出现的[[#Patterns|<code>pattern</code>]]替换为由<code>repl</code>指定的替换物(replacement),这个替换物可以是字符串、表或者函数。<code>gsub</code>也会作为第二个值返回发生了的匹配的总次数。
第1,293行:
==== string.len ====
<code
返回字符串的字节长度。不会被ASCII NUL字符混淆。等同于[[#Length operator|#]]s。
第1,300行:
==== string.lower ====
<code
将字符串的所有ASCII大写字符转为小写后返回。所有其他字符不改变。
第1,307行:
==== string.match ====
<code
寻找字符串中[[#Patterns|<code>pattern</code>]]的第一个匹配,如果找到一个,则<code>match</code>返回从样式匹配中的捕获,否则返回nil。如果<code>pattern</code>不指定捕获,则返回整个字符串。
第1,316行:
==== string.rep ====
<code
返回字符串<code>s</code>重复<code>n</code>次并连接后的字符串。等价于[[#mw.ustring.rep|mw.ustring.rep()]]。
==== string.reverse ====
<code
返回字符串<code>s</code>被逆转后的字符串(按字节逆转)。
==== string.sub ====
<code
返回<code>s</code>的从<code>i</code>开始持续到<code>j</code>的子串(substring);<code>i</code>和<code>j</code>可以是负的。如果<code>j</code>是nil或未指定,则会一直到字符串末尾。
特别地,调用<code>string.sub(s,1,j)</code>会返回字符串<code>s</code>的长度<code>j</code>的前缀,而<code
参看[[#mw.ustring.sub|mw.ustring.sub()]]以了解使用字符而非字节值的类似函数。
==== string.upper ====
<code
将字符串的所有ASCII小写字符转为大写后返回。所有其他字符不改变。
第1,438行:
! scope="row" | <code>[{{var|set}}]</code>
|
代表集合{{var|set}}中所有字符的组合。一系列字符可以通过用'<code>-</code>'分隔字符末尾来指定。上面讲到的所有的<code>%{{var|x}}</code>都可以是{{var|set}}中的一部分。{{var|set}}中所有其他字符代表其自身。 例如,<code>[%w_]</code>(或<code>[_%w]</code>)代表所有的字母数字字符加上下划线,<code
范围和类之间的交互是没被定义的,因此像<code>[%a-z]</code>或<code>[a-%%]</code>这样的匹配模式没有含义。
第1,480行:
==== table.concat ====
<code
给一个所有元素都是字符串或数字的数组,返回<code
<code>sep</code>的默认值为空字符串,<code>i</code>的默认值为1,<code>j</code>的默认值为表的长度。如果<code>i</code>大于<code>j</code>,返回空字符串。
==== table.insert ====
<code
<br/>
<code
在表<code>table</code>的位置<code>pos</code>处插入元素<code>value</code>,会将其他元素的位置增加1以给这个元素提供插入空间。<code>pos</code>的默认值为表的长度加1,所以调用<code
大于<code>#table</code>的元素都会被提高,参考[[#Length operator|长度操作符]]以了解当表不是[[#sequence|序列]]时的注意事项。
==== table.maxn ====
<code
返回给定的表的最大正数索引,或者表没有正数索引时返回零。
第1,516行:
==== table.remove ====
<code
从表格<code>table</code>中移走位于<code>pos</code>处的元素,将后面的元素前移。<code>pos</code>的默认值为表的长度,所以调用<code
大于<code>#table</code>的元素都会被移动,参考[[#Length operator|长度操作符]]以了解当表不是[[#sequence|序列]]时的注意事项。
==== table.sort ====
<code
从<code>table[1]</code>到<code>table[#table]</code>,按照给定的次序给表的元素排序。如果给了<code>comp</code>,则它必须是接收两个表元素的函数,并且当第一个小于第二个时返回true(所以<code
排序算法并不稳定;也就是说,当两个元素按照给定的顺序被看作相等时,它们在排序后的相对位置可能会改变。
第1,536行:
==== mw.addWarning ====
<code
在预览编辑时加一个警告信息。<code>text</code>解析为维基文本。
==== mw.allToString ====
<code
对所有的参数调用[[#tostring|tostring()]],然后用制表符作为分隔符连接起来。
==== mw.clone ====
<code
深拷贝一个值。所有的表和它们的元表被重构,但是新表和旧表共用函数。
第1,566行:
==== mw.loadData ====
<code
有时一个模块需要大量表格的数据,例如,用于转换计量单位的通用模块可能需要一张大表的已识别的单位及其转换系数。而且有时这些模块会在一个页面中使用多次。每次<code><nowiki>{{#invoke:}}</nowiki></code>都解析大表格的数据会用大量时间。<code>mw.loadData()</code>正是为了避免这个问题。
第1,578行:
* 返回的表(和所有子表)不能有[[#Metatables|metatable]]元表。
* 所有的表键必须是布尔值、数字、字符串。
* 由<code>mw.loadData()</code>返回的表会元方法,可以提供只读获取由模块返回的表。因为不能直接包含数据,<code>[[#pairs|pairs()]]</code>和<code>[[#ipairs|ipairs()]]</code>会起作用,但是其他方法如<code>[[#Length operator|#值]]</code>、<code
上述假定的单位转换模块可能将其代码存储在“Module:Convert”然后将其数据存储在“Module:Convert/data”,且“Module:Convert”会使用<code
==== mw.dumpObject ====
<code
将<code>object</code>序列化为人类可读的字符串并返回。
第1,589行:
==== mw.log ====
{{Anchor|print}}
<code
将参数传递到[[#mw.allToString|mw.allToString()]],然后将结果字符串加载控制台后。
第1,596行:
==== mw.logObject ====
<code
<br/>
<code
调用[[#mw.dumpObject|mw.dumpObject()]]然后将结果加到控制台输出的后面。如果给了<code>prefix</code>,则会被加到控制台输出并紧随一个等于号在序列化字符串之前,比如输出的字符串可以是"prefix = object-string"。
第1,611行:
<nowiki>{{#invoke:module|function|arg1|arg2|name=arg3}}</nowiki>
那么<code>frame.args[1]</code>会返回<code>"arg1"</code>,<code>frame.args[2]</code>会返回<code>"arg2"</code>,<code>frame.args['name']</code>或<code>frame.args.name</code>会返回<code>"arg3"</code>。在参数列表迭代可以使用<code
然而由于Lua实现表迭代器,迭代的顺序不确定,参数出现在维基文本中的顺序也无从得知。
第1,618行:
在MediaWiki模板调用中,命名参数(named arguments)会在传递到Lua前移除名称和值的多余空格,而匿名参数(unnamed arguments)不会移除空格。
考虑到性能,<code>frame.args</code>使用元表,而非直接包含参数。参数值会从根据需求从MediaWiki请求得到。这意味着大多数其他表格方法不会正常生效,包括<code>[[#Length operator|#frame.args]]</code>、<code
如果在#invoke的参数中包含了像模板调用和三层括号变量这样的预处理器(preprocessor)语法,那么这些在传递到Lua之后不会被展开,直到值被Lua请求时才会展开。如果在#invoke的参数中包含了用XML标记形式写的特殊标签,例如<code><pre></code>、<code><nowiki></code>、<code><gallery></code>和<code><ref></code>,这些标签会被转化为[[strip marker]]——一种特殊字符串,由删除符(ASCII 127)开始,在从#invoke返回后转化为HTML。
==== frame:callParserFunction ====
<code
<br/>
<code
<br/>
<code
: ''注意使用了[[#named arguments|命名参数]]。''
第1,654行:
==== frame:expandTemplate ====
<code
: ''注意使用了[[#named arguments|命名参数]]。''
第1,675行:
==== frame:extensionTag ====
<code
<br/>
<code
这大致相当于调用[[#frame:callParserFunction|frame:callParserFunction()]],其函数名称为<code
<syntaxhighlight lang="lua">
第1,710行:
==== frame:newChild ====
<code
: ''注意使用了[[#named arguments|命名参数]]。''
第1,719行:
==== frame:preprocess ====
<code
<br/>
<code
在当前框架环境下展开维基文本,比如,模板、解析器函数以及像<code><nowiki>{{{1}}}</nowiki></code>这样的参数都会展开。某些特殊的写成XML格式的标记,比如<code><pre></code>、<code><nowiki></code>、<code><gallery></code>和<code><ref></code>都会被替换为“strip marker”——一类特殊的字符串,由删除符(ASCII 127)开头,在从<code>#invoke</code>返回后被替换成HTML。
第1,730行:
==== frame:getArgument ====
<code
<br/>
<code
获得特定参数的对象,或者没有提供参数时返回nil。
第1,739行:
==== frame:newParserValue ====
<code
<br/>
<code
返回有一个方法<code>object:expand()</code>的对象,该方法可以返回<code
==== frame:newTemplateParserValue ====
<code
: ''注意使用了[[#named arguments|命名参数]]。''
第1,755行:
<code>frame:argumentPairs()</code>
等同于<code
=== 哈希库 ===
==== mw.hash.hashValue ====
<code
按照指定的算法算出字符串的哈希值。可以通过[[#mw.hash.listAlgorithms|mw.hash.listAlgorithms()]]获得有效的算法。
==== mw.hash.listAlgorithms ====
<code
返回支持的哈希算法的列表,以用于[[#mw.hash.hashValue|mw.hash.hashValue()]]。
第1,790行:
==== mw.html.create ====
<code
创建一个新的mw.html对象,其包含一个标签名称为<code>tagName</code>的HTML元素。你也可以传递一个空的字符串或nil作为<code>tagName</code>,以创建一个新的空的mw.html对象。
第1,800行:
==== mw.html:node ====
<code
向当前的mw.html实例附加mw.html(<code>builder</code>)子节点。如果传递nil,那么函数不做任何事。(<code>builder</code>)节点是要创建的HTML元素的种类的字符串代表。
==== mw.html:wikitext ====
<code
给mw.html对象加上不定数量的维基文本字符串。
第1,812行:
==== mw.html:newline ====
<code
给mw.html对象加新行。
==== mw.html:tag ====
<code
给mw.html对象添加一个新的节点,其标签名称为<code>tagName</code>,返回代表这个新的节点的mw.html实例。<code>args</code>参数和[[#mw.html.create|<code>mw.html.create</code>]]的参数是一样的。
==== mw.html:attr ====
<code
<br/>
<code
将节点的HTML属性的<code>name</code>属性的值设为<code>value</code>。也可以选择使用表,其键值对即为属性名称-值对。第一种形式中,如果值为nil,会导致这个给定名称的已被设置属性设为未被设置。
==== mw.html:getAttr ====
<code
获得已经通过[[#mw.html:attr|<code>html:attr()</code>]]设置的属性<code>name</code>的值。
==== mw.html:addClass ====
<code
给节点的类(class)属性添加一个类名称(class name)。如果参数为nil,则无效。
==== mw.html:css ====
<code
<br/>
<code
使用给定的<code>name</code>和<code>value</code>给节点设置CSS属性。也可以选择使用表,其键值对即为CSS名称-值对。第一种形式中,如果值为nil,会导致这个给定名称的已被设置的CSS设为未被设置。
==== mw.html:cssText ====
<code
给节点的属性添加一些纯<code>css</code>文本。如果参数为nil,则无效。
==== mw.html:done ====
<code
返回当前节点被创建时所在的上级节点。类似于jQuery.end,这是个方便地函数可以允许创建多个子节点,而由一个语句串在一起。
==== mw.html:allDone ====
<code
类似于[[#mw.html:done|<code>html:done()</code>]],但是会遍历直到树节点的根部再返回。
第1,868行:
==== mw.language.fetchLanguageName ====
<code
给定的语言代码的完整语言名称:默认为本地名称,如有<code>inLanguage</code>的值,则是被翻译为目标语言的语言名称。
==== mw.language.fetchLanguageNames ====
<code
<br/>
<code
<br/>
<code
获取MediaWiki已知的语言列表,返回将语言代码映射到语言名称的表。
第1,894行:
==== mw.language.getFallbacksFor ====
[[File:MediaWiki fallback chains.svg|thumb|备选链]]
<code
返回MediaWiki针对指定语言代码的备选语言代码列表。
==== mw.language.isKnownLanguageTag ====
<code
若语言代码为MediaWiki已知的语言,返回true。
第1,906行:
==== mw.language.isSupportedLanguage ====
<code
检查MediaWiki的语言代码内是否有任何本地化可用。
第1,915行:
==== mw.language.isValidBuiltInCode ====
<code
如果语言代码是用于MediaWiki内部自定义的有效形式,返回true。
第1,926行:
==== mw.language.isValidCode ====
<code
若语言代码字符串是有效形式的,返回true,无论其是否存在。这包括了所有单独用于通过MediaWiki命名空间自定义使用的语言代码。
第1,935行:
==== mw.language.new ====
<code
<br/>
<code
创建新的语言对象。语言对象没有任何可公开获取的属性,不过可以含有几个方法,下面列出。
第1,944行:
==== mw.language:getCode ====
<code
返回这个语言对象的语言代码。
==== mw.language:getFallbackLanguages ====
<code
返回MediaWiki针对此语言对象的备选语言代码列表。等同<code
==== mw.language:isRTL ====
<code
若语言是从右至左写的,返回true,否则返回false。
==== mw.language:lc ====
<code
将字符串转化为小写,但遵从给定的语言的任何特殊规则。
当加载了[[#Ustring library|ustring库]],[[#mw.ustring.lower|mw.ustring.lower()]]函数就会通过调用<code
==== mw.language:lcfirst ====
<code
将字符串的第一个字符转化为小写,就像[[#mw.language:lc|lang:lc()]]那样。
==== mw.language:uc ====
<code
将字符串转化为大写,但遵从给定的语言的任何特殊规则。
当加载了[[#Ustring library|ustring库]],[[#mw.ustring.upper|mw.ustring.upper()]]函数就会通过调用<code
==== mw.language:ucfirst ====
<code
将字符串的第一个字符转化为大写,就像[[#mw.language:uc|lang:lc()]]那样。
==== mw.language:caseFold ====
<code
将字符串转换为不区分大小写的比较表示形式。注意,显示其结果可能无任何意义。
==== mw.language:formatNum ====
<code
<br/>
<code
格式化数字,使用给定语言的合适的分组符合小数点。给予123456.78,可能会产生123,456.78、123.456,78或甚至١٢٣٬٤٥٦٫٧٨,取决于语言和wiki配置。
第1,999行:
==== mw.language:formatDate ====
<code
根据给定的格式字符串格式化一个日期。如果省略了<code>timestamp</code>,默认为当前时间。<code>local</code>的值必须是boolean或nil,如果是true,时间会格式化为wiki的当地时间而非UTC。
第2,018行:
==== mw.language:formatDuration ====
<code
<br/>
<code
将秒数的时间间隔转化为更加已读的单位,例如12345转化为3 hours, 25 minutes and 45 seconds(3时25分45秒),作为字符串返回结果。
第2,027行:
==== mw.language:parseFormattedNumber ====
<code
这需要一个以[[#mw.language:formatNum|lang:formatNum()]]格式化的数字,并返回实际数字。换句话说,这基本上是[[#tonumber|<code>tonumber()</code>]]根据语言转换的版本。
第2,033行:
==== mw.language:convertPlural ====
{{Anchor|mw.language:plural}}
<code
<br/>
<code
<br/>
<code
<br/>
<code
从<code>forms</code>(必须是[[#sequence|序列]]表)或<code>...</code>基于数字<code>n</code>选择合适的语法形式。例如,在英语你必须使用<code
序列的必填值取决于语言,详见[[mw:Help:Magic words#Localization|魔术字的本地化]]和[[translatewiki:Special:MyLanguage/FAQ#PLURAL|translatewiki针对PLURAL的常见问题]]。
第2,047行:
==== mw.language:convertGrammar ====
{{Anchor|mw.language:grammar}}
<code
<br/>
<code
: ''注意两个别称之间的不同参数顺序。<code>convertGrammar</code>匹配MediaWiki的Language对象的相同名称的方法的顺序,而<code>grammar</code>匹配相同名称的解析器函数的顺序,可参考帮助:魔术字#本地化。''
第2,058行:
==== mw.language:gender ====
<code
<br/>
<code
选择对应<code>what</code>的性别的字符串,可以是male、female或注册的用户名。
==== mw.language:getArrow ====
<code
返回对应方向<code>direction</code>的Unicode箭头字符:
第2,077行:
==== mw.language:getDir ====
<code
根据语言的书写方向,返回"ltr"(从左至右)或"rtl"(从右至左)。
==== mw.language:getDirMark ====
<code
返回包含U+200E(从左至右标记)或U+20F(从右至左标记)的字符串,取决于语言的书写方向以及<code>opposite</code>的值。
==== mw.language:getDirMarkEntity ====
<code
返回“&lrm;”或“&rlm;”,取决于语言的书写方向和<code>opposite</code>的值。
==== mw.language:getDurationIntervals ====
<code
<br/>
<code
将秒数的时间间隔转化为更加已读的单位,例如12345转化为3 hours, 25 minutes and 45 seconds(3时25分45秒),返回从单位名称映射到数字的表。
第2,110行:
==== mw.message.new ====
<code
创建一个给定消息<code>key</code>的新消息对象。
第2,118行:
==== mw.message.newFallbackSequence ====
<code
创建给定的消息的新的消息对象(存在的第一个会被使用)。
第2,125行:
==== mw.message.newRawMessage ====
<code
创建新的消息对象,使用给定的文本,而不是查找国际化的(internationalized)消息。剩下的参数会传递到新对象的<code>[[#mw.message:params|params()]]</code>方法中。
第2,132行:
==== mw.message.rawParam ====
<code
包装(wrap)该值使之不会被<code>[[#mw.message:parse|msg:parse()]]</code>解析为维基文本。
==== mw.message.numParam ====
<code
包装(wrap)该值使之自动被格式化为<code>[[#mw.language:formatNum|lang:formatNum()]]</code>。注意这不依赖事实上有效的[[#Language library|语言库]]。
==== mw.message.getDefaultLanguage ====
<code
返回默认语言的语言对象。
==== mw.message:params ====
<code
<br/>
<code
给消息添加参数,参数可以一被传递为独立的参数或者作为一个[[#sequence|序列]]表。参数必须是数字、字符串或由[[#mw.message.numParam|mw.message.numParam()]]或[[#mw.message.rawParam|mw.message.rawParam()]]返回的特殊的值。如果使用序列表,参数必须是直接出现在表中,使用[[#Metatables|__index元方法]]的参考不起作用。
第2,156行:
==== mw.message:rawParams ====
<code
<br/>
<code
像[[#mw.message:params|:params()]],但是会先通过[[#mw.message.rawParam|mw.message.rawParam()]]传递所有的参数。
第2,165行:
==== mw.message:numParams ====
<code
<br/>
<code
像[[#mw.message:params|:params()]],但是会先通过[[#mw.message.numParam|mw.message.numParam()]]传递所有的参数。
第2,174行:
==== mw.message:inLanguage ====
<code
指定一个语言,以在加工消息时使用。<code>lang</code>可以是字符串,或者带有<code>getCode()</code>元表的表(比如[[#Language library|语言对象]])。
第2,183行:
==== mw.message:useDatabase ====
<code
指定是否在MediaWiki:命名空间查找消息(比如在数据库中查找),或者只是使用MediaWiki分配的默认消息。
第2,192行:
==== mw.message:plain ====
<code
替换参数按原样返回消息维基文本。模板调用和解析器函数都是完整的。
==== mw.message:exists ====
<code
返回表示消息键是否存在的布尔值。
==== mw.message:isBlank ====
<code
返回表示消息键是否有内容的布尔值。当消息键不存在或者消息是空字符串时返回true。
==== mw.message:isDisabled ====
<code
返回表示消息键是否被禁用的布尔值。如果消息键不存在,或者消息是空字符串,或者是字符串"-"则返回true。
第2,274行:
==== mw.site.stats.pagesInCategory ====
<code
: {{red|这个函数是高开销函数}}
第2,290行:
==== mw.site.stats.pagesInNamespace ====
<code
返回给定的命名空间(由数字指定)的页面数量。
==== mw.site.stats.usersInGroup ====
<code
返回给定的用户组的用户数量。
==== mw.site.interwikiMap ====
<code
返回包含可用的跨wiki前缀的数据的表。如果<code>filter</code>是字符串"local",则只会返回关于本地跨wiki前缀的数据。如果<code>filter</code>是字符串"!local",则只会返回非本地跨wiki前缀的数据。如果没有指定filter,则所有的前缀的数据都会返回。这个"local"前缀是同一个项目的。比如在英文维基百科,其他语言的维基百科都会考虑为本地的(local),而维基词典不会。
第2,321行:
==== mw.text.decode ====
<code
<br/>
<code
将字符串中的[[HTML元素|HTML元素]]替换为对应的字符。
第2,330行:
==== mw.text.encode ====
<code
<br/>
<code
使用[[HTML实体|HTML实体]]替换字符串中的字符。字符“<”“>”“&”“"”和非换行空格会被适当的命名实体替换,所有其他的都会被替换为数字实体。
第2,339行:
==== mw.text.jsonDecode ====
<code
<br/>
<code
解析JSON字符串。<code>flags</code>是0或flags<code>mw.text.JSON_PRESERVE_KEYS</code>和<code>mw.text.JSON_TRY_FIXING</code>的组合(使用<code>+</code>)。
第2,357行:
==== mw.text.jsonEncode ====
<code
<br/>
<code
编码JSON字符串。如果传入的值不能被JSON编码则会报错。<code>flags</code>是0或flags<code>mw.text.JSON_PRESERVE_KEYS</code>和<code>mw.text.JSON_PRETTY</code>的组合(使用<code>+</code>)。
第2,374行:
==== mw.text.killMarkers ====
<code
除去字符串中所有的[[strip marker]]。
==== mw.text.listToText ====
<code
<br/>
<code
使用自然语言组合一个列表,类似于<code>[[#table.concat|table.concat()]]</code>,但是最后一项前面的分隔符不同。
第2,406行:
==== mw.text.nowiki ====
<code
使用[[HTML实体|HTML实体]]替换字符串中的多种字符,以避免被解析为维基文本。包括:
第2,419行:
==== mw.text.split ====
<code
在匹配了[[#Ustring patterns|Ustring模式]]的<code>pattern</code>的地方分割字符串。如果指定了<code>plain</code>且为true,则<code>pattern</code>会被解释为纯字符串而不是Lua模式(就像<code>[[#mw.ustring.find|mw.ustring.find()]]</code>的这个参数一样)。返回包含子字符串的表。
比如,<code
如果<code>pattern</code>匹配空字符串,<code>s</code>会被分割成单个字符。
==== mw.text.gsplit ====
<code
返回会迭代子字符串的[[#iterators|迭代器函数]],返回的相当于调用<code>[[#mw.text.split|mw.text.split()]]</code>。
==== mw.text.tag ====
<code
<br/>
<code
: ''注意使用了[[#named arguments|命名参数]]。''
第2,448行:
==== mw.text.trim ====
<code
<br/>
<code
从字符串的开始和结尾移除空白字符或其他字符。
如果提供了<code>charset</code>,则它应该是合适的字符串,且被[[#Ustring patterns|Ustring模式]]的括号括住,比如<code>[set]</code>中的“set”。默认的charset是ASCII空白字符,<code
==== mw.text.truncate ====
<code
<br/>
<code
<br/>
<code
将文本<code>text</code>裁剪到指定的长度,如果执行了裁剪,加入<code>ellipsis</code>(省略号)。如果长度为正,则字符串末尾被裁剪,如果为负,则字符串的开头会被裁剪。如果给定了<code>adjustLength</code>且为true,则包含省略号的字符串不会长于指定的长度。
第2,487行:
==== mw.text.unstripNoWiki ====
<code
将MediaWiki的<nowiki> [[strip marker]]替换为对应的文本。其他类型的strip marker不会改变。
==== mw.text.unstrip ====
<code
等同于<code
这个不在显示特殊页面嵌入包含、<ref>后的HTML,就像Scribunto早期版本的那样。
第2,501行:
==== mw.title.equals ====
<code
检测两个标题是否相等。注意比较时忽略碎片(fragments)。
==== mw.title.compare ====
<code
返回-1、0、1,表示标题<code>a</code>是否小于、等于或大于标题<code>b</code>。
第2,513行:
==== mw.title.getCurrentTitle ====
<code
返回当前页面的标题对象。
==== mw.title.new ====
<code
<br/>
<code
: {{red|用ID调用时该函数是高开销函数}}
第2,531行:
==== mw.title.makeTitle ====
<code
创建命名空间<code>namespace</code>内标题<code>title</code>的标题对象,可以有指定的<code>fragment</code>和<code>interwiki</code>前缀。<code>namespace</code>可以是在<code>[[#mw.site.namespaces|mw.site.namespaces]]</code>中找到的任何键。如果结果的标题无效,返回nil。
注意,不像<code>[[#mw.title.new|mw.title.new()]]</code>,这个方法总会应用指定的命名空间。比如,<code
==== 标题对象 ====
第2,571行:
* '''contentModel''':此标题的内容模型,字符串,{{red|可能会造成[[#Expensive properties|高开销]]}}。
<includeonly>* '''pageLanguage''':此标题的页面语言,语言对象类似于<code>[[#mw.language.getContentLanguage|mw.language.getContentLanguage]]</code>返回的默认值,但是取决于特定页面。{{red|此函数[[#Expensive properties|可能由较高开销]]}}。</includeonly>
* '''basePageTitle''':等同于<code
* '''rootPageTitle''':等同于<code
* '''talkPageTitle''':等同于<code
* '''subjectPageTitle''':等同于<code
* '''redirectTarget''':返回重定向页面的目标页面的标题对象,但如果不是重定向页面,则返回<code>false</code>。
* '''protectionLevels''':页面的保护等级。其值为一个表,键对应每个操作(如<code>"edit"</code>、<code>"move"</code>),值为数组,第一项是包含对应保护等级的字符串,如果页面未被保护,则表的值或者数组的项就会为<code>nil</code>。{{red|此函数高开销}}。
* '''cascadingProtection''':该页面应用的级联保护,为一个表,键为<code>"restrictions"</code>(自身为一个表,键类似于<code>protectionLevels</code>拥有的那些)和<code>"sources"</code>(列举保护级联来源的标题的数组)。如果没有保护级联到此页面,则<code>"restrictions"</code>和<code>"sources"</code>可能是空的。{{red|此函数开销较高}}。
* '''subPageTitle( text )''':等同于<code
* '''partialUrl()''':返回编码的<code>title.text</code>,就像在URL中会有的那样。
* '''fullUrl( query, proto )'''::返回此标题的完整URL(带有可选的query表/字符串)。可以指定<var>proto</var>以控制返回URL的协议:<code>"http"</code>、<code>"https"</code>、<code>"relative"</code>(默认值)或<code>"canonical"</code>。
第2,585行:
* '''getContent()''':返回页面的(未解析的)内容,如果页面不存在则返回<code>nil</code>。页面会被记录为嵌入包含。
标题对象可以使用[[#Relational operators|关系运算符]]比较。<code
由于这可能难以置信,所以请注意获取标题对象的任何[[#Expensive properties|高开销]]的字段会记录一次对页面的“链入”(就像[[Special:WhatLinksHere|Special:链入页面]]中展示的那样)。使用标题对象的<code>getContent()</code>方法或访问<code>redirectTarget</code>字段会记录为“{{int|istemplate}}”,访问标题对象的<code>file</code>或<code>fileExists</code>字段会记录为“{{int|isimage}}”。
第2,611行:
==== mw.uri.encode ====
<code
[[百分号编码|百分号编码]]字符串。默认类型,<code>"QUERY"</code>,使用“+”编码空格以用于查询字符;<code>"PATH"</code>将空格编码为%20,<code>"WIKI"</code>将空格编码为“_”。
第2,618行:
==== mw.uri.decode ====
<code
[[百分号编码|百分号解码]]字符串。默认类型,<code>"QUERY"</code>,将“+”解码为空格;<code>"PATH"</code>不执行额外的解码,<code>"WIKI"</code>将“_”解码为空格。
==== mw.uri.anchorEncode ====
<code
编码字符串以用于MediaWiki URI fragment。
==== mw.uri.buildQueryString ====
<code
将表编码为URI查询字符串。键必须是字符串,值可以是字符串、数字、序列表或布尔值false。
==== mw.uri.parseQueryString ====
<code
将查询字符串<code>s</code>解码为表。字符串中没有值的键会拥有false值,重复多次的键会有序列表作为其值,其他的都会有字符串作为值。
第2,640行:
==== mw.uri.canonicalUrl ====
<code
返回页面的[[Help:Magic_words#URL_data|规范URL]]的[[#URI object|URI对象]],可选查询字符串或表。
==== mw.uri.fullUrl ====
<code
返回页面的[[Help:Magic_words#URL_data|完整URL]]的[[#URI object|URI对象]],可选查询字符串或表。
==== mw.uri.localUrl ====
<code
返回页面的[[Help:Magic_words#URL_data|本地URL]]的[[#URI object|URI对象]],可选查询字符串或表。
==== mw.uri.new ====
<code
利用传入的字符串或表构造一个新的[[#URI object|URI对象]]。参见URI对象的描述以了解表可能的字段。
==== mw.uri.validate ====
<code
验证传入的表(或URI对象)是否有效。返回布尔值,以表示表是否有效,以及如果无效,一个描述问题发生原因的字符串。
第2,689行:
===== mw.uri:parse =====
<code
将字符串解析为当前的URI对象。字符串中指定的任何字段都会被当前的对象替换;未指定的字段都会保留旧值。
第2,699行:
===== mw.uri:extend =====
<code
将参数表合并到对象的查询表。
第2,716行:
==== mw.ustring.byte ====
<code
返回单独的字节,等同于[[#string.byte|string.byte()]]。
==== mw.ustring.byteoffset ====
<code
返回字符在字符串内的字节偏移值。<code>l</code>和<code>i</code>的默认值都是1.<code>i</code>可以是负数,即倒过来计数。
第2,728行:
==== mw.ustring.char ====
<code
非常像[[#string.char|string.char()]],但是整数为Unicode代码点而非字节值。
第2,737行:
==== mw.ustring.codepoint ====
<code
很像[[#string.byte|string.byte()]],但是返回的值是代码点,且偏移值为字符而非字节。
==== mw.ustring.find ====
<code
非常像[[#string.find|string.find()]],但是匹配模式是扩展了的,在[[#Ustring patterns|Ustring patterns]]中有描述,且<code>init</code>是按照字符而非字节。
==== mw.ustring.format ====
<code
等同于[[#string.format|string.format()]]。字符串的宽度和精度是以字节表达,而非编号。
==== mw.ustring.gcodepoint ====
<code
返回用于在字符串内迭代代码点的三个值。<code>i</code>默认为1,<code>j</code>默认为-1。这是为了用于[[#iterators|<code>for</code>形式的迭代]]:
第2,763行:
==== mw.ustring.gmatch ====
<code
非常像[[#string.gmatch|string.gmatch()]],但是匹配模式是扩展了的,在[[#Ustring patterns|ustring匹配模式]]中有描述。
==== mw.ustring.gsub ====
<code
非常像[[#string.gsub|string.gsub()]],但是匹配模式是扩展了的,在[[#Ustring patterns|ustring匹配模式]]中有描述。
==== mw.ustring.isutf8 ====
<code
若字符串是有效的UTF-8,返回true,否则返回false。
==== mw.ustring.len ====
<code
返回字符串的长度,或者不是有效的UTF-8时返回nil。
第2,785行:
==== mw.ustring.lower ====
<code
非常像[[#string.lower|string.lower()]],但是所有在Unicode中定义了小写到大写转换的字符都会被转换。
第2,792行:
==== mw.ustring.match ====
<code
非常像[[#string.match|string.match()]],但是匹配模式是扩展了的,在[[#Ustring patterns|ustring匹配模式]]中有描述,且<code>init</code>偏移是按照字符而非字节。
==== mw.ustring.rep ====
<code
等同于[[#string.rep|string.format()]]。
==== mw.ustring.sub ====
<code
非常像[[#string.sub|string.sub()]],但是偏移值为字符而非字节。
==== mw.ustring.toNFC ====
<code
将字符串转化为[[Unicode等价性|正规形式C]]。如果字符串不是有效的UTF-8则返回nil。
==== mw.ustring.toNFD ====
<code
将字符串转化为[[Unicode等价性|正规形式D]]。如果字符串不是有效的UTF-8则返回nil。
==== mw.ustring.upper ====
<code
非常像[[#string.upper|string.upper()]],但是所有在Unicode中定义了大写到小写转换的字符都会被转换。
第2,856行:
==== bit32.band ====
<code
返回参数的“按位与”运算:对于结果中的每一位,只有当所有参数中都设置了该位时,结果中才会有这一位。
第2,863行:
==== bit32.bnot ====
<code
返回<code>x</code>的“取反”。
==== bit32.bor ====
<code
返回参数的“按位或”运算:对于结果中的每一位,只要所有参数中有任何一个设置了该位,结果中就会有这一位。
第2,875行:
==== bit32.btest ====
<code
等同于<code
==== bit32.bxor ====
<code
返回参数的“按位异或”运算:对于结果中的每一位,只有所有参数中设置了该位的参数个数为奇数,结果中才会有这一位。
第2,887行:
==== bit32.extract ====
<code
从<code>n</code>导出<code>width</code>位,以<code>field</code>为开始。访问0到31范围之外的位都是错误的。
第2,894行:
==== bit32.replace ====
<code
替换<code>n</code>中的<code>width</code>位,以<code>field</code>位开始,<code>v</code>开始的低<code>width</code>位。访问0到31范围之外的位都是错误的。
第2,901行:
==== bit32.lshift ====
<code
返回数<code>n</code>向左[[位操作#移位|移动]]<code>disp</code>位。这是一个[[位操作#逻辑移位|逻辑移位]]:插入的位为0。这通常相当于乘以2的<code>disp</code>次方。
第2,908行:
==== bit32.rshift ====
<code
返回数<code>n</code>向右[[位操作#移位|移动]]<code>disp</code>位。这是一个[[位操作#逻辑移位|逻辑移位]]:插入的位为0。这通常相当于除以2的<code>disp</code>次方。
第2,915行:
==== bit32.arshift ====
<code
返回数<code>n</code>向右[[位操作#移位|移动]]<code>disp</code>位。这是一个[[算数移位|算数移位]]:如果<code>disp</code>是正的,那么插入的位将会与原始数字的31位相同。
第2,922行:
==== bit32.lrotate ====
<code
返回数<code>n</code>向左旋转<code>disp</code>位。
第2,929行:
==== bit32.rrotate ====
<code
返回数<code>n</code>向右旋转<code>disp</code>位。
第2,942行:
==== libraryUtil.checkType ====
<code
<code
<code>name</code>是调用函数的名称,<code>argIdx</code>是参数列表中参数的位置。这些用于格式化错误消息。
==== libraryUtil.checkTypeMulti ====
<code
<code
用于可以有多个有效类型的参数。
==== libraryUtil.checkTypeForIndex ====
<code
<code
用于实现<code>__newindex</code>[[#Metatables|元方法]]。
==== libraryUtil.checkTypeForNamedArg ====
<code
<code
在使用Lua的命名参数语法(<code
==== libraryUtil.makeCheckSelfFunction ====
<code
此函数用于在用于被<code>obj:method()</code>语法调用的对象表中实现“方法”,会返回一个应该在这些方法顶部调用的函数,并使用<code>self</code>参数和方法名称,如果<code>self</code>对象不是<code>selfObject</code>则会抛出错误。
|