新增的內容 刪去的內容
無編輯摘要 |
小 (文本替换 - 替换“的的”为“的”) |
||
(未顯示2個用戶的17個中間版本) | |||
第5行:
| text = 此页面记载的是最新版本的Scribunto扩展的文档。某些功能可能尚未部署。
}}
{{Namespaces}}
此手册记载[[Lua]]的文档,用于MediaWiki的Scribunto扩展。
部分内容(英文原文)取自[https://www.lua.org/manual/5.1/index.html Lua 5.1参考手册](翻译时参考了[https://www.runoob.com/manual/lua53doc/ Lua参考手册的中文翻译]),其许可协议为[[#License|MIT许可证]]。
== 介绍 ==
=== 入门 ===
在已启用Scribunto的MediaWiki wiki上,以“Module:”前缀为标题创建一个页面,例如“
进入该新页面,复制下列文本:
第35行 ⟶ 第34行:
从模板的环境中调用Lua代码确实是一个好办法。
这意味着从调用页面的角度来说,语法不依赖与模板逻辑是否被Lua或者
这也避免了把复杂语法加到wiki内容命名空间中。
第45行 ⟶ 第44行:
对于模块来说,最好将所有的函数和变量声明为局部变量。
=== 访问
<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>。
框架对象也用来访问对应环境的
=== 返回文本 ===
模块函数通常返回单个的字符串;无论返回什么值都会通过[[#tostring|tostring()]]转换,然后连接在一起。这个字符串就是转化成
在解析页面的这一点上,模板都是已经被展开的,解析器函数和扩展标签都已经被处理,而且预存的转换(例如签名的扩展以及[[Help:链接#管道技巧|管道技巧]])都已经完成。因此,模块不能在输出文本中使用这些特性。例如,如果一个模块返回<code><nowiki>"Hello, world! {{welcome}}"</nowiki></code>,页面就会显示“Hello, world! <nowiki>{{welcome}}</nowiki>”。
另一方面,替换引用是在加工的早期阶段处理的,所以只有当其他尝试的替换引用会被处理时才使用<code><nowiki>{{subst:#invoke:}}</nowiki></code>。失败的替换引用因为会保持为
=== 模块文档 ===
Scruibunto允许模块可以被自动关联的模块
这也可以使用以下MediaWiki命名空间下的消息配置:
* <code>scribunto-doc-page-name</code> —设置用来作文档页面的名称。 模块(除了模块:prefix)的名称会通过<code>$1</code>。 如果在模块命名空间,这里的页面通常会视为
* <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语言 ==
第224行 ⟶ 第222行:
==== 数字(number) ====
Lua只有一种数字类型,就是典型的[[
数字可以用点(<code>.</code>)来表示小数,例如<code>123456.78</code>。数字也可以用不带空格的[[
虽然[[
重申一遍,在转化为布尔值时,任何数字都会被视为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>。
第238行 ⟶ 第236行:
表要用一对花括号创建。空表是<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}}
第288行 ⟶ 第286行:
Lua中的函数是一等的(first-class)的值:可以匿名创建,或作为参数传递,或给变量赋值,等等。
函数通过<code>function</code>(“函数”的英文)关键字,并使用圆括号调用。有一些[[
Lua函数是[[
类似于表,如果函数一个函数被分配给另一个变量,或者作为参数传递给另一个函数,它仍然是相同的被调用的底层“函数对象”。
第312行 ⟶ 第310行:
以下元表字段可以影响表本身:
; __index
: 如果表访问<code>t[key]</code>返回nil就使用这个。 如果这个字段的值是表,访问就会在这个表中重复进行,例如<code>__index[''键'']</code>(会调用这个表的元表的__index)。 如果这个字段的值是函数,函数就会像<code
; __newindex
: 这个元方法用于将键赋值到表中,即<code
; __call
: 对表应用函数调用语法<code
; {{Anchor|weak tables}}__mode
: 这用于使表保持弱引用(weak references)。 这个值一定是一个字符串。 默认情况下,任何一个值被作为表格中的键或值时是不会被垃圾回收的。 但如果元表字段包含字母k,且没有非弱引用,键可能会被作为垃圾收集。而且如果包含v则值有可能也会作为垃圾收集;其他的情况,对应的键和值都会从表中移除。 注意,如果在表用作元表之后字段被改变,则行为未定义。
第343行 ⟶ 第341行:
<div id="binop-note" style="padding:0 1em;text-indent: -1em;"><sup>†</sup> 对于二元运算符,Lua首先检查左边的变量的元表(若有),如果左边变量的元方法不存在则寻找右边的变量的元方法。</div>
<div id="relop-note" style="padding:0 1em;text-indent: -1em;"><sup>‡</sup> 对于关系运算符,只有当两个参数的元方法都指定了同一个函数时,元表才会被使用。不同的匿名函数,即使具有相同的主体和闭包,也不可能被认为是相同的。</div>
<div id="metatable-note" style="padding:0 1em;text-indent: -1em;"><sup>*</sup>
__metatable会同时影响[[#getmetatable|getmetatable()]]和[[#setmetatable|setmetatable()]]</div>
</div>
第390行 ⟶ 第388行:
| / || 除法 || a / b || __div || 除以零不会出错,会返回NaN或者无穷大
|-
| % || 模运算 || a % b || __mod || 定义为<code
|-
| ^ || 幂运算 || a ^ b || __pow || 允许非整数指数
第401行 ⟶ 第399行:
Lua的关系运算符是<code>==</code>、<code>~=</code>、<code><</code>、<code>></code>、<code><=</code>和<code>>=</code>。关系运算的结果一定是布尔值(boolean)。
等于号(<code>==</code>)首先比较两个值的种类;如果两个值是不同的种类,结果为假(false)。然后比较值:空值、布尔值、数字和字符串照常比较。对于函数,则是看两个函数是否引用同一个准确的函数对象;像这样检测两个不同的(但作用相同的)匿名函数<code
不等号(<code>~=</code>)与等于号作用相反。
第407行 ⟶ 第405行:
对于排序运算符,如果两者都是数字,或者两者都是字符串,则直接进行比较。其次检查元方法:
* <code
* <code
* <code
* <code
如果必需的元方法不可用,会产生错误。
第424行 ⟶ 第422行:
对于<code>not</code>,其结果一定是布尔值(true或false)。
注意由<code>and</code>和<code>or</code>组成的简短语句。例如,<code
==== 连接运算符 ====
连接运算符就是两个点(dot),比如<code
注意Lua的字符串是不可变的(immutable),而且Lua不提供任何类型的“字符串构造器(string builder)”,所以反复进行<code
==== 长度运算符 ====
第448行 ⟶ 第446行:
==== 运算优先级 ====
Lua的[[
# ^
第459行 ⟶ 第457行:
# or
在同一级中,二元运算符会从左到右运算,例如<code
{{Anchor|Function calls}}
第519行 ⟶ 第517行:
函数被调用时,''block''中的语句会在由''var-list''创建与变量表对应的局部变量和指定值之后执行。如果执行到[[#return|返回语句]],语句块就会退出,函数调用表达式的值就会是返回语句给予的值。如果执行到代码段末尾,还没有返回语句,则函数调用返回的结果是0个值。
Lua函数是[[
<syntaxhighlight lang="lua">
第563行 ⟶ 第561行:
</syntaxhighlight>
[[#select|select()]]函数就是用来作用于这些参数表达式的;特别地,如要获取参数表达式的值的数量,应当使用<code
Lua为将函数声明和赋值提供到变量中提供语法糖;参见[[#Function declaration statements|函数声明语句]]的细节。
第589行 ⟶ 第587行:
{{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>是错误的。循环开始前,所有的表达式都会先被计算。
第640行 ⟶ 第638行:
{{Anchor|iterators}}
<code
第二种形式的for循环会与'''迭代'''函数一起作用。就像在第一种形式里,''表达式列表''会在开始循环之前就赋值了。
第664行 ⟶ 第662行:
{{Anchor|if}}
<code
当''表达式1''返回true时执行''语句块1'',否则,当''表达式2''返回true时执行''语句块2'',否则执行''语句块3''。<code
{{Anchor|return}}
<code
返回语句用来返回从函数或者[[#chunk|代码块]](只是一个函数)。''表达式列表''是由逗号分隔开的零个或更多个表达式。
Lua实现[[
返回语句必须是[[#block|语句块]]的最后一个语句。如果某些原因语句块的中间需要返回,那么可能需要明显的语句块<code
{{Anchor|break}}
第682行 ⟶ 第680行:
break语句用来中止一个while、repeat或for循环的执行,并跳到循环后面的语句。
break声明必须是[[#block|语句块(block)]]的最后一个声明。如果某些原因语句块的中间需要中断,那么可能需要明显的语句块<code
==== 函数调用作为语句 ====
第710行 ⟶ 第708行:
注意,这里的冒号符号与[[#Function calls|函数调用]]的冒号符号相类似,在参数列表的开头添加了一个隐式参数,名为<code>self</code>。
=== 错误处理 ===
错误可以通过[[#error|error()]]和[[#assert|assert()]]“抛出”,使用[[#pcall|pcall()]] 或者[[#xpcall|xpcall()]]可以“捕获”错误。注意,某些Scribunto的内部错误是不能被Lua层面的代码捕获处理。
第767行 ⟶ 第765行:
==== assert ====
<code
如果<code>v</code>是nil或false,抛出错误,<code>message</code>就会用作错误的文本:如果错误文本为nil(或者未指定),则文本是"assertion failed!"(“断言失败!”);如果是字符串或者数字,文字就是那个值;否则assert本身就会抛出错误。
第784行 ⟶ 第782行:
==== error ====
<code
用文本<code>message</code>来发出一个错误。
第791行 ⟶ 第789行:
==== getfenv ====
<code
注意,这个函数可能会无效,取决于配置中的<code>allowEnvFuncs</code>。
第804行 ⟶ 第802行:
==== getmetatable ====
<code
返回这个[[#table|表]]的[[#Metatables|元表]]。其他的类型都会返回nil。
第811行 ⟶ 第809行:
==== ipairs ====
<code
返回3个值:迭代函数、表<code>t</code>和0。它是供[[#iterators|<code>for</code>的迭代形式]]使用的:
第823行 ⟶ 第821行:
它会迭代数对(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]]。
第835行 ⟶ 第833行:
==== pairs ====
<code
返回三个值:迭代器函数([[#next|next]]或者类似的)、表<code>t</code>和nil。这是用于[[#iterators|<code>for</code>的迭代器形式]]。
第847行 ⟶ 第845行:
这会遍历<code>t</code>中的键值对,就像[[#next|next]]做的那样。参考[[#next|next]]的文档以了解遍历期间修改表的限制。
如果__pairs[[#Metatables|元方法]]存在,那么标准行为会被覆盖,调用会返回与<code
==== pcall ====
<code
用指定的参数在“保护模式”下调用函数<code>f</code>。这意味着如果在调用<code>f</code>时出错,pcall会返回false与错误消息。如果没有错误发生,pcall会返回true与调用返回的所有值。
用[[
<syntaxhighlight lang="lua">
第867行 ⟶ 第865行:
==== 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>中参数的个数。
第900行 ⟶ 第898行:
==== setmetatable ====
<code
设置[[#table|表]]的[[#Metatables|元表]],<code>metatable</code>可能是nil,但是必须是清楚地提供的。
第907行 ⟶ 第905行:
==== tonumber ====
<code
尝试将<code>value</code>转化为数字。如果已经是数字或者可以转化为数字的字符串,<code>tonumber</code>就会返回这个数字,否则会返回nil。
第913行 ⟶ 第911行:
<code>base</code>是可选的,默认为10,指定解析数字的进位基数。这个基数可以是2到36之间的任何整数。对于大于10,字母A(大小写均可)代表10,B代表11,以此类推,Z代表35。
十进制下,值可以有小数部分,或者以[[
==== 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>中。
用[[
<syntaxhighlight lang="lua">
第954行 ⟶ 第952行:
==== debug.traceback ====
<code
以字符串的形式返回调用栈。可选的message参数会被连接到调用栈信息的前面。可选的level参数表示返回多少层调用栈。
第961行 ⟶ 第959行:
==== 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,032行 ⟶ 第1,030行:
==== 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,054行 ⟶ 第1,052行:
==== math.min ====
<code
返回其参数的最小值。
第1,061行 ⟶ 第1,059行:
==== math.modf ====
<code
返回两个数字,<code>x</code>的整数部分和<code>x</code>的小数部分。比如,<code>math.modf( 1.25 )</code>产生<code>1, 0.25</code>。
第1,069行 ⟶ 第1,067行:
==== math.pow ====
<code
与<code>x^y</code>相同。
==== math.rad ====
<code
将角度<code>x</code>转化为弧度角。
==== math.random ====
<code
返回伪随机数。
第1,085行 ⟶ 第1,083行:
参数<code>m</code>、<code>n</code>可省略,但是如果指定了,则必须能够转化为整数。
* 没有参数时返回区间<math>[0,1)</math>内的实数。
* 有一个参数时返回区间<math>[1,m]</math>内的整数。
* 有两个参数时返回区间<math>[m,n]</math>内的整数。
注意,如果<code>m</code>或者<code>n</code>小于−2147483648或者大于2147483647,或者<code>n - m</code>大于2147483646,那么输出可能会不正确。
第1,093行 ⟶ 第1,091行:
==== math.randomseed ====
<code
以<code>x</code>作为伪随机数生成器的[[
注意使用同一个种子会导致<code>math.random</code>输出相同的数列。
==== 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,132行 ⟶ 第1,130行:
==== os.date ====
<code
: ''[[#mw.language:formatDate|语言库的formatDate]]''可以被用于更加全面的日期格式。
第1,147行 ⟶ 第1,145行:
* hour(0~23)
* min(0~59)
* sec(0~60,允许[[
* wday(weekday,Sunday是1)
* yday(一年的某一天)
第1,155行 ⟶ 第1,153行:
==== os.difftime ====
<code
返回从<code>t1</code>到<code>t2</code>两个时间的秒数。
==== os.time ====
<code
返回代表当前时间的数字。
第1,169行 ⟶ 第1,167行:
==== require ====
<code
加载指定的模块。
第1,212行 ⟶ 第1,210行:
==== package.seeall ====
<code
将<code>table</code>的__index[[#Metatables|元方法]]设置为[[#_G|_G]]。
第1,223行 ⟶ 第1,221行:
==== 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,239行 ⟶ 第1,237行:
==== string.find ====
<code
寻找字符串<code>s</code>中<code>[[#Patterns|pattern]]</code>的第一个匹配(match)。如果找到一个匹配,返回<code>s</code>中起止点的序列,否则返回nil。如果匹配模式有捕获物(capture),则在成功的匹配中被捕获的值也会被返回在两个索引之后。
第1,250行 ⟶ 第1,248行:
==== string.format ====
<code
返回变量数字的参数将第一个参数(必须是字符串)格式化后的版本。
第1,270行 ⟶ 第1,268行:
==== string.gmatch ====
<code
返回一个迭代器函数,每次被调用,都会从字符串<code>s</code>中的[[#Patterns|<code>pattern</code>]]返回下一个捕获。如果<code>pattern</code>不会指定捕获,则整个匹配都会在每次调用时产生。
第1,279行 ⟶ 第1,277行:
==== string.gsub ====
<code
将字符串<code>s</code>的所有(或者前<code>n</code>个,如果给定了)出现的[[#Patterns|<code>pattern</code>]]替换为由<code>repl</code>指定的替换物(replacement),这个替换物可以是字符串、表或者函数。<code>gsub</code>也会作为第二个值返回发生了的匹配的总次数。
第1,294行 ⟶ 第1,292行:
==== string.len ====
<code
返回字符串的字节长度。不会被ASCII NUL字符混淆。等同于[[#Length operator|#]]s。
第1,301行 ⟶ 第1,299行:
==== string.lower ====
<code
将字符串的所有ASCII大写字符转为小写后返回。所有其他字符不改变。
第1,308行 ⟶ 第1,306行:
==== string.match ====
<code
寻找字符串中[[#Patterns|<code>pattern</code>]]的第一个匹配,如果找到一个,则<code>match</code>返回从样式匹配中的捕获,否则返回nil。如果<code>pattern</code>不指定捕获,则返回整个字符串。
第1,317行 ⟶ 第1,315行:
==== 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,344行 ⟶ 第1,342行:
==== 匹配模式(patterns) ====
注意Lua的匹配模式类似于[[
* 用于引用的字符串是百分号(<code>%</code>)而非反斜杠(<code>\</code>)。
第1,439行 ⟶ 第1,437行:
! 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,470行 ⟶ 第1,468行:
模式可以包括用小括号括起来的子模式(sub-patterns),描述了“捕获”。匹配成功时,字符串的匹配捕获的子字符串会被存储(被“捕获”)以备使用。捕获是根据左边的括号被标号的。比如,在模式<code>(a*(.)%w(%s*))</code>中,匹配<code>a*(.)%w(%s*)</code>的字符串部分被存储在第一个捕获(所以是第一项),匹配<code>.</code>的字符被捕获,记为第2项,匹配<code>%s*</code>的则是第3项。
捕获参考可以出现在字符串自身,而返回参考早前被捕获的文本。比如,<code>([a-z])%1</code>会匹配任何一对相同的小写字母,而<code>([a-z])([a-z])([a-z])[a-z]%3%2%1</code>会匹配任何7个字母的[[
特殊情况,空的捕获<code>()</code>会捕获当前的字符串位置(一个数字)。比如我们对字符串<code>"flaaap"</code>执行模式<code>"()aa()"</code>,那么会有两个捕获:3和5。
第1,481行 ⟶ 第1,479行:
==== 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,517行 ⟶ 第1,515行:
==== 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,537行 ⟶ 第1,535行:
==== mw.addWarning ====
<code
在预览编辑时加一个警告信息。<code>text</code>解析为
==== mw.allToString ====
<code
对所有的参数调用[[#tostring|tostring()]],然后用制表符作为分隔符连接起来。
==== mw.clone ====
<code
深拷贝一个值。所有的表和它们的元表被重构,但是新表和旧表共用函数。
第1,567行 ⟶ 第1,565行:
==== mw.loadData ====
<code
有时一个模块需要大量表格的数据,例如,用于转换计量单位的通用模块可能需要一张大表的已识别的单位及其转换系数。而且有时这些模块会在一个页面中使用多次。每次<code><nowiki>{{#invoke:}}</nowiki></code>都解析大表格的数据会用大量时间。<code>mw.loadData()</code>正是为了避免这个问题。
第1,579行 ⟶ 第1,577行:
* 返回的表(和所有子表)不能有[[#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,590行 ⟶ 第1,588行:
==== mw.log ====
{{Anchor|print}}
<code
将参数传递到[[#mw.allToString|mw.allToString()]],然后将结果字符串加载控制台后。
第1,597行 ⟶ 第1,595行:
==== mw.logObject ====
<code
<br/>
<code
调用[[#mw.dumpObject|mw.dumpObject()]]然后将结果加到控制台输出的后面。如果给了<code>prefix</code>,则会被加到控制台输出并紧随一个等于号在序列化字符串之前,比如输出的字符串可以是"prefix = object-string"。
第1,609行 ⟶ 第1,607行:
注意没有框架库,也没有叫做<code>frame</code>的全局变量。框架对象通常为被<code><nowiki>{{#invoke:}}</nowiki></code>调用的函数的参数,当然也可以从<code>[[#mw.getCurrentFrame|mw.getCurrentFrame()]]</code>获得。
==== frame.args ====
用来访问传递到frame的参数的表。例如,一个模块从如下的
<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实现表迭代器,迭代的顺序不确定,参数出现在
注意这个表中的值总是为字符串,<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>。
第1,619行 ⟶ 第1,617行:
在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,634行 ⟶ 第1,632行:
调用解析器函数,返回适当的字符串。这相比于<code>frame:preprocess</code>更优,但如果有可能,最好优先使用原生的Lua函数或Scribunto库函数。
以下调用与以下
<syntaxhighlight lang="lua">
第1,655行 ⟶ 第1,653行:
==== frame:expandTemplate ====
<code
: ''注意使用了[[#named arguments|命名参数]]。''
第1,663行 ⟶ 第1,661行:
frame:expandTemplate{ title = 'template', args = { 'arg1', 'arg2', name = 'arg3' } }
在Lua脚本中的行为大致和<code><nowiki>{{template|arg1|arg2|name=arg3}}</nowiki></code>在
注意标题与参数在传递到模版之前并未预处理:
<syntaxhighlight lang="lua">
-- 这与
frame:expandTemplate{ title = 'template', args = { '|' } }
-- 这与
frame:expandTemplate{ title = 'template', args = { '{{!}}' } }
</syntaxhighlight>
==== frame:extensionTag ====
<code
<br/>
<code
这大致相当于调用[[#frame:callParserFunction|frame:callParserFunction()]],其函数名称为<code
<syntaxhighlight lang="lua">
第1,711行 ⟶ 第1,709行:
==== frame:newChild ====
<code
: ''注意使用了[[#named arguments|命名参数]]。''
第1,720行 ⟶ 第1,718行:
==== frame:preprocess ====
<code
<br/>
<code
在当前框架环境下展开
如果你使用单个模板,使用[[#frame:expandTemplate|<code>frame:expandTemplate</code>]]而非尝试建造
同理,展开单个解析器函数时应使用[[#frame:callParserFunction|<code>frame:callParserFunction</code>]]。
==== frame:getArgument ====
<code
<br/>
<code
获得特定参数的对象,或者没有提供参数时返回nil。
返回的对象有一个方法,<code>object:expand()</code>,可以返回对应参数的展开后的
==== frame:newParserValue ====
<code
<br/>
<code
返回有一个方法<code>object:expand()</code>的对象,该方法可以返回<code
==== frame:newTemplateParserValue ====
<code
: ''注意使用了[[#named arguments|命名参数]]。''
第1,756行 ⟶ 第1,754行:
<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,791行 ⟶ 第1,789行:
==== mw.html.create ====
<code
创建一个新的mw.html对象,其包含一个标签名称为<code>tagName</code>的HTML元素。你也可以传递一个空的字符串或nil作为<code>tagName</code>,以创建一个新的空的mw.html对象。
第1,801行 ⟶ 第1,799行:
==== mw.html:node ====
<code
向当前的mw.html实例附加mw.html(<code>builder</code>)子节点。如果传递nil,那么函数不做任何事。(<code>builder</code>)节点是要创建的HTML元素的种类的字符串代表。
==== mw.html:wikitext ====
<code
给mw.html对象加上不定数量的
注意遇到第一个''nil''项就会停。
==== 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,863行 ⟶ 第1,861行:
=== 语言库 ===
语言代码在语言代码中由描述。很多MediaWiki的语言代码类似于[[
{{anchor|mw.language-object}}
第1,869行 ⟶ 第1,867行:
==== mw.language.fetchLanguageName ====
<code
给定的语言代码的完整语言名称:默认为本地名称,如有<code>inLanguage</code>的值,则是被翻译为目标语言的语言名称。
==== mw.language.fetchLanguageNames ====
<code
<br/>
<code
<br/>
<code
获取MediaWiki已知的语言列表,返回将语言代码映射到语言名称的表。
第1,894行 ⟶ 第1,892行:
==== mw.language.getFallbacksFor ====
[[File:MediaWiki fallback chains.svg|
<code
返回MediaWiki针对指定语言代码的备选语言代码列表。
==== mw.language.isKnownLanguageTag ====
<code
若语言代码为MediaWiki已知的语言,返回true。
第1,907行 ⟶ 第1,905行:
==== mw.language.isSupportedLanguage ====
<code
检查MediaWiki的语言代码内是否有任何本地化可用。
第1,916行 ⟶ 第1,914行:
==== mw.language.isValidBuiltInCode ====
<code
如果语言代码是用于MediaWiki内部自定义的有效形式,返回true。
第1,927行 ⟶ 第1,925行:
==== mw.language.isValidCode ====
<code
若语言代码字符串是有效形式的,返回true,无论其是否存在。这包括了所有单独用于通过MediaWiki命名空间自定义使用的语言代码。
第1,936行 ⟶ 第1,934行:
==== mw.language.new ====
<code
<br/>
<code
创建新的语言对象。语言对象没有任何可公开获取的属性,不过可以含有几个方法,下面列出。
第1,945行 ⟶ 第1,943行:
==== 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配置。
第2,000行 ⟶ 第1,998行:
==== mw.language:formatDate ====
<code
根据给定的格式字符串格式化一个日期。如果省略了<code>timestamp</code>,默认为当前时间。<code>local</code>的值必须是boolean或nil,如果是true,时间会格式化为wiki的当地时间而非UTC。
<code>timestamp</code>的格式字符串和支持的值与[[Extension:ParserFunctions]]的#time解析器函数完全相同。
注意虽然反斜杠可能需要在Lua字符串字面量中写两次,由于Lua也使用反斜杠转义,而
<syntaxhighlight lang="lua">
第2,019行 ⟶ 第2,017行:
==== mw.language:formatDuration ====
<code
<br/>
<code
将秒数的时间间隔转化为更加已读的单位,例如12345转化为3 hours, 25 minutes and 45 seconds(3时25分45秒),作为字符串返回结果。
第2,028行 ⟶ 第2,026行:
==== mw.language:parseFormattedNumber ====
<code
这需要一个以[[#mw.language:formatNum|lang:formatNum()]]格式化的数字,并返回实际数字。换句话说,这基本上是[[#tonumber|<code>tonumber()</code>]]根据语言转换的版本。
第2,034行 ⟶ 第2,032行:
==== 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,048行 ⟶ 第2,046行:
==== mw.language:convertGrammar ====
{{Anchor|mw.language:grammar}}
<code
<br/>
<code
: ''注意两个别称之间的不同参数顺序。<code>convertGrammar</code>匹配MediaWiki的Language对象的相同名称的方法的顺序,而<code>grammar</code>匹配相同名称的解析器函数的顺序,可参考帮助:魔术字#本地化。''
第2,059行 ⟶ 第2,057行:
==== mw.language:gender ====
<code
<br/>
<code
选择对应<code>what</code>的性别的字符串,可以是male、female或注册的用户名。
==== mw.language:getArrow ====
<code
返回对应方向<code>direction</code>的Unicode箭头字符:
第2,078行 ⟶ 第2,076行:
==== 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,111行 ⟶ 第2,109行:
==== mw.message.new ====
<code
创建一个给定消息<code>key</code>的新消息对象。
第2,119行 ⟶ 第2,117行:
==== mw.message.newFallbackSequence ====
<code
创建给定的消息的新的消息对象(存在的第一个会被使用)。
第2,126行 ⟶ 第2,124行:
==== mw.message.newRawMessage ====
<code
创建新的消息对象,使用给定的文本,而不是查找国际化的(internationalized)消息。剩下的参数会传递到新对象的<code>[[#mw.message:params|params()]]</code>方法中。
第2,133行 ⟶ 第2,131行:
==== 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,157行 ⟶ 第2,155行:
==== mw.message:rawParams ====
<code
<br/>
<code
像[[#mw.message:params|:params()]],但是会先通过[[#mw.message.rawParam|mw.message.rawParam()]]传递所有的参数。
第2,166行 ⟶ 第2,164行:
==== mw.message:numParams ====
<code
<br/>
<code
像[[#mw.message:params|:params()]],但是会先通过[[#mw.message.numParam|mw.message.numParam()]]传递所有的参数。
第2,175行 ⟶ 第2,173行:
==== mw.message:inLanguage ====
<code
指定一个语言,以在加工消息时使用。<code>lang</code>可以是字符串,或者带有<code>getCode()</code>元表的表(比如[[#Language library|语言对象]])。
第2,184行 ⟶ 第2,182行:
==== mw.message:useDatabase ====
<code
指定是否在MediaWiki:命名空间查找消息(比如在数据库中查找),或者只是使用MediaWiki分配的默认消息。
第2,193行 ⟶ 第2,191行:
==== mw.message:plain ====
<code
替换参数按原样返回消息
==== mw.message:exists ====
<code
返回表示消息键是否存在的布尔值。
==== mw.message:isBlank ====
<code
返回表示消息键是否有内容的布尔值。当消息键不存在或者消息是空字符串时返回true。
==== mw.message:isDisabled ====
<code
返回表示消息键是否被禁用的布尔值。如果消息键不存在,或者消息是空字符串,或者是字符串"-"则返回true。
=== 站点信息库 ===
==== mw.site.currentVersion ====
第2,236行 ⟶ 第2,234行:
* '''id''':命名空间数字。
* '''name''':本地命名空间名称。
* '''canonicalName''':规范(canonical)命名空间名称。
* '''displayName''':为命名空间0设置,用于显示的名称(因为这个名称通常是空白字符串)。
* '''hasSubpages''':这个命名空间是否启用了子页面。
第2,275行 ⟶ 第2,273行:
==== mw.site.stats.pagesInCategory ====
<code
: {{red|这个函数是高开销函数}}
第2,291行 ⟶ 第2,289行:
==== 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,309行 ⟶ 第2,307行:
* '''prefix'''——跨wiki前缀。
* '''url'''——跨wiki指向的URL。页面名称由参数$1体现。
* '''isProtocalRelative'''——布尔值,显示URL是否为[[
* '''isLocal'''——这个URL是否是当前wiki的站点的。
* '''isCurrentWiki'''——这个URL是否是为当前wiki的。
* '''isTranscludable'''——使用这个跨wiki前缀的页面能否[[
* '''isExtraLanguageLink'''——跨wiki是否列举在了
* '''displayText'''——对于列举在<code>$wgExtraInterlanguageLinkPrefixes</code>中的链接,跨语言链接显示的文本。未指定时为nil。
* '''tooltip'''——对于列举在<code>$wgExtraInterlanguageLinkPrefixes</code>的链接,当用户悬浮在跨语言链接上时显示的浮窗提示文本。未指定时为nil。
=== 文本库 ===
第2,322行 ⟶ 第2,320行:
==== mw.text.decode ====
<code
<br/>
<code
将字符串中的[[
如果布尔值<code>decodeNameEntities</code>被省略或者为false,则只有被命名的实体“&lt;”“&gt;”“&amp;”“&quot;”和“&nbsp;”会被认可。否则,认可的HTML5命名实体的列表会从PHP的[https://php.net/get_html_translation_table <code>get_html_translation_table</code>]函数中加载。
==== mw.text.encode ====
<code
<br/>
<code
使用[[
如果提供了<code>charset</code>,则它应该是合适的字符串,且被[[#Ustring patterns|Ustring模式]]的括号括住,比如<code>[set]</code>中的“set”。默认的charset是<code>'<>&"\' '</code>(末尾的空格为非换行空格,U+00A0)。
==== 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,355行 ⟶ 第2,353行:
* JSON对象会丢弃含有null值的键。
* 不能直接分辨带有序列整数键的是JSON数组还是JSON对象。
* 带有序列整数键从1开始
==== 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,375行 ⟶ 第2,373行:
==== mw.text.killMarkers ====
<code
除去字符串中所有的[[strip marker]]。
==== mw.text.listToText ====
<code
<br/>
<code
使用自然语言组合一个列表,类似于<code>[[#table.concat|table.concat()]]</code>,但是最后一项前面的分隔符不同。
第2,407行 ⟶ 第2,405行:
==== mw.text.nowiki ====
<code
使用[[
* 以下字符:<code>"</code>、<code>&</code>、<code>'</code>、<code><</code>、<code>=</code>、<code>></code>、<code>[</code>、<code>]</code>、<code>{</code>、<code>|</code>、<code>}</code>
* 字符串开头或新行后面
* 空行会有关联的新行或返回转义的字符(Blank lines will have one of the associated newline or carriage return characters escaped)
* 字符串开始处或新行后
* <code>__</code>会使一个下划线被转义
* <code>://</code>会使冒号被转义
第2,420行 ⟶ 第2,418行:
==== 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,449行 ⟶ 第2,447行:
==== 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,488行 ⟶ 第2,486行:
==== mw.text.unstripNoWiki ====
<code
将MediaWiki的<nowiki> [[strip marker]]替换为对应的文本。其他类型的strip marker不会改变。
==== mw.text.unstrip ====
<code
等同于<code
这个不在显示特殊页面嵌入包含、<ref>后的HTML,就像Scribunto早期版本的那样。
第2,502行 ⟶ 第2,500行:
==== mw.title.equals ====
<code
检测两个标题是否相等。注意比较时忽略碎片(fragments)。
==== mw.title.compare ====
<code
返回-1、0、1,表示标题<code>a</code>是否小于、等于或大于标题<code>b</code>。
第2,514行 ⟶ 第2,512行:
==== mw.title.getCurrentTitle ====
<code
返回当前页面的标题对象。
==== mw.title.new ====
<code
<br/>
<code
: {{red|用ID调用时该函数是高开销函数}}
第2,532行 ⟶ 第2,530行:
==== 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,557行 ⟶ 第2,555行:
* '''subpageText''':如果这是个子页面,子页面名称。否则,和<code>title.text</code>相同。
* '''canTalk''':这个标题的页面能否拥有讨论页。
* '''exists''':该页面是否存在。Media命名空间页面的<code>file.exists</code>别名。对于File命名空间的页面,这将检查文件描述页面的存在,而不是文件本身。{{red|此函数[[#Expensive properties|可能为高开销]]}}。
* '''file''','''fileExists''':参见下面的[[#File metadata|#文件元数据]]。
* '''isContentPage''':这个页面是否在内容命名空间内。
* '''isExternal''':此页面是否具有跨wiki的前缀。
* '''isLocal''':此页面是否在此项目中。例如,在英语维基百科上,任何其他语言维基百科都被视为“本地”(Local),而维基
* '''isRedirect''':是否是重定向页面的标题。{{red|此函数[[#Expensive properties|可能为高开销]]}}。
* '''isSpecialPage''':该页面是否可能是特殊页面(即“Special”命名空间中的页面)。
第2,572行 ⟶ 第2,570行:
* '''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,586行 ⟶ 第2,584行:
* '''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,600行 ⟶ 第2,598行:
* '''pages''':如果文件格式支持多页,这是包含文件每个页面的表,否则为<code>nil</code>。[[#Length operator|“#”操作符]]可以用于获取文件页数。每个单独的页面表都包含一个width和height属性。
* '''size''':文件的字节长度。
* '''mimeType''':文件的[[
* '''length''':媒体文件的长度,单位为秒。不支持长度的媒体则为0。
第2,612行 ⟶ 第2,610行:
==== mw.uri.encode ====
<code
[[
注意"WIKI"格式不是完全可以逆转的,因为空格和下划线都会编码为“_”。
==== mw.uri.decode ====
<code
[[
==== mw.uri.anchorEncode ====
<code
编码字符串以用于MediaWiki URI fragment。
==== mw.uri.buildQueryString ====
<code
将表编码为URI查询字符串。键必须是字符串,值可以是字符串、数字、序列表或布尔值false。
==== mw.uri.parseQueryString ====
<code
将查询字符串<code>s</code>解码为表。字符串中没有值的键会拥有false值,重复多次的键会有序列表作为其值,其他的都会有字符串作为值。
第2,641行 ⟶ 第2,639行:
==== 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,690行 ⟶ 第2,688行:
===== mw.uri:parse =====
<code
将字符串解析为当前的URI对象。字符串中指定的任何字段都会被当前的对象替换;未指定的字段都会保留旧值。
第2,700行 ⟶ 第2,698行:
===== mw.uri:extend =====
<code
将参数表合并到对象的查询表。
第2,717行 ⟶ 第2,715行:
==== mw.ustring.byte ====
<code
返回单独的字节,等同于[[#string.byte|string.byte()]]。
==== mw.ustring.byteoffset ====
<code
返回字符在字符串内的字节偏移值。<code>l</code>和<code>i</code>的默认值都是1.<code>i</code>可以是负数,即倒过来计数。
第2,729行 ⟶ 第2,727行:
==== mw.ustring.char ====
<code
非常像[[#string.char|string.char()]],但是整数为Unicode代码点而非字节值。
第2,738行 ⟶ 第2,736行:
==== 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,764行 ⟶ 第2,762行:
==== 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,786行 ⟶ 第2,784行:
==== mw.ustring.lower ====
<code
非常像[[#string.lower|string.lower()]],但是所有在Unicode中定义了小写到大写转换的字符都会被转换。
第2,793行 ⟶ 第2,791行:
==== 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
将字符串转化为[[
==== mw.ustring.toNFD ====
<code
将字符串转化为[[
==== mw.ustring.upper ====
<code
非常像[[#string.upper|string.upper()]],但是所有在Unicode中定义了大写到小写转换的字符都会被转换。
第2,826行 ⟶ 第2,824行:
==== ustring匹配模式 ====
ustring函数中的匹配模式使用和[[#Patterns|字符串库匹配模式]]相同的语法。主要区别是,字符串类会根据[[
* '''<code>%a</code>''':代表一般类别“控制”中的所有字符。
第2,852行 ⟶ 第2,850行:
bit32 = require( 'bit32' )
bit32库提供了无符号的32位整数的[[
如果字节被编号(就像[[#bit32.extract|bit32.extract()]]中那样),那么0是最低位的字节(带有值2<sup>0</sup>的),31是最高位的(带有值2<sup>31</sup>的)。
==== bit32.band ====
<code
返回参数的“按位与”运算:对于结果中的每一位,只有当所有参数中都设置了该位时,结果中才会有这一位。
第2,864行 ⟶ 第2,862行:
==== bit32.bnot ====
<code
返回<code>x</code>的“取反”。
==== bit32.bor ====
<code
返回参数的“按位或”运算:对于结果中的每一位,只要所有参数中有任何一个设置了该位,结果中就会有这一位。
第2,876行 ⟶ 第2,874行:
==== bit32.btest ====
<code
等同于<code
==== bit32.bxor ====
<code
返回参数的“按位异或”运算:对于结果中的每一位,只有所有参数中设置了该位的参数个数为奇数,结果中才会有这一位。
第2,888行 ⟶ 第2,886行:
==== bit32.extract ====
<code
从<code>n</code>导出<code>width</code>位,以<code>field</code>为开始。访问0到31范围之外的位都是错误的。
第2,895行 ⟶ 第2,893行:
==== bit32.replace ====
<code
替换<code>n</code>中的<code>width</code>位,以<code>field</code>位开始,<code>v</code>开始的低<code>width</code>位。访问0到31范围之外的位都是错误的。
第2,902行 ⟶ 第2,900行:
==== bit32.lshift ====
<code
返回数<code>n</code>向左[[
请注意,超过31的位移将导致0。
==== bit32.rshift ====
<code
返回数<code>n</code>向右[[
请注意,超过31的位移将导致0。
==== bit32.arshift ====
<code
返回数<code>n</code>向右[[
注意超过31的移位将会导致0或4294967295。
==== bit32.lrotate ====
<code
返回数<code>n</code>向左旋转<code>disp</code>位。
第2,930行 ⟶ 第2,928行:
==== bit32.rrotate ====
<code
返回数<code>n</code>向右旋转<code>disp</code>位。
第2,943行 ⟶ 第2,941行:
==== 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>则会抛出错误。
第3,014行 ⟶ 第3,012行:
一些MediaWiki扩展提供额外的Scribunto库。这些都位于表<code>mw</code>中,通常是在表<code>mw.text</code>中,然而,这些只有在安装了特定扩展时才存在(加上Scribunto扩展本身)。
[[#Writing Scribunto libraries|
<!--
=== mw.wikibase ===
第3,067行 ⟶ 第3,065行:
== 与标准Lua的不同之处 ==
=== 改变的函数 ===
以下函数被'''修改'''了:
第3,083行 ⟶ 第3,081行:
以下包被'''几乎移除'''。只有列出来的函数可用。
;
:; [https://www.lua.org/manual/5.1/manual.html#pdf-package.loaded package.loaded]
:; [https://www.lua.org/manual/5.1/manual.html#pdf-package.preload package.preload]
:; [https://www.lua.org/manual/5.1/manual.html#pdf-package.loaders package.loaders]: 可获取本地文件系统或加载C库的加载器不存在。 添加了Module命名空间页面的加载器。
:; [https://www.lua.org/manual/5.1/manual.html#pdf-package.seeall package.seeall()]
;
:; [https://www.lua.org/manual/5.1/manual.html#pdf-os.clock os.clock()]
:; [https://www.lua.org/manual/5.1/manual.html#pdf-os.date os.date()]
:; [https://www.lua.org/manual/5.1/manual.html#pdf-os.difftime os.difftime()]
:; [https://www.lua.org/manual/5.1/manual.html#pdf-os.time os.time()]
;
:; [https://www.lua.org/manual/5.1/manual.html#pdf-debug.traceback debug.traceback()]
第3,167行 ⟶ 第3,165行:
Scribunto扩展包括一个用于测试用例的基类<code>Scribunto_LuaEngineTestBase</code>,该类将针对LuaSandbox和LuaStandalone引擎运行测试。
库的测试用例应该扩展这个类,并且不应该覆盖<code>static function suite()</code>。
在Scribunto扩展中,测试用例应该在<code>tests/engines/LuaCommon/''Name''LibraryTest.php</code>并添加到{{phpi|ScribuntoHooks::unitTestsList()}}中的数组中(在<code>common/Hooks.php</code>中),扩展应该在自己的<code>[[mw:Manual:Hooks/UnitTestsList|UnitTestsList]]</code>钩子函数中添加测试用例,可能取决于是否设置了<code>$wgAutoloadClasses['Scribunto_LuaEngineTestBase']</code>。
大多数时候,制作测试用例需要做的包括:
第3,213行 ⟶ 第3,211行:
有(至少)两种方式来运行PHPUnit测试:
# 针对核心运行phpunit,允许tests/phpunit/suites/ExtensionsTestSuite.php使用[[mw:Manual:Hooks/UnitTestsList|UnitTestsList]]钩子找到扩展的测试。 如果您的扩展的测试类名称都包含一个唯一的组件(例如扩展的名称),则可以使用<code>--filter</code>选项以仅运行您的扩展的测试。
# 对扩展目录运行phpunit,这将获取以“Test.php”结尾的任何文件。
第3,232行 ⟶ 第3,230行:
Scribunto中包含的模块应该在上面的[[#Scribunto libraries|Scribunto库]]部分中包含文档。扩展库应该在其自己的扩展页面的子页面中包含文档,并从上方的[[#Extension library|扩展库]]章节中链接到该文档。
== 参见 ==
* [[Lua]]
{{anchor|License}}
== 许可协议 ==
本手册(中文翻译)取自[[mw:Extension:Scribunto/Lua_reference_manual/zh|MediaWiki网站]],以[[cc-by-sa:3.0|CC BY-SA 3.0]]授权。
本手册(
▲本手册(的英文原文)取自[https://www.lua.org/manual/5.1/index.html Lua 5.1 参考手册],在[https://www.lua.org/license.html MIT许可证]下可用。
{{-}}
▲{{MIT License|© 1994–2012 Lua.org,PUC-Rio}}
{{帮助页面}}
[[Category:
|