Help:Lua：修订间差异

从模板的环境中调用Lua代码确实是一个好办法。

这也避免了把复杂语法加到wiki内容命名空间中。

对于模块来说，最好将所有的函数和变量声明为局部变量。

<code><nowiki>{{#invoke:}}</nowiki></code>调用函数时，会将[[#frame-object|框架对象（frame object）]]作为单一的参数。要访问传递到<code><nowiki>{{#invoke:}}</nowiki></code>的参数，代码通常会使用框架对象的<code>[[#frame.args|args]]</code>表，也可以访问传递到了包含<code><nowiki>{{#invoke:}}</nowiki></code>的模板的参数，方法是使用<code>[[#frame:getParent|frame:getParent()]]</code>，并访问该框架的<code>args</code>。

=== 返回文本 ===

在解析页面的这一点上，模板都是已经被展开的，解析器函数和扩展标签都已经被处理，而且预存的转换（例如签名的扩展以及[[Help:链接#管道技巧|管道技巧]]）都已经完成。因此，模块不能在输出文本中使用这些特性。例如，如果一个模块返回<code><nowiki>"Hello, world! {{welcome}}"</nowiki></code>，页面就会显示“Hello, world! <nowiki>{{welcome}}</nowiki>”。

=== 模块文档 ===

这也可以使用以下MediaWiki命名空间下的消息配置：

* <code>scribunto-doc-page-does-not-exist</code> — 文档页面不存在时显示的消息。 页面名称传递为<code>$1</code>。 默认为空。

* <code>scribunto-doc-page-show</code> — 文档页面存在时显示的消息。 页面名称传递为<code>$1</code>。 默认是嵌入包含文档页面。

* <code>scribunto-doc-page-header</code> — 查看文档页面本身时显示的标题。 模块的名称（有Module:前缀）传递为<code>$1</code>。 默认以斜体显示简要说明。

== Lua语言 ==

==== 数字（number） ====

重申一遍，在转化为布尔值时，任何数字都会被视为true。这不像其他语言，数字0通常视为false。数字在转化为字符串时，数字都会被视为有限小数和科学计数；NaN是<syntaxhighlight lang="lua" inline>"nan"</syntaxhighlight>或者<syntaxhighlight lang="lua" inline>"-nan"</syntaxhighlight>；无穷大就是<syntaxhighlight lang="lua" inline>"inf"</syntaxhighlight>或<syntaxhighlight lang="lua" inline>"-inf"</syntaxhighlight>。

表要用一对花括号创建。空表是<code>{}</code>。创建有多个字段的表时，逗号和分号可以分隔表中的各个字段。表的内容可以用以下形式表示：

{{Anchor|sequence}}

Lua中的函数是一等的（first-class）的值：可以匿名创建，或作为参数传递，或给变量赋值，等等。

Lua函数是[[闭包 (计算机科学)|闭包]]，这意味着它们维护对它们声明的作用域的引用，并可以访问和操作该作用域中的变量。

以下元表字段可以影响表本身：

; __index

; __newindex

; __call

; {{Anchor|weak tables}}__mode

: 这用于使表保持弱引用（weak references）。 这个值一定是一个字符串。 默认情况下，任何一个值被作为表格中的键或值时是不会被垃圾回收的。 但如果元表字段包含字母k，且没有非弱引用，键可能会被作为垃圾收集。而且如果包含v则值有可能也会作为垃圾收集；其他的情况，对应的键和值都会从表中移除。 注意，如果在表用作元表之后字段被改变，则行为未定义。

<div id="binop-note" style="padding:0 1em;text-indent: -1em;">^† 对于二元运算符，Lua首先检查左边的变量的元表（若有），如果左边变量的元方法不存在则寻找右边的变量的元方法。</div>

<div id="relop-note" style="padding:0 1em;text-indent: -1em;">^‡ 对于关系运算符，只有当两个参数的元方法都指定了同一个函数时，元表才会被使用。不同的匿名函数，即使具有相同的主体和闭包，也不可能被认为是相同的。</div>

__metatable会同时影响[[#getmetatable|getmetatable()]]和[[#setmetatable|setmetatable()]]</div>

</div>

| / || 除法 || a / b || __div || 除以零不会出错，会返回NaN或者无穷大

|-

|-

| ^ || 幂运算 || a ^ b || __pow || 允许非整数指数

Lua的关系运算符是<code>==</code>、<code>~=</code>、<code><</code>、<code>></code>、<code><=</code>和<code>>=</code>。关系运算的结果一定是布尔值（boolean）。

不等号（<code>~=</code>）与等于号作用相反。

对于排序运算符，如果两者都是数字，或者两者都是字符串，则直接进行比较。其次检查元方法：

如果必需的元方法不可用，会产生错误。

对于<code>not</code>，其结果一定是布尔值（true或false）。

==== 连接运算符 ====

==== 长度运算符 ====

# or

{{Anchor|Function calls}}

</syntaxhighlight>

Lua为将函数声明和赋值提供到变量中提供语法糖；参见[[#Function declaration statements|函数声明语句]]的细节。

{{Anchor|block}}

==== 赋值 ====

==== 局部变量定义 ====

局部变量可以在一个[[#block|语句块]]或[[#block|代码块]]内任意地方声明。第一种形式，不需要表达式列表，声明变量但不赋值，所以这些变量都会将nil作为值二中形式，为局部变量赋值，参见上面的[[#Assignments|赋值]]。

==== 控制结构 ====

{{Anchor|while}}

只要''表达式''还是（视为）true时，就会反复执行while语句。

{{Anchor|repeat}}

反复执行''语句块''，直到''表达式''（视为）是true。语句块内声明的局部变量可以用于表达式中。

{{Anchor|for}}

for循环的第一种形式会声明一个局部变量，然后从''exp1''以''exp3''的步长到''exp2''重复语句块。注意''exp3''可以省略，相当于1，但是非数字值比如<code>nil</code>和<code>false</code>是错误的。循环开始前，所有的表达式都会先被计算。

{{Anchor|iterators}}

第二种形式的for循环会与'''迭代'''函数一起作用。就像在第一种形式里，''表达式列表''会在开始循环之前就赋值了。

{{Anchor|if}}

{{Anchor|return}}

返回语句用来返回从函数或者[[#chunk|代码块]]（只是一个函数）。''表达式列表''是由逗号分隔开的零个或更多个表达式。

Lua实现[[尾调用|尾调用（tail calls）]]。如果表达式列表包含一个函数调用，对那个函数的调用会重新使用当前的堆栈项（stack frame）。这可用于处理调用堆栈的函数，比如<code>[[#getfenv|getfenv()]]</code>和<code>[[#debug.traceback|debug.traceback()]]</code>。

{{Anchor|break}}

break语句用来中止一个while、repeat或for循环的执行，并跳到循环后面的语句。

==== 函数调用作为语句 ====

注意，这里的冒号符号与[[#Function calls|函数调用]]的冒号符号相类似，在参数列表的开头添加了一个隐式参数，名为<code>self</code>。

错误可以通过[[#error|error()]]和[[#assert|assert()]]“抛出”，使用[[#pcall|pcall()]] 或者[[#xpcall|xpcall()]]可以“捕获”错误。注意，某些Scribunto的内部错误是不能被Lua层面的代码捕获处理。

==== assert ====

如果<code>v</code>是nil或false，抛出错误，<code>message</code>就会用作错误的文本：如果错误文本为nil（或者未指定），则文本是"assertion failed!"（“断言失败！”）；如果是字符串或者数字，文字就是那个值；否则assert本身就会抛出错误。

==== error ====

用文本<code>message</code>来发出一个错误。

==== getfenv ====

注意，这个函数可能会无效，取决于配置中的<code>allowEnvFuncs</code>。

==== getmetatable ====

返回这个[[#table|表]]的[[#Metatables|元表]]。其他的类型都会返回nil。

==== ipairs ====

返回3个值：迭代函数、表<code>t</code>和0。它是供[[#iterators|<code>for</code>的迭代形式]]使用的：

它会迭代数对(1, t[1])、(2,t[2])等，直到t[i]是nil时。

==== next ====

注意键被返回的顺序是没有指定的，即使表有数字的索引（indexes）。如要以数字顺序遍历表，使用[[#for|数字的for]]或[[#ipairs|ipairs]]。

==== pairs ====

返回三个值：迭代器函数（[[#next|next]]或者类似的）、表<code>t</code>和nil。这是用于[[#iterators|<code>for</code>的迭代器形式]]。

这会遍历<code>t</code>中的键值对，就像[[#next|next]]做的那样。参考[[#next|next]]的文档以了解遍历期间修改表的限制。

==== pcall ====

用指定的参数在“保护模式”下调用函数<code>f</code>。这意味着如果在调用<code>f</code>时出错，pcall会返回false与错误消息。如果没有错误发生，pcall会返回true与调用返回的所有值。

<syntaxhighlight lang="lua">

==== rawequal ====

==== rawget ====

与<code>table[k]</code>相同，只是忽略了所有__index[[#Metatables|元方法]]。

==== rawset ====

==== select ====

如果<code>index</code>是数字，返回index之后的<code>...</code>中对应位置的数。如果<code>index</code>是字符串"#"，返回<code>...</code>中参数的个数。

==== setmetatable ====

设置[[#table|表]]的[[#Metatables|元表]]，<code>metatable</code>可能是nil，但是必须是清楚地提供的。

==== tonumber ====

尝试将<code>value</code>转化为数字。如果已经是数字或者可以转化为数字的字符串，<code>tonumber</code>就会返回这个数字，否则会返回nil。

<code>base</code>是可选的，默认为10，指定解析数字的进位基数。这个基数可以是2到36之间的任何整数。对于大于10，字母A（大小写均可）代表10，B代表11，以此类推，Z代表35。

==== tostring ====

将<code>value</code>转化为字符串。参考上方的[[#Data types|数据类型]]以了解各种类型被转换时的细节。

==== type ====

以字符串形式返回<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>table</code>不是一个[[#sequence|序列]]且<code>j</code>是nil或未指定，则结果是不确定的，参考[[#Length operator|长度操作符]]以了解详细。

==== xpcall ====

这个很像<code>[[#pcall|pcall]]</code>，只是错误消息在返回之前传递到函数<code>errhandler</code>中。

<syntaxhighlight lang="lua">

==== debug.traceback ====

以字符串的形式返回调用栈。可选的message参数会被连接到调用栈信息的前面。可选的level参数表示返回多少层调用栈。

==== math.abs ====

返回<code>x</code>的绝对值。

==== math.acos ====

返回<code>x</code>的反余弦值（以弧度表示）。

==== math.asin ====

返回<code>x</code>的反正弦值（以弧度表示）。

==== math.atan ====

返回<code>x</code>的反正切值（以弧度表示）。

==== math.atan2 ====

使用两个参数的符号（signs）以找到结果的象限，返回<code>y/x</code>的反正切值（弧度制）。

==== math.ceil ====

返回不小于<code>x</code>的最小整数。

==== math.cos ====

返回<code>x</code>（以弧度表示）的余弦值。

==== math.cosh ====

返回<code>x</code>的双曲余弦值。

==== math.deg ====

将弧度角<code>x</code>转化为角度。

==== math.exp ====

返回<math>e^x</math>。

==== math.floor ====

返回小于或等于<code>x</code>的最大整数。

==== math.fmod ====

返回<code>x</code>除以<code>y</code>的余数，并将商舍入到零。比如，<code>math.fmod( 10, 3 )</code>产生<code>1</code>。

==== math.frexp ====

返回像这样的两个值<code>m</code>和<code>e</code>：

==== math.ldexp ====

返回<math>m \times 2^e</math>（<code>e</code>是整数）。

==== math.log ====

返回<code>x</code>的自然对数。

==== math.log10 ====

返回<code>x</code>的以10为底的对数。

==== math.max ====

返回其参数的最大值。

==== math.min ====

返回其参数的最小值。

==== math.modf ====

返回两个数字，<code>x</code>的整数部分和<code>x</code>的小数部分。比如，<code>math.modf( 1.25 )</code>产生<code>1, 0.25</code>。

==== math.pow ====

与<code>x^y</code>相同。

==== math.rad ====

将角度<code>x</code>转化为弧度角。

==== math.random ====

返回伪随机数。

参数<code>m</code>、<code>n</code>可省略，但是如果指定了，则必须能够转化为整数。

注意，如果<code>m</code>或者<code>n</code>小于−2147483648或者大于2147483647，或者<code>n - m</code>大于2147483646，那么输出可能会不正确。

==== math.randomseed ====

以<code>x</code>作为伪随机数生成器的[[伪随机数的种子|种子]]。

==== math.sin ====

返回 <code>x</code>（以弧度表示）的正弦值。

==== math.sinh ====

返回<code>x</code>的双曲正弦值。

==== math.sqrt ====

返回<code>x</code>的平方根。与<code>x^0.5</code>相同。

==== math.tan ====

返回<code>x</code>（以弧度表示）的正切值。

==== math.tanh ====

返回<code>x</code>的双曲正切值。

==== os.date ====

: ''[[#mw.language:formatDate|语言库的formatDate]]''可以被用于更加全面的日期格式。

* hour（0～23）

* min（0～59）

* wday（weekday，Sunday是1）

* yday（一年的某一天）

==== os.difftime ====

返回从<code>t1</code>到<code>t2</code>两个时间的秒数。

==== os.time ====

返回代表当前时间的数字。

==== require ====

加载指定的模块。

==== package.seeall ====

将<code>table</code>的__index[[#Metatables|元方法]]设置为[[#_G|_G]]。

==== string.byte ====

如果字符串被考虑为字节的数组，返回<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 ====

接受零个或更多个整数。返回和长度与参数个数相同的字符串，每个字符的字节值等于其对应的参数。

==== string.find ====

寻找字符串<code>s</code>中<code>[[#Patterns|pattern]]</code>的第一个匹配（match）。如果找到一个匹配，返回<code>s</code>中起止点的序列，否则返回nil。如果匹配模式有捕获物（capture），则在成功的匹配中被捕获的值也会被返回在两个索引之后。

==== string.format ====

返回变量数字的参数将第一个参数（必须是字符串）格式化后的版本。

==== string.gmatch ====

返回一个迭代器函数，每次被调用，都会从字符串<code>s</code>中的[[#Patterns|<code>pattern</code>]]返回下一个捕获。如果<code>pattern</code>不会指定捕获，则整个匹配都会在每次调用时产生。

==== string.gsub ====

将字符串<code>s</code>的所有（或者前<code>n</code>个，如果给定了）出现的[[#Patterns|<code>pattern</code>]]替换为由<code>repl</code>指定的替换物（replacement），这个替换物可以是字符串、表或者函数。<code>gsub</code>也会作为第二个值返回发生了的匹配的总次数。

==== string.len ====

返回字符串的字节长度。不会被ASCII NUL字符混淆。等同于[[#Length operator|#]]s。

==== string.lower ====

将字符串的所有ASCII大写字符转为小写后返回。所有其他字符不改变。

==== string.match ====

寻找字符串中[[#Patterns|<code>pattern</code>]]的第一个匹配，如果找到一个，则<code>match</code>返回从样式匹配中的捕获，否则返回nil。如果<code>pattern</code>不指定捕获，则返回整个字符串。

==== string.rep ====

返回字符串<code>s</code>重复<code>n</code>次并连接后的字符串。等价于[[#mw.ustring.rep|mw.ustring.rep()]]。

==== string.reverse ====

返回字符串<code>s</code>被逆转后的字符串（按字节逆转）。

==== string.sub ====

返回<code>s</code>的从<code>i</code>开始持续到<code>j</code>的子串（substring）；<code>i</code>和<code>j</code>可以是负的。如果<code>j</code>是nil或未指定，则会一直到字符串末尾。

参看[[#mw.ustring.sub|mw.ustring.sub()]]以了解使用字符而非字节值的类似函数。

==== string.upper ====

将字符串的所有ASCII小写字符转为大写后返回。所有其他字符不改变。

! scope="row" | <code>[{{var|set}}]</code>

|

范围和类之间的交互是没被定义的，因此像<code>[%a-z]</code>或<code>[a-%%]</code>这样的匹配模式没有含义。

模式可以包括用小括号括起来的子模式（sub-patterns），描述了“捕获”。匹配成功时，字符串的匹配捕获的子字符串会被存储（被“捕获”）以备使用。捕获是根据左边的括号被标号的。比如，在模式<code>(a*(.)%w(%s*))</code>中，匹配<code>a*(.)%w(%s*)</code>的字符串部分被存储在第一个捕获（所以是第一项），匹配<code>.</code>的字符被捕获，记为第2项，匹配<code>%s*</code>的则是第3项。

特殊情况，空的捕获<code>()</code>会捕获当前的字符串位置（一个数字）。比如我们对字符串<code>"flaaap"</code>执行模式<code>"()aa()"</code>，那么会有两个捕获：3和5。

==== table.concat ====

<code>sep</code>的默认值为空字符串，<code>i</code>的默认值为1，<code>j</code>的默认值为表的长度。如果<code>i</code>大于<code>j</code>，返回空字符串。

==== table.insert ====

<br/>

大于<code>#table</code>的元素都会被提高，参考[[#Length operator|长度操作符]]以了解当表不是[[#sequence|序列]]时的注意事项。

==== table.maxn ====

返回给定的表的最大正数索引，或者表没有正数索引时返回零。

==== table.remove ====

大于<code>#table</code>的元素都会被移动，参考[[#Length operator|长度操作符]]以了解当表不是[[#sequence|序列]]时的注意事项。

==== table.sort ====

排序算法并不稳定；也就是说，当两个元素按照给定的顺序被看作相等时，它们在排序后的相对位置可能会改变。

==== mw.addWarning ====

==== mw.allToString ====

对所有的参数调用[[#tostring|tostring()]]，然后用制表符作为分隔符连接起来。

==== mw.clone ====

深拷贝一个值。所有的表和它们的元表被重构，但是新表和旧表共用函数。

==== mw.loadData ====

有时一个模块需要大量表格的数据，例如，用于转换计量单位的通用模块可能需要一张大表的已识别的单位及其转换系数。而且有时这些模块会在一个页面中使用多次。每次<code><nowiki>{{#invoke:}}</nowiki></code>都解析大表格的数据会用大量时间。<code>mw.loadData()</code>正是为了避免这个问题。

* 返回的表（和所有子表）不能有[[#Metatables|metatable]]元表。

* 所有的表键必须是布尔值、数字、字符串。

==== mw.dumpObject ====

将<code>object</code>序列化为人类可读的字符串并返回。

==== mw.log ====

{{Anchor|print}}

将参数传递到[[#mw.allToString|mw.allToString()]]，然后将结果字符串加载控制台后。

==== mw.logObject ====

<br/>

调用[[#mw.dumpObject|mw.dumpObject()]]然后将结果加到控制台输出的后面。如果给了<code>prefix</code>，则会被加到控制台输出并紧随一个等于号在序列化字符串之前，比如输出的字符串可以是"prefix = object-string"。

注意没有框架库，也没有叫做<code>frame</code>的全局变量。框架对象通常为被<code><nowiki>{{#invoke:}}</nowiki></code>调用的函数的参数，当然也可以从<code>[[#mw.getCurrentFrame|mw.getCurrentFrame()]]</code>获得。

==== frame.args ====

<nowiki>{{#invoke:module|function|arg1|arg2|name=arg3}}</nowiki>

注意这个表中的值总是为字符串，<code>[[#tonumber|tonumber()]]</code>可以用于在需要时转化为数字。但是，键是数字，即使在调用时清楚提供：<code><nowiki>{{#invoke:module|function|1|2=2}}</nowiki></code>给予被数字键<code>1</code>和<code>2</code>索引的字符串值<code>"1"</code>和<code>"2"</code>。

在MediaWiki模板调用中，命名参数（named arguments）会在传递到Lua前移除名称和值的多余空格，而匿名参数（unnamed arguments）不会移除空格。

如果在#invoke的参数中包含了像模板调用和三层括号变量这样的预处理器（preprocessor）语法，那么这些在传递到Lua之后不会被展开，直到值被Lua请求时才会展开。如果在#invoke的参数中包含了用XML标记形式写的特殊标签，例如<code>&lt;pre&gt;</code>、<code>&lt;nowiki&gt;</code>、<code>&lt;gallery&gt;</code>和<code>&lt;ref&gt;</code>，这些标签会被转化为[[strip marker]]——一种特殊字符串，由删除符（ASCII 127）开始，在从#invoke返回后转化为HTML。

==== frame:callParserFunction ====

<br/>

<br/>

: ''注意使用了[[#named arguments|命名参数]]。''

调用解析器函数，返回适当的字符串。这相比于<code>frame:preprocess</code>更优，但如果有可能，最好优先使用原生的Lua函数或Scribunto库函数。

<syntaxhighlight lang="lua">

==== frame:expandTemplate ====

: ''注意使用了[[#named arguments|命名参数]]。''

frame:expandTemplate{ title = 'template', args = { 'arg1', 'arg2', name = 'arg3' } }

注意标题与参数在传递到模版之前并未预处理：

<syntaxhighlight lang="lua">

frame:expandTemplate{ title = 'template', args = { '|' } }

frame:expandTemplate{ title = 'template', args = { '{{!}}' } }

</syntaxhighlight>

==== frame:extensionTag ====

<br/>

<syntaxhighlight lang="lua">

==== frame:newChild ====

: ''注意使用了[[#named arguments|命名参数]]。''

==== frame:preprocess ====

<br/>

同理，展开单个解析器函数时应使用[[#frame:callParserFunction|<code>frame:callParserFunction</code>]]。

==== frame:getArgument ====

<br/>

获得特定参数的对象，或者没有提供参数时返回nil。

==== frame:newParserValue ====

<br/>

==== frame:newTemplateParserValue ====

: ''注意使用了[[#named arguments|命名参数]]。''

<code>frame:argumentPairs()</code>

=== 哈希库 ===

==== mw.hash.hashValue ====

按照指定的算法算出字符串的哈希值。可以通过[[#mw.hash.listAlgorithms|mw.hash.listAlgorithms()]]获得有效的算法。

==== mw.hash.listAlgorithms ====

返回支持的哈希算法的列表，以用于[[#mw.hash.hashValue|mw.hash.hashValue()]]。

==== mw.html.create ====

创建一个新的mw.html对象，其包含一个标签名称为<code>tagName</code>的HTML元素。你也可以传递一个空的字符串或nil作为<code>tagName</code>，以创建一个新的空的mw.html对象。

==== mw.html:node ====

向当前的mw.html实例附加mw.html（<code>builder</code>）子节点。如果传递nil，那么函数不做任何事。（<code>builder</code>）节点是要创建的HTML元素的种类的字符串代表。

==== mw.html:wikitext ====

注意遇到第一个''nil''项就会停。

==== mw.html:newline ====

给mw.html对象加新行。

==== mw.html:tag ====

给mw.html对象添加一个新的节点，其标签名称为<code>tagName</code>，返回代表这个新的节点的mw.html实例。<code>args</code>参数和[[#mw.html.create|<code>mw.html.create</code>]]的参数是一样的。

==== mw.html:attr ====

<br/>

将节点的HTML属性的<code>name</code>属性的值设为<code>value</code>。也可以选择使用表，其键值对即为属性名称-值对。第一种形式中，如果值为nil，会导致这个给定名称的已被设置属性设为未被设置。

==== mw.html:getAttr ====

获得已经通过[[#mw.html:attr|<code>html:attr()</code>]]设置的属性<code>name</code>的值。

==== mw.html:addClass ====

给节点的类（class）属性添加一个类名称（class name）。如果参数为nil，则无效。

==== mw.html:css ====

<br/>

使用给定的<code>name</code>和<code>value</code>给节点设置CSS属性。也可以选择使用表，其键值对即为CSS名称-值对。第一种形式中，如果值为nil，会导致这个给定名称的已被设置的CSS设为未被设置。

==== mw.html:cssText ====

给节点的属性添加一些纯<code>css</code>文本。如果参数为nil，则无效。

==== mw.html:done ====

返回当前节点被创建时所在的上级节点。类似于jQuery.end，这是个方便地函数可以允许创建多个子节点，而由一个语句串在一起。

==== mw.html:allDone ====

类似于[[#mw.html:done|<code>html:done()</code>]]，但是会遍历直到树节点的根部再返回。

=== 语言库 ===

{{anchor|mw.language-object}}

==== mw.language.fetchLanguageName ====

给定的语言代码的完整语言名称：默认为本地名称，如有<code>inLanguage</code>的值，则是被翻译为目标语言的语言名称。

==== mw.language.fetchLanguageNames ====

<br/>

<br/>

获取MediaWiki已知的语言列表，返回将语言代码映射到语言名称的表。

==== mw.language.getFallbacksFor ====

返回MediaWiki针对指定语言代码的备选语言代码列表。

==== mw.language.isKnownLanguageTag ====

若语言代码为MediaWiki已知的语言，返回true。

==== mw.language.isSupportedLanguage ====

检查MediaWiki的语言代码内是否有任何本地化可用。

==== mw.language.isValidBuiltInCode ====

如果语言代码是用于MediaWiki内部自定义的有效形式，返回true。

==== mw.language.isValidCode ====

若语言代码字符串是有效形式的，返回true，无论其是否存在。这包括了所有单独用于通过MediaWiki命名空间自定义使用的语言代码。

==== mw.language.new ====

<br/>

创建新的语言对象。语言对象没有任何可公开获取的属性，不过可以含有几个方法，下面列出。

==== mw.language:getCode ====

返回这个语言对象的语言代码。

==== mw.language:getFallbackLanguages ====

==== mw.language:isRTL ====

若语言是从右至左写的，返回true，否则返回false。

==== mw.language:lc ====

将字符串转化为小写，但遵从给定的语言的任何特殊规则。

==== mw.language:lcfirst ====

将字符串的第一个字符转化为小写，就像[[#mw.language:lc|lang:lc()]]那样。

==== mw.language:uc ====

将字符串转化为大写，但遵从给定的语言的任何特殊规则。

==== mw.language:ucfirst ====

将字符串的第一个字符转化为大写，就像[[#mw.language:uc|lang:lc()]]那样。

==== mw.language:caseFold ====

将字符串转换为不区分大小写的比较表示形式。注意，显示其结果可能无任何意义。

==== mw.language:formatNum ====

<br/>

格式化数字，使用给定语言的合适的分组符合小数点。给予123456.78，可能会产生123,456.78、123.456,78或甚至١٢٣٬٤٥٦٫٧٨，取决于语言和wiki配置。

==== mw.language:formatDate ====

根据给定的格式字符串格式化一个日期。如果省略了<code>timestamp</code>，默认为当前时间。<code>local</code>的值必须是boolean或nil，如果是true，时间会格式化为wiki的当地时间而非UTC。

<code>timestamp</code>的格式字符串和支持的值与[[Extension:ParserFunctions]]的#time解析器函数完全相同。

<syntaxhighlight lang="lua">

==== mw.language:formatDuration ====

<br/>

将秒数的时间间隔转化为更加已读的单位，例如12345转化为3 hours, 25 minutes and 45 seconds（3时25分45秒），作为字符串返回结果。

==== mw.language:parseFormattedNumber ====

这需要一个以[[#mw.language:formatNum|lang:formatNum()]]格式化的数字，并返回实际数字。换句话说，这基本上是[[#tonumber|<code>tonumber()</code>]]根据语言转换的版本。

==== mw.language:convertPlural ====

{{Anchor|mw.language:plural}}

<br/>

<br/>

<br/>

序列的必填值取决于语言，详见[[mw:Help:Magic words#Localization|魔术字的本地化]]和[[translatewiki:Special:MyLanguage/FAQ#PLURAL|translatewiki针对PLURAL的常见问题]]。

==== mw.language:convertGrammar ====

{{Anchor|mw.language:grammar}}

<br/>

: ''注意两个别称之间的不同参数顺序。<code>convertGrammar</code>匹配MediaWiki的Language对象的相同名称的方法的顺序，而<code>grammar</code>匹配相同名称的解析器函数的顺序，可参考帮助:魔术字#本地化。''

==== mw.language:gender ====

<br/>

选择对应<code>what</code>的性别的字符串，可以是male、female或注册的用户名。

==== mw.language:getArrow ====

返回对应方向<code>direction</code>的Unicode箭头字符：

==== mw.language:getDir ====

根据语言的书写方向，返回"ltr"（从左至右）或"rtl"（从右至左）。

==== mw.language:getDirMark ====

返回包含U+200E（从左至右标记）或U+20F（从右至左标记）的字符串，取决于语言的书写方向以及<code>opposite</code>的值。

==== mw.language:getDirMarkEntity ====

返回“&amp;lrm;”或“&amp;rlm;”，取决于语言的书写方向和<code>opposite</code>的值。

==== mw.language:getDurationIntervals ====

<br/>

将秒数的时间间隔转化为更加已读的单位，例如12345转化为3 hours, 25 minutes and 45 seconds（3时25分45秒），返回从单位名称映射到数字的表。

==== mw.message.new ====

创建一个给定消息<code>key</code>的新消息对象。

==== mw.message.newFallbackSequence ====

创建给定的消息的新的消息对象（存在的第一个会被使用）。

==== mw.message.newRawMessage ====

创建新的消息对象，使用给定的文本，而不是查找国际化的（internationalized）消息。剩下的参数会传递到新对象的<code>[[#mw.message:params|params()]]</code>方法中。

==== mw.message.rawParam ====

==== mw.message.numParam ====

包装（wrap）该值使之自动被格式化为<code>[[#mw.language:formatNum|lang:formatNum()]]</code>。注意这不依赖事实上有效的[[#Language library|语言库]]。

==== mw.message.getDefaultLanguage ====

返回默认语言的语言对象。

==== mw.message:params ====

<br/>

给消息添加参数，参数可以一被传递为独立的参数或者作为一个[[#sequence|序列]]表。参数必须是数字、字符串或由[[#mw.message.numParam|mw.message.numParam()]]或[[#mw.message.rawParam|mw.message.rawParam()]]返回的特殊的值。如果使用序列表，参数必须是直接出现在表中，使用[[#Metatables|__index元方法]]的参考不起作用。

==== mw.message:rawParams ====

<br/>

像[[#mw.message:params|:params()]]，但是会先通过[[#mw.message.rawParam|mw.message.rawParam()]]传递所有的参数。

==== mw.message:numParams ====

<br/>

像[[#mw.message:params|:params()]]，但是会先通过[[#mw.message.numParam|mw.message.numParam()]]传递所有的参数。

==== mw.message:inLanguage ====

指定一个语言，以在加工消息时使用。<code>lang</code>可以是字符串，或者带有<code>getCode()</code>元表的表（比如[[#Language library|语言对象]]）。

==== mw.message:useDatabase ====

指定是否在MediaWiki:命名空间查找消息（比如在数据库中查找），或者只是使用MediaWiki分配的默认消息。