新增的內容 刪去的內容
無編輯摘要 |
小 (文本替换 - 替换“的的”为“的”) |
||
(未顯示2個用戶的12個中間版本) | |||
第5行: | 第5行: | ||
| text = 此页面记载的是最新版本的Scribunto扩展的文档。某些功能可能尚未部署。 |
| text = 此页面记载的是最新版本的Scribunto扩展的文档。某些功能可能尚未部署。 |
||
}} |
}} |
||
{{Namespaces}} |
|||
此手册记载[[Lua]]的文档,用于MediaWiki的Scribunto扩展。 |
此手册记载[[Lua]]的文档,用于MediaWiki的Scribunto扩展。 |
||
部分内容(英文原文)取自[https://www.lua.org/manual/5.1/index.html Lua 5.1参考手册](翻译时参考了[https://www.runoob.com/manual/lua53doc/ Lua参考手册的中文翻译]),其许可协议为[[#License|MIT许可证]]。 |
部分内容(英文原文)取自[https://www.lua.org/manual/5.1/index.html Lua 5.1参考手册](翻译时参考了[https://www.runoob.com/manual/lua53doc/ Lua参考手册的中文翻译]),其许可协议为[[#License|MIT许可证]]。 |
||
{{TOCright}} |
|||
== 介绍 == |
== 介绍 == |
||
第35行: | 第34行: | ||
从模板的环境中调用Lua代码确实是一个好办法。 |
从模板的环境中调用Lua代码确实是一个好办法。 |
||
这意味着从调用页面的角度来说,语法不依赖与模板逻辑是否被Lua或者 |
这意味着从调用页面的角度来说,语法不依赖与模板逻辑是否被Lua或者wikitext执行。 |
||
这也避免了把复杂语法加到wiki内容命名空间中。 |
这也避免了把复杂语法加到wiki内容命名空间中。 |
||
第45行: | 第44行: | ||
对于模块来说,最好将所有的函数和变量声明为局部变量。 |
对于模块来说,最好将所有的函数和变量声明为局部变量。 |
||
=== 访问 |
=== 访问wikitext中的参数 === |
||
<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>。 |
<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>。 |
||
框架对象也用来访问对应环境的 |
框架对象也用来访问对应环境的wikitext解析器,例如[[#frame:callParserFunction|调用解析器函数]]、[[#frame:expandTemplate|扩展模板]]以及[[#frame:preprocess|展开任意的wikitext字符串]]。 |
||
=== 返回文本 === |
=== 返回文本 === |
||
模块函数通常返回单个的字符串;无论返回什么值都会通过[[#tostring|tostring()]]转换,然后连接在一起。这个字符串就是转化成 |
模块函数通常返回单个的字符串;无论返回什么值都会通过[[#tostring|tostring()]]转换,然后连接在一起。这个字符串就是转化成wikitext代码<code><nowiki>{{#invoke:}}</nowiki></code>的结果。 |
||
在解析页面的这一点上,模板都是已经被展开的,解析器函数和扩展标签都已经被处理,而且预存的转换(例如签名的扩展以及[[Help:链接#管道技巧|管道技巧]])都已经完成。因此,模块不能在输出文本中使用这些特性。例如,如果一个模块返回<code><nowiki>"Hello, world! {{welcome}}"</nowiki></code>,页面就会显示“Hello, world! <nowiki>{{welcome}}</nowiki>”。 |
在解析页面的这一点上,模板都是已经被展开的,解析器函数和扩展标签都已经被处理,而且预存的转换(例如签名的扩展以及[[Help:链接#管道技巧|管道技巧]])都已经完成。因此,模块不能在输出文本中使用这些特性。例如,如果一个模块返回<code><nowiki>"Hello, world! {{welcome}}"</nowiki></code>,页面就会显示“Hello, world! <nowiki>{{welcome}}</nowiki>”。 |
||
另一方面,替换引用是在加工的早期阶段处理的,所以只有当其他尝试的替换引用会被处理时才使用<code><nowiki>{{subst:#invoke:}}</nowiki></code>。失败的替换引用因为会保持为 |
另一方面,替换引用是在加工的早期阶段处理的,所以只有当其他尝试的替换引用会被处理时才使用<code><nowiki>{{subst:#invoke:}}</nowiki></code>。失败的替换引用因为会保持为wikitext,所以都会在'''下一次'''编辑时被处理。这通常需要避免。 |
||
=== 模块文档 === |
=== 模块文档 === |
||
Scruibunto允许模块可以被自动关联的模块 |
Scruibunto允许模块可以被自动关联的模块wikitext页面关联文档;默认情况下,模块的“/doc”子页面是用来作为文档,并且会在模块页面的代码顶部显示其内容。例如,“模块:Bananas”的文档页面就是“模块:Bananas/doc”。 |
||
这也可以使用以下MediaWiki命名空间下的消息配置: |
这也可以使用以下MediaWiki命名空间下的消息配置: |
||
* <code>scribunto-doc-page-name</code> —设置用来作文档页面的名称。 模块(除了模块:prefix)的名称会通过<code>$1</code>。 如果在模块命名空间,这里的页面通常会视为 |
* <code>scribunto-doc-page-name</code> —设置用来作文档页面的名称。 模块(除了模块:prefix)的名称会通过<code>$1</code>。 如果在模块命名空间,这里的页面通常会视为wikitext而不是Lua代码,也不会被<code><nowiki>{{#invoke:}}</nowiki></code>使用。 模块的页面通常是“Module:$1/doc”这样的模块/doc子页面。注意解析器函数等其他可扩展代码在这个消息中不被使用。 请注意,此消息中解析器函数和其他大括号扩展可能无法使用。 |
||
* <code>scribunto-doc-page-does-not-exist</code> — 文档页面不存在时显示的消息。 页面名称传递为<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-show</code> — 文档页面存在时显示的消息。 页面名称传递为<code>$1</code>。 默认是嵌入包含文档页面。 |
||
* <code>scribunto-doc-page-header</code> — 查看文档页面本身时显示的标题。 模块的名称(有Module:前缀)传递为<code>$1</code>。 默认以斜体显示简要说明。 |
* <code>scribunto-doc-page-header</code> — 查看文档页面本身时显示的标题。 模块的名称(有Module:前缀)传递为<code>$1</code>。 默认以斜体显示简要说明。 |
||
注意模块不可以被直接分类,也不可以直接添加跨 |
注意模块不可以被直接分类,也不可以直接添加跨站链接。这些应该放在文档页面里面的{{tag|includeonly}}标签中,当文档页面被引用到模块页面时,这些分类和跨站链接就会应用于模块页面。 |
||
这些应该放在文档页面里面的{{tag|includeonly}}标签中,当文档页面被引用到模块页面时,这些分类和跨维基链接就会应用于模块页面。 |
|||
== Lua语言 == |
== Lua语言 == |
||
第224行: | 第222行: | ||
==== 数字(number) ==== |
==== 数字(number) ==== |
||
Lua只有一种数字类型,就是典型的[[ |
Lua只有一种数字类型,就是典型的[[双精度浮点数]]。这种格式下,-9007199254740992到9007199254740992之间的整数都会准确表达,更大的数和带有小数部分的数将会受到舍入的误差。 |
||
数字可以用点(<code>.</code>)来表示小数,例如<code>123456.78</code>。数字也可以用不带空格的[[ |
数字可以用点(<code>.</code>)来表示小数,例如<code>123456.78</code>。数字也可以用不带空格的[[科学计数法]],例如<code>1.23e-10</code>、<code>123.45e20</code>或者<code>1.23E5</code>。也可以用16进制表示整数,方法就是以<code>0x</code>开头,例如<code>0x3A</code>。 |
||
虽然[[ |
虽然[[NaN]]和正负无穷大都可以正确地储存、处理,但是Lua不提供相应的直接文字表示方法。<code>math.huge</code>是正无穷大,相当于<code>1/0</code>,此外,像<code>0/0</code>这样的除法就可以生成NaN。 |
||
重申一遍,在转化为布尔值时,任何数字都会被视为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>。 |
重申一遍,在转化为布尔值时,任何数字都会被视为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 |
* <code>[''[[#Expressions|表达式1]]''] = ''[[#Expressions|表达式2]]''</code>,意思是键为''表达式1'',它与值''表达式2''匹配。即''表达式1''的值是''表达式2''。 |
||
* <code |
* <code>''[[#name|名称]]'' = ''[[#Expressions|表达式]]''</code>,它等价于<code>["''名称''"] = ''表达式''</code>。 |
||
* <code>''[[#Expressions|表达式]]''</code>大致相当于<code |
* <code>''[[#Expressions|表达式]]''</code>大致相当于<code>[''i''] = ''表达式''</code>,在这里''i''是在这个表中从1开始排序的正整数。如果最后一个字段和表达式有多个值,所有的值都会使用;否则只有第一个会保留。 |
||
表中的字段用中括号访问,例如<code>table[key]</code>。字符串键(key)同样也可以用作点来表示的[[#name|名字]],例如<code>table.key</code>就与<code>table['key']</code>等价。调用表中的一个函数也可以用冒号,例如<code |
表中的字段用中括号访问,例如<code>table[key]</code>。字符串键(key)同样也可以用作点来表示的[[#name|名字]],例如<code>table.key</code>就与<code>table['key']</code>等价。调用表中的一个函数也可以用冒号,例如<code>table:func( ... )</code>,相当于<code>table['func']( table, ... )</code>或者<code>table.func( table, ... )</code>。 |
||
{{Anchor|sequence}} |
{{Anchor|sequence}} |
||
第288行: | 第286行: | ||
Lua中的函数是一等的(first-class)的值:可以匿名创建,或作为参数传递,或给变量赋值,等等。 |
Lua中的函数是一等的(first-class)的值:可以匿名创建,或作为参数传递,或给变量赋值,等等。 |
||
函数通过<code>function</code>(“函数”的英文)关键字,并使用圆括号调用。有一些[[ |
函数通过<code>function</code>(“函数”的英文)关键字,并使用圆括号调用。有一些[[语法糖]]可以用来命名函数,局部函数,并且可以作为表中的一个域值。参看[[#Function declarations|函数声明]]和[[#Function calls|函数调用]]。 |
||
Lua函数是[[闭包 (计算机科学)|闭包]],这意味着它们维护对它们声明的作用域的引用,并可以访问和操作该作用域中的变量。 |
Lua函数是[[闭包 (计算机科学)|闭包]],这意味着它们维护对它们声明的作用域的引用,并可以访问和操作该作用域中的变量。 |
||
第312行: | 第310行: | ||
以下元表字段可以影响表本身: |
以下元表字段可以影响表本身: |
||
; __index |
; __index |
||
: 如果表访问<code>t[key]</code>返回nil就使用这个。 如果这个字段的值是表,访问就会在这个表中重复进行,例如<code>__index[''键'']</code>(会调用这个表的元表的__index)。 如果这个字段的值是函数,函数就会像<code |
: 如果表访问<code>t[key]</code>返回nil就使用这个。 如果这个字段的值是表,访问就会在这个表中重复进行,例如<code>__index[''键'']</code>(会调用这个表的元表的__index)。 如果这个字段的值是函数,函数就会像<code>__index( t, ''键'' )</code>这样调用。 [[#rawget|rawget()]]函数会绕过这个元方法。 |
||
; __newindex |
; __newindex |
||
: 这个元方法用于将键赋值到表中,即<code |
: 这个元方法用于将键赋值到表中,即<code>t[''键'']=''值''</code>,但是<code>[[#rawget|rawget]]( t, key )</code>会返回空值(nil)。 如果这个字段的值是表,赋值就会在这个表中重复进行,例如<code>__newindex[''键''] = ''值''</code>(会调用这个表的元表的__newindex)。 如果这个字段的值是函数,那么函数就会像这样调用:<code>__newindex( t, ''键'', ''值'')</code>。 [[#rawset|rawset()]]函数会绕过这个元方法。 |
||
; __call |
; __call |
||
: 对表应用函数调用语法<code |
: 对表应用函数调用语法<code>t( ... )</code>时,就会使用这个元方法。 这个值必须是函数,会像<code>__call( t, ··· )</code>这样调用。 |
||
; {{Anchor|weak tables}}__mode |
; {{Anchor|weak tables}}__mode |
||
: 这用于使表保持弱引用(weak references)。 这个值一定是一个字符串。 默认情况下,任何一个值被作为表格中的键或值时是不会被垃圾回收的。 但如果元表字段包含字母k,且没有非弱引用,键可能会被作为垃圾收集。而且如果包含v则值有可能也会作为垃圾收集;其他的情况,对应的键和值都会从表中移除。 注意,如果在表用作元表之后字段被改变,则行为未定义。 |
: 这用于使表保持弱引用(weak references)。 这个值一定是一个字符串。 默认情况下,任何一个值被作为表格中的键或值时是不会被垃圾回收的。 但如果元表字段包含字母k,且没有非弱引用,键可能会被作为垃圾收集。而且如果包含v则值有可能也会作为垃圾收集;其他的情况,对应的键和值都会从表中移除。 注意,如果在表用作元表之后字段被改变,则行为未定义。 |
||
第343行: | 第341行: | ||
<div id="binop-note" style="padding:0 1em;text-indent: -1em;"><sup>†</sup> 对于二元运算符,Lua首先检查左边的变量的元表(若有),如果左边变量的元方法不存在则寻找右边的变量的元方法。</div> |
<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="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> |
<div id="metatable-note" style="padding:0 1em;text-indent: -1em;"><sup>*</sup> |
||
__metatable会同时影响[[#getmetatable|getmetatable()]]和[[#setmetatable|setmetatable()]]</div> |
__metatable会同时影响[[#getmetatable|getmetatable()]]和[[#setmetatable|setmetatable()]]</div> |
||
</div> |
</div> |
||
第390行: | 第388行: | ||
| / || 除法 || a / b || __div || 除以零不会出错,会返回NaN或者无穷大 |
| / || 除法 || a / b || __div || 除以零不会出错,会返回NaN或者无穷大 |
||
|- |
|- |
||
| % || 模运算 || a % b || __mod || 定义为<code |
| % || 模运算 || a % b || __mod || 定义为<code>a % b == a - math.floor( a / b ) * b</code> |
||
|- |
|- |
||
| ^ || 幂运算 || a ^ b || __pow || 允许非整数指数 |
| ^ || 幂运算 || a ^ b || __pow || 允许非整数指数 |
||
第401行: | 第399行: | ||
Lua的关系运算符是<code>==</code>、<code>~=</code>、<code><</code>、<code>></code>、<code><=</code>和<code>>=</code>。关系运算的结果一定是布尔值(boolean)。 |
Lua的关系运算符是<code>==</code>、<code>~=</code>、<code><</code>、<code>></code>、<code><=</code>和<code>>=</code>。关系运算的结果一定是布尔值(boolean)。 |
||
等于号(<code>==</code>)首先比较两个值的种类;如果两个值是不同的种类,结果为假(false)。然后比较值:空值、布尔值、数字和字符串照常比较。对于函数,则是看两个函数是否引用同一个准确的函数对象;像这样检测两个不同的(但作用相同的)匿名函数<code |
等于号(<code>==</code>)首先比较两个值的种类;如果两个值是不同的种类,结果为假(false)。然后比较值:空值、布尔值、数字和字符串照常比较。对于函数,则是看两个函数是否引用同一个准确的函数对象;像这样检测两个不同的(但作用相同的)匿名函数<code>function() end == function() end</code>一定会返回假(false)。表也会默认像函数这样比较,但是可能会由于使用__eq[[#Metatables|元方法]]而改变结果。 |
||
不等号(<code>~=</code>)与等于号作用相反。 |
不等号(<code>~=</code>)与等于号作用相反。 |
||
第407行: | 第405行: | ||
对于排序运算符,如果两者都是数字,或者两者都是字符串,则直接进行比较。其次检查元方法: |
对于排序运算符,如果两者都是数字,或者两者都是字符串,则直接进行比较。其次检查元方法: |
||
* <code |
* <code>a < b</code>使用<code>__lt</code> |
||
* <code |
* <code>a <= b</code>使用<code>__le</code>如果可用,或者<code>__lt</code>可用,那么它等价于<code>not ( b < a )</code> |
||
* <code |
* <code>a > b</code>等价于<code>b < a</code> |
||
* <code |
* <code>a >= b</code>等价于<code>b <= a</code> |
||
如果必需的元方法不可用,会产生错误。 |
如果必需的元方法不可用,会产生错误。 |
||
第424行: | 第422行: | ||
对于<code>not</code>,其结果一定是布尔值(true或false)。 |
对于<code>not</code>,其结果一定是布尔值(true或false)。 |
||
注意由<code>and</code>和<code>or</code>组成的简短语句。例如,<code |
注意由<code>and</code>和<code>or</code>组成的简短语句。例如,<code>foo() or bar()</code>只会调用<code>bar()</code>,除非<code>foo()</code>不是在它的返回false或nil。 |
||
==== 连接运算符 ==== |
==== 连接运算符 ==== |
||
连接运算符就是两个点(dot),比如<code |
连接运算符就是两个点(dot),比如<code>a .. b</code>。如果两个操作数都是数字或字符串,它们会被转化为字符串然后返回。但是如果__concat[[#Metatables|元方法]]可用,就会使用这样的元方法。如果它存在但无效,则会产生错误。 |
||
注意Lua的字符串是不可变的(immutable),而且Lua不提供任何类型的“字符串构造器(string builder)”,所以反复进行<code |
注意Lua的字符串是不可变的(immutable),而且Lua不提供任何类型的“字符串构造器(string builder)”,所以反复进行<code>a = a .. b</code>会必须为每次迭代创建一个新字符串,并最终将旧字符串作为垃圾收集。如果许多字符串都需要连接,则应使用[[#string.format|string.format()]],或将所有的字符串添加到一个[[#sequence|序列]]然后最后使用[[#table.concat|table.concat()]]连接。 |
||
==== 长度运算符 ==== |
==== 长度运算符 ==== |
||
第459行: | 第457行: | ||
# or |
# or |
||
在同一级中,二元运算符会从左到右运算,例如<code |
在同一级中,二元运算符会从左到右运算,例如<code>a / b / c</code>相当于<code>(a / b) / c</code>。幂运算和级联会从右往左,例如<code>a ^ b ^ c</code>相当于<code>a ^ (b ^ c)</code>> |
||
{{Anchor|Function calls}} |
{{Anchor|Function calls}} |
||
第563行: | 第561行: | ||
</syntaxhighlight> |
</syntaxhighlight> |
||
[[#select|select()]]函数就是用来作用于这些参数表达式的;特别地,如要获取参数表达式的值的数量,应当使用<code |
[[#select|select()]]函数就是用来作用于这些参数表达式的;特别地,如要获取参数表达式的值的数量,应当使用<code>select( '#', ... )</code>而非<code>#{ ... }</code>来数参数表达式有多少个,因为<code>{ ... }</code>不一定是[[#sequence|序列]]。 |
||
Lua为将函数声明和赋值提供到变量中提供语法糖;参见[[#Function declaration statements|函数声明语句]]的细节。 |
Lua为将函数声明和赋值提供到变量中提供语法糖;参见[[#Function declaration statements|函数声明语句]]的细节。 |
||
第589行: | 第587行: | ||
{{Anchor|block}} |
{{Anchor|block}} |
||
'''语句块(block)'''也是语句序列,就像一个代码块(chunk)。语句块可以被分隔以创建单个语句(statement):<code |
'''语句块(block)'''也是语句序列,就像一个代码块(chunk)。语句块可以被分隔以创建单个语句(statement):<code>do ''语句块'' end</code>。这些通常用来限制局部变量的作用范围,或者在另一个块的中间加入<code>return</code>或<code>break</code>。 |
||
==== 赋值 ==== |
==== 赋值 ==== |
||
<code |
<code>''变量列表'' = [[#expression-list|''表达式列表'']]</code> |
||
''var-list''是由逗号分隔的变量;''表达式列表''是由逗号分隔的一组一个或多个表达式。所有的表达式都会在赋值之前被求值,所以<code |
''var-list''是由逗号分隔的变量;''表达式列表''是由逗号分隔的一组一个或多个表达式。所有的表达式都会在赋值之前被求值,所以<code>a, b = b, a</code>会交换<var>a</var>与<var>b</var>的值。 |
||
==== 局部变量定义 ==== |
==== 局部变量定义 ==== |
||
<code |
<code>local ''变量列表''</code> |
||
<code |
<code>local ''变量列表'' = [[#expression-list|''表达式列表'']]</code> |
||
局部变量可以在一个[[#block|语句块]]或[[#block|代码块]]内任意地方声明。第一种形式,不需要表达式列表,声明变量但不赋值,所以这些变量都会将nil作为值二中形式,为局部变量赋值,参见上面的[[#Assignments|赋值]]。 |
局部变量可以在一个[[#block|语句块]]或[[#block|代码块]]内任意地方声明。第一种形式,不需要表达式列表,声明变量但不赋值,所以这些变量都会将nil作为值二中形式,为局部变量赋值,参见上面的[[#Assignments|赋值]]。 |
||
注意:局部变量显式声明于local关键字后面,形式为''local 变量名''。比如语句 <code |
注意:局部变量显式声明于local关键字后面,形式为''local 变量名''。比如语句 <code>local x = x</code> 声明一个名为“x”的局部变量,并将全局变量“x”的值赋予这个变量。局部变量只在其声明的语句块结尾前的地方生效。 |
||
==== 控制结构 ==== |
==== 控制结构 ==== |
||
{{Anchor|while}} |
{{Anchor|while}} |
||
<code |
<code>while ''表达式'' do ''[[#block|语句块]]'' end</code> |
||
只要''表达式''还是(视为)true时,就会反复执行while语句。 |
只要''表达式''还是(视为)true时,就会反复执行while语句。 |
||
{{Anchor|repeat}} |
{{Anchor|repeat}} |
||
<code |
<code>repeat ''[[#block|语句块]]'' until ''表达式''</code> |
||
反复执行''语句块'',直到''表达式''(视为)是true。语句块内声明的局部变量可以用于表达式中。 |
反复执行''语句块'',直到''表达式''(视为)是true。语句块内声明的局部变量可以用于表达式中。 |
||
{{Anchor|for}} |
{{Anchor|for}} |
||
<code |
<code>for ''名称'' = ''表达式1'', ''表达式2'', ''表达式3'' do ''[[#block|语句块]]'' end</code><br/> |
||
<code |
<code>for ''名称'' = ''表达式1'', ''表达式2'' do ''[[#block|语句块]]'' end</code> |
||
for循环的第一种形式会声明一个局部变量,然后从''exp1''以''exp3''的步长到''exp2''重复语句块。注意''exp3''可以省略,相当于1,但是非数字值比如<code>nil</code>和<code>false</code>是错误的。循环开始前,所有的表达式都会先被计算。 |
for循环的第一种形式会声明一个局部变量,然后从''exp1''以''exp3''的步长到''exp2''重复语句块。注意''exp3''可以省略,相当于1,但是非数字值比如<code>nil</code>和<code>false</code>是错误的。循环开始前,所有的表达式都会先被计算。 |
||
第640行: | 第638行: | ||
{{Anchor|iterators}} |
{{Anchor|iterators}} |
||
<code |
<code>for ''变量列表'' in [[#expression-list|''表达式列表'']] do ''[[#block|语句块]]'' end</code> |
||
第二种形式的for循环会与'''迭代'''函数一起作用。就像在第一种形式里,''表达式列表''会在开始循环之前就赋值了。 |
第二种形式的for循环会与'''迭代'''函数一起作用。就像在第一种形式里,''表达式列表''会在开始循环之前就赋值了。 |
||
第664行: | 第662行: | ||
{{Anchor|if}} |
{{Anchor|if}} |
||
<code |
<code>if ''表达式1'' then ''[[#block|语句块1]]'' elseif ''表达式2'' then ''[[#block|语句块2]]'' else ''[[#block|语句块3]]'' end</code> |
||
当''表达式1''返回true时执行''语句块1'',否则,当''表达式2''返回true时执行''语句块2'',否则执行''语句块3''。<code |
当''表达式1''返回true时执行''语句块1'',否则,当''表达式2''返回true时执行''语句块2'',否则执行''语句块3''。<code>else ''语句块3''</code>部分可以省去,<code>elseif ''表达式2'' then ''语句块2''</code>部分可以重复,也可以省去。 |
||
{{Anchor|return}} |
{{Anchor|return}} |
||
<code |
<code>return [[#expression-list|''表达式列表'']]</code> |
||
返回语句用来返回从函数或者[[#chunk|代码块]](只是一个函数)。''表达式列表''是由逗号分隔开的零个或更多个表达式。 |
返回语句用来返回从函数或者[[#chunk|代码块]](只是一个函数)。''表达式列表''是由逗号分隔开的零个或更多个表达式。 |
||
第675行: | 第673行: | ||
Lua实现[[尾调用|尾调用(tail calls)]]。如果表达式列表包含一个函数调用,对那个函数的调用会重新使用当前的堆栈项(stack frame)。这可用于处理调用堆栈的函数,比如<code>[[#getfenv|getfenv()]]</code>和<code>[[#debug.traceback|debug.traceback()]]</code>。 |
Lua实现[[尾调用|尾调用(tail calls)]]。如果表达式列表包含一个函数调用,对那个函数的调用会重新使用当前的堆栈项(stack frame)。这可用于处理调用堆栈的函数,比如<code>[[#getfenv|getfenv()]]</code>和<code>[[#debug.traceback|debug.traceback()]]</code>。 |
||
返回语句必须是[[#block|语句块]]的最后一个语句。如果某些原因语句块的中间需要返回,那么可能需要明显的语句块<code |
返回语句必须是[[#block|语句块]]的最后一个语句。如果某些原因语句块的中间需要返回,那么可能需要明显的语句块<code>do return end</code>。 |
||
{{Anchor|break}} |
{{Anchor|break}} |
||
第682行: | 第680行: | ||
break语句用来中止一个while、repeat或for循环的执行,并跳到循环后面的语句。 |
break语句用来中止一个while、repeat或for循环的执行,并跳到循环后面的语句。 |
||
break声明必须是[[#block|语句块(block)]]的最后一个声明。如果某些原因语句块的中间需要中断,那么可能需要明显的语句块<code |
break声明必须是[[#block|语句块(block)]]的最后一个声明。如果某些原因语句块的中间需要中断,那么可能需要明显的语句块<code>do return end</code>。 |
||
==== 函数调用作为语句 ==== |
==== 函数调用作为语句 ==== |
||
第710行: | 第708行: | ||
注意,这里的冒号符号与[[#Function calls|函数调用]]的冒号符号相类似,在参数列表的开头添加了一个隐式参数,名为<code>self</code>。 |
注意,这里的冒号符号与[[#Function calls|函数调用]]的冒号符号相类似,在参数列表的开头添加了一个隐式参数,名为<code>self</code>。 |
||
===错误处理=== |
=== 错误处理 === |
||
错误可以通过[[#error|error()]]和[[#assert|assert()]]“抛出”,使用[[#pcall|pcall()]] 或者[[#xpcall|xpcall()]]可以“捕获”错误。注意,某些Scribunto的内部错误是不能被Lua层面的代码捕获处理。 |
错误可以通过[[#error|error()]]和[[#assert|assert()]]“抛出”,使用[[#pcall|pcall()]] 或者[[#xpcall|xpcall()]]可以“捕获”错误。注意,某些Scribunto的内部错误是不能被Lua层面的代码捕获处理。 |
||
第767行: | 第765行: | ||
==== assert ==== |
==== assert ==== |
||
<code |
<code>assert( v, message, ... )</code> |
||
如果<code>v</code>是nil或false,抛出错误,<code>message</code>就会用作错误的文本:如果错误文本为nil(或者未指定),则文本是"assertion failed!"(“断言失败!”);如果是字符串或者数字,文字就是那个值;否则assert本身就会抛出错误。 |
如果<code>v</code>是nil或false,抛出错误,<code>message</code>就会用作错误的文本:如果错误文本为nil(或者未指定),则文本是"assertion failed!"(“断言失败!”);如果是字符串或者数字,文字就是那个值;否则assert本身就会抛出错误。 |
||
第784行: | 第782行: | ||
==== error ==== |
==== error ==== |
||
<code |
<code>error( message, level )</code> |
||
用文本<code>message</code>来发出一个错误。 |
用文本<code>message</code>来发出一个错误。 |
||
第791行: | 第789行: | ||
==== getfenv ==== |
==== getfenv ==== |
||
<code |
<code>getfenv( f )</code> |
||
注意,这个函数可能会无效,取决于配置中的<code>allowEnvFuncs</code>。 |
注意,这个函数可能会无效,取决于配置中的<code>allowEnvFuncs</code>。 |
||
第804行: | 第802行: | ||
==== getmetatable ==== |
==== getmetatable ==== |
||
<code |
<code>getmetatable( table )</code> |
||
返回这个[[#table|表]]的[[#Metatables|元表]]。其他的类型都会返回nil。 |
返回这个[[#table|表]]的[[#Metatables|元表]]。其他的类型都会返回nil。 |
||
第811行: | 第809行: | ||
==== ipairs ==== |
==== ipairs ==== |
||
<code |
<code>ipairs( t )</code> |
||
返回3个值:迭代函数、表<code>t</code>和0。它是供[[#iterators|<code>for</code>的迭代形式]]使用的: |
返回3个值:迭代函数、表<code>t</code>和0。它是供[[#iterators|<code>for</code>的迭代形式]]使用的: |
||
第823行: | 第821行: | ||
它会迭代数对(1, t[1])、(2,t[2])等,直到t[i]是nil时。 |
它会迭代数对(1, t[1])、(2,t[2])等,直到t[i]是nil时。 |
||
如果<code>__ipairs</code>[[#Metatables|元方法]]存在,那么标准行为会被覆盖,调用会返回与<code |
如果<code>__ipairs</code>[[#Metatables|元方法]]存在,那么标准行为会被覆盖,调用会返回与<code>__ipairs( t )</code>的返回值一致的值。 |
||
==== next ==== |
==== next ==== |
||
<code |
<code>next( table, key )</code> |
||
允许遍历表中的键。如果<code>key</code>是nil或者未指定,返回表中的第一个键和值,否则,返回下一个键和值。如果没有更多的键可以用,返回nil。可以通过使用<code |
允许遍历表中的键。如果<code>key</code>是nil或者未指定,返回表中的第一个键和值,否则,返回下一个键和值。如果没有更多的键可以用,返回nil。可以通过使用<code>next( t ) == nil</code>来检查表是否是空的。 |
||
注意键被返回的顺序是没有指定的,即使表有数字的索引(indexes)。如要以数字顺序遍历表,使用[[#for|数字的for]]或[[#ipairs|ipairs]]。 |
注意键被返回的顺序是没有指定的,即使表有数字的索引(indexes)。如要以数字顺序遍历表,使用[[#for|数字的for]]或[[#ipairs|ipairs]]。 |
||
第835行: | 第833行: | ||
==== pairs ==== |
==== pairs ==== |
||
<code |
<code>pairs( t )</code> |
||
返回三个值:迭代器函数([[#next|next]]或者类似的)、表<code>t</code>和nil。这是用于[[#iterators|<code>for</code>的迭代器形式]]。 |
返回三个值:迭代器函数([[#next|next]]或者类似的)、表<code>t</code>和nil。这是用于[[#iterators|<code>for</code>的迭代器形式]]。 |
||
第847行: | 第845行: | ||
这会遍历<code>t</code>中的键值对,就像[[#next|next]]做的那样。参考[[#next|next]]的文档以了解遍历期间修改表的限制。 |
这会遍历<code>t</code>中的键值对,就像[[#next|next]]做的那样。参考[[#next|next]]的文档以了解遍历期间修改表的限制。 |
||
如果__pairs[[#Metatables|元方法]]存在,那么标准行为会被覆盖,调用会返回与<code |
如果__pairs[[#Metatables|元方法]]存在,那么标准行为会被覆盖,调用会返回与<code>__pairs( t )</code>的返回值一致的值。 |
||
==== pcall ==== |
==== pcall ==== |
||
<code |
<code>pcall( f, ... )</code> |
||
用指定的参数在“保护模式”下调用函数<code>f</code>。这意味着如果在调用<code>f</code>时出错,pcall会返回false与错误消息。如果没有错误发生,pcall会返回true与调用返回的所有值。 |
用指定的参数在“保护模式”下调用函数<code>f</code>。这意味着如果在调用<code>f</code>时出错,pcall会返回false与错误消息。如果没有错误发生,pcall会返回true与调用返回的所有值。 |
||
用[[ |
用[[伪代码]]表示,<code>pcall</code>的定义类似如下: |
||
<syntaxhighlight lang="lua"> |
<syntaxhighlight lang="lua"> |
||
第867行: | 第865行: | ||
==== rawequal ==== |
==== rawequal ==== |
||
<code |
<code>rawequal( a, b )</code> |
||
与<code |
与<code>a == b</code>相同,只是忽略了所有__eq[[#Metatables|元方法]]。 |
||
==== rawget ==== |
==== rawget ==== |
||
<code |
<code>rawget( table, k )</code> |
||
与<code>table[k]</code>相同,只是忽略了所有__index[[#Metatables|元方法]]。 |
与<code>table[k]</code>相同,只是忽略了所有__index[[#Metatables|元方法]]。 |
||
==== rawset ==== |
==== rawset ==== |
||
<code |
<code>rawset( table, k, v )</code> |
||
与<code |
与<code>table[k] = v</code>相同,只是忽略了所有__newindex[[#Metatables|元方法]]。 |
||
==== select ==== |
==== select ==== |
||
<code |
<code>select( index, ... )</code> |
||
如果<code>index</code>是数字,返回index之后的<code>...</code>中对应位置的数。如果<code>index</code>是字符串"#",返回<code>...</code>中参数的个数。 |
如果<code>index</code>是数字,返回index之后的<code>...</code>中对应位置的数。如果<code>index</code>是字符串"#",返回<code>...</code>中参数的个数。 |
||
第900行: | 第898行: | ||
==== setmetatable ==== |
==== setmetatable ==== |
||
<code |
<code>setmetatable( table, metatable )</code> |
||
设置[[#table|表]]的[[#Metatables|元表]],<code>metatable</code>可能是nil,但是必须是清楚地提供的。 |
设置[[#table|表]]的[[#Metatables|元表]],<code>metatable</code>可能是nil,但是必须是清楚地提供的。 |
||
第907行: | 第905行: | ||
==== tonumber ==== |
==== tonumber ==== |
||
<code |
<code>tonumber( value, base )</code> |
||
尝试将<code>value</code>转化为数字。如果已经是数字或者可以转化为数字的字符串,<code>tonumber</code>就会返回这个数字,否则会返回nil。 |
尝试将<code>value</code>转化为数字。如果已经是数字或者可以转化为数字的字符串,<code>tonumber</code>就会返回这个数字,否则会返回nil。 |
||
第913行: | 第911行: | ||
<code>base</code>是可选的,默认为10,指定解析数字的进位基数。这个基数可以是2到36之间的任何整数。对于大于10,字母A(大小写均可)代表10,B代表11,以此类推,Z代表35。 |
<code>base</code>是可选的,默认为10,指定解析数字的进位基数。这个基数可以是2到36之间的任何整数。对于大于10,字母A(大小写均可)代表10,B代表11,以此类推,Z代表35。 |
||
十进制下,值可以有小数部分,或者以[[ |
十进制下,值可以有小数部分,或者以[[科学计数法]]表示,而且甚至可以以“0x”开头以表示16进制。其他情况,只会接受不带符号的整数。 |
||
==== tostring ==== |
==== tostring ==== |
||
<code |
<code>tostring( value )</code> |
||
将<code>value</code>转化为字符串。参考上方的[[#Data types|数据类型]]以了解各种类型被转换时的细节。 |
将<code>value</code>转化为字符串。参考上方的[[#Data types|数据类型]]以了解各种类型被转换时的细节。 |
||
对于表,标准的转换行为可以被__tostring[[#mw.language:formatDate|元方法]]覆盖。如果这个元方法存在,那么调用tostring会返回由<code |
对于表,标准的转换行为可以被__tostring[[#mw.language:formatDate|元方法]]覆盖。如果这个元方法存在,那么调用tostring会返回由<code>__tostring( value )</code>返回的单个值。 |
||
==== type ==== |
==== type ==== |
||
<code |
<code>type( value )</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>。 |
以字符串形式返回<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 ==== |
==== unpack ==== |
||
<code |
<code>unpack( table, i, j )</code> |
||
从给定的表返回值,像<code |
从给定的表返回值,像<code>table[i], table[i+1], ···, table[j]</code>这样的如果被写出会直接返回。<code>i</code>和<code>j</code>如果没有给出或者是nil,取其默认值1和<code>[[#Length operator|#]]table</code>。 |
||
注意如果<code>table</code>不是一个[[#sequence|序列]]且<code>j</code>是nil或未指定,则结果是不确定的,参考[[#Length operator|长度操作符]]以了解详细。 |
注意如果<code>table</code>不是一个[[#sequence|序列]]且<code>j</code>是nil或未指定,则结果是不确定的,参考[[#Length operator|长度操作符]]以了解详细。 |
||
==== xpcall ==== |
==== xpcall ==== |
||
<code |
<code>xpcall( f, errhandler )</code> |
||
这个很像<code>[[#pcall|pcall]]</code>,只是错误消息在返回之前传递到函数<code>errhandler</code>中。 |
这个很像<code>[[#pcall|pcall]]</code>,只是错误消息在返回之前传递到函数<code>errhandler</code>中。 |
||
用[[ |
用[[伪代码]]表示,<code>xpcall</code>的定义类似如下: |
||
<syntaxhighlight lang="lua"> |
<syntaxhighlight lang="lua"> |
||
第954行: | 第952行: | ||
==== debug.traceback ==== |
==== debug.traceback ==== |
||
<code |
<code>debug.traceback( message, level )</code> |
||
以字符串的形式返回调用栈。可选的message参数会被连接到调用栈信息的前面。可选的level参数表示返回多少层调用栈。 |
以字符串的形式返回调用栈。可选的message参数会被连接到调用栈信息的前面。可选的level参数表示返回多少层调用栈。 |
||
第961行: | 第959行: | ||
==== math.abs ==== |
==== math.abs ==== |
||
<code |
<code>math.abs( x )</code> |
||
返回<code>x</code>的绝对值。 |
返回<code>x</code>的绝对值。 |
||
==== math.acos ==== |
==== math.acos ==== |
||
<code |
<code>math.acos( x )</code> |
||
返回<code>x</code>的反余弦值(以弧度表示)。 |
返回<code>x</code>的反余弦值(以弧度表示)。 |
||
==== math.asin ==== |
==== math.asin ==== |
||
<code |
<code>math.asin( x )</code> |
||
返回<code>x</code>的反正弦值(以弧度表示)。 |
返回<code>x</code>的反正弦值(以弧度表示)。 |
||
==== math.atan ==== |
==== math.atan ==== |
||
<code |
<code>math.atan( x )</code> |
||
返回<code>x</code>的反正切值(以弧度表示)。 |
返回<code>x</code>的反正切值(以弧度表示)。 |
||
==== math.atan2 ==== |
==== math.atan2 ==== |
||
<code |
<code>math.atan2( y, x )</code> |
||
使用两个参数的符号(signs)以找到结果的象限,返回<code>y/x</code>的反正切值(弧度制)。 |
使用两个参数的符号(signs)以找到结果的象限,返回<code>y/x</code>的反正切值(弧度制)。 |
||
==== math.ceil ==== |
==== math.ceil ==== |
||
<code |
<code>math.ceil( x )</code> |
||
返回不小于<code>x</code>的最小整数。 |
返回不小于<code>x</code>的最小整数。 |
||
==== math.cos ==== |
==== math.cos ==== |
||
<code |
<code>math.cos( x )</code> |
||
返回<code>x</code>(以弧度表示)的余弦值。 |
返回<code>x</code>(以弧度表示)的余弦值。 |
||
==== math.cosh ==== |
==== math.cosh ==== |
||
<code |
<code>math.cosh( x )</code> |
||
返回<code>x</code>的双曲余弦值。 |
返回<code>x</code>的双曲余弦值。 |
||
==== math.deg ==== |
==== math.deg ==== |
||
<code |
<code>math.deg( x )</code> |
||
将弧度角<code>x</code>转化为角度。 |
将弧度角<code>x</code>转化为角度。 |
||
==== math.exp ==== |
==== math.exp ==== |
||
<code |
<code>math.exp( x )</code> |
||
返回<math>e^x</math>。 |
返回<math>e^x</math>。 |
||
==== math.floor ==== |
==== math.floor ==== |
||
<code |
<code>math.floor( x )</code> |
||
返回小于或等于<code>x</code>的最大整数。 |
返回小于或等于<code>x</code>的最大整数。 |
||
==== math.fmod ==== |
==== math.fmod ==== |
||
<code |
<code>math.fmod( x, y )</code> |
||
返回<code>x</code>除以<code>y</code>的余数,并将商舍入到零。比如,<code>math.fmod( 10, 3 )</code>产生<code>1</code>。 |
返回<code>x</code>除以<code>y</code>的余数,并将商舍入到零。比如,<code>math.fmod( 10, 3 )</code>产生<code>1</code>。 |
||
==== math.frexp ==== |
==== math.frexp ==== |
||
<code |
<code>math.frexp( x )</code> |
||
返回像这样的两个值<code>m</code>和<code>e</code>: |
返回像这样的两个值<code>m</code>和<code>e</code>: |
||
第1,032行: | 第1,030行: | ||
==== math.ldexp ==== |
==== math.ldexp ==== |
||
<code |
<code>math.ldexp( m, e )</code> |
||
返回<math>m \times 2^e</math>(<code>e</code>是整数)。 |
返回<math>m \times 2^e</math>(<code>e</code>是整数)。 |
||
==== math.log ==== |
==== math.log ==== |
||
<code |
<code>math.log( x )</code> |
||
返回<code>x</code>的自然对数。 |
返回<code>x</code>的自然对数。 |
||
==== math.log10 ==== |
==== math.log10 ==== |
||
<code |
<code>math.log10( x )</code> |
||
返回<code>x</code>的以10为底的对数。 |
返回<code>x</code>的以10为底的对数。 |
||
==== math.max ==== |
==== math.max ==== |
||
<code |
<code>math.max( x, ... )</code> |
||
返回其参数的最大值。 |
返回其参数的最大值。 |
||
第1,054行: | 第1,052行: | ||
==== math.min ==== |
==== math.min ==== |
||
<code |
<code>math.min( x, ... )</code> |
||
返回其参数的最小值。 |
返回其参数的最小值。 |
||
第1,061行: | 第1,059行: | ||
==== math.modf ==== |
==== math.modf ==== |
||
<code |
<code>math.modf( x )</code> |
||
返回两个数字,<code>x</code>的整数部分和<code>x</code>的小数部分。比如,<code>math.modf( 1.25 )</code>产生<code>1, 0.25</code>。 |
返回两个数字,<code>x</code>的整数部分和<code>x</code>的小数部分。比如,<code>math.modf( 1.25 )</code>产生<code>1, 0.25</code>。 |
||
第1,069行: | 第1,067行: | ||
==== math.pow ==== |
==== math.pow ==== |
||
<code |
<code>math.pow( x, y )</code> |
||
与<code>x^y</code>相同。 |
与<code>x^y</code>相同。 |
||
==== math.rad ==== |
==== math.rad ==== |
||
<code |
<code>math.rad( x )</code> |
||
将角度<code>x</code>转化为弧度角。 |
将角度<code>x</code>转化为弧度角。 |
||
==== math.random ==== |
==== math.random ==== |
||
<code |
<code>math.random( m, n )</code> |
||
返回伪随机数。 |
返回伪随机数。 |
||
第1,085行: | 第1,083行: | ||
参数<code>m</code>、<code>n</code>可省略,但是如果指定了,则必须能够转化为整数。 |
参数<code>m</code>、<code>n</code>可省略,但是如果指定了,则必须能够转化为整数。 |
||
*没有参数时返回区间<math>[0,1)</math>内的实数。 |
* 没有参数时返回区间<math>[0,1)</math>内的实数。 |
||
*有一个参数时返回区间<math>[1,m]</math>内的整数。 |
* 有一个参数时返回区间<math>[1,m]</math>内的整数。 |
||
*有两个参数时返回区间<math>[m,n]</math>内的整数。 |
* 有两个参数时返回区间<math>[m,n]</math>内的整数。 |
||
注意,如果<code>m</code>或者<code>n</code>小于−2147483648或者大于2147483647,或者<code>n - m</code>大于2147483646,那么输出可能会不正确。 |
注意,如果<code>m</code>或者<code>n</code>小于−2147483648或者大于2147483647,或者<code>n - m</code>大于2147483646,那么输出可能会不正确。 |
||
第1,093行: | 第1,091行: | ||
==== math.randomseed ==== |
==== math.randomseed ==== |
||
<code |
<code>math.randomseed( x )</code> |
||
以<code>x</code>作为伪随机数生成器的[[伪随机数的种子|种子]]。 |
以<code>x</code>作为伪随机数生成器的[[伪随机数的种子|种子]]。 |
||
第1,100行: | 第1,098行: | ||
==== math.sin ==== |
==== math.sin ==== |
||
<code |
<code>math.sin( x )</code> |
||
返回 <code>x</code>(以弧度表示)的正弦值。 |
返回 <code>x</code>(以弧度表示)的正弦值。 |
||
==== math.sinh ==== |
==== math.sinh ==== |
||
<code |
<code>math.sinh( x )</code> |
||
返回<code>x</code>的双曲正弦值。 |
返回<code>x</code>的双曲正弦值。 |
||
==== math.sqrt ==== |
==== math.sqrt ==== |
||
<code |
<code>math.sqrt( x )</code> |
||
返回<code>x</code>的平方根。与<code>x^0.5</code>相同。 |
返回<code>x</code>的平方根。与<code>x^0.5</code>相同。 |
||
==== math.tan ==== |
==== math.tan ==== |
||
<code |
<code>math.tan( x )</code> |
||
返回<code>x</code>(以弧度表示)的正切值。 |
返回<code>x</code>(以弧度表示)的正切值。 |
||
==== math.tanh ==== |
==== math.tanh ==== |
||
<code |
<code>math.tanh( x )</code> |
||
返回<code>x</code>的双曲正切值。 |
返回<code>x</code>的双曲正切值。 |
||
第1,132行: | 第1,130行: | ||
==== os.date ==== |
==== os.date ==== |
||
<code |
<code>os.date( format, time )</code> |
||
: ''[[#mw.language:formatDate|语言库的formatDate]]''可以被用于更加全面的日期格式。 |
: ''[[#mw.language:formatDate|语言库的formatDate]]''可以被用于更加全面的日期格式。 |
||
第1,147行: | 第1,145行: | ||
* hour(0~23) |
* hour(0~23) |
||
* min(0~59) |
* min(0~59) |
||
* sec(0~60,允许[[ |
* sec(0~60,允许[[闰秒]]的情况) |
||
* wday(weekday,Sunday是1) |
* wday(weekday,Sunday是1) |
||
* yday(一年的某一天) |
* yday(一年的某一天) |
||
第1,155行: | 第1,153行: | ||
==== os.difftime ==== |
==== os.difftime ==== |
||
<code |
<code>os.difftime( t2, t1 )</code> |
||
返回从<code>t1</code>到<code>t2</code>两个时间的秒数。 |
返回从<code>t1</code>到<code>t2</code>两个时间的秒数。 |
||
==== os.time ==== |
==== os.time ==== |
||
<code |
<code>os.time( table )</code> |
||
返回代表当前时间的数字。 |
返回代表当前时间的数字。 |
||
第1,169行: | 第1,167行: | ||
==== require ==== |
==== require ==== |
||
<code |
<code>require( modulename )</code> |
||
加载指定的模块。 |
加载指定的模块。 |
||
第1,212行: | 第1,210行: | ||
==== package.seeall ==== |
==== package.seeall ==== |
||
<code |
<code>package.seeall( table )</code> |
||
将<code>table</code>的__index[[#Metatables|元方法]]设置为[[#_G|_G]]。 |
将<code>table</code>的__index[[#Metatables|元方法]]设置为[[#_G|_G]]。 |
||
第1,223行: | 第1,221行: | ||
==== string.byte ==== |
==== string.byte ==== |
||
<code |
<code>string.byte( s, i, j )</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()]]。 |
如果字符串被考虑为字节的数组,返回<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.char ==== |
||
<code |
<code>string.char( ... )</code> |
||
接受零个或更多个整数。返回和长度与参数个数相同的字符串,每个字符的字节值等于其对应的参数。 |
接受零个或更多个整数。返回和长度与参数个数相同的字符串,每个字符的字节值等于其对应的参数。 |
||
第1,239行: | 第1,237行: | ||
==== string.find ==== |
==== string.find ==== |
||
<code |
<code>string.find( s, pattern, init, plain )</code> |
||
寻找字符串<code>s</code>中<code>[[#Patterns|pattern]]</code>的第一个匹配(match)。如果找到一个匹配,返回<code>s</code>中起止点的序列,否则返回nil。如果匹配模式有捕获物(capture),则在成功的匹配中被捕获的值也会被返回在两个索引之后。 |
寻找字符串<code>s</code>中<code>[[#Patterns|pattern]]</code>的第一个匹配(match)。如果找到一个匹配,返回<code>s</code>中起止点的序列,否则返回nil。如果匹配模式有捕获物(capture),则在成功的匹配中被捕获的值也会被返回在两个索引之后。 |
||
第1,250行: | 第1,248行: | ||
==== string.format ==== |
==== string.format ==== |
||
<code |
<code>string.format( formatstring, ... )</code> |
||
返回变量数字的参数将第一个参数(必须是字符串)格式化后的版本。 |
返回变量数字的参数将第一个参数(必须是字符串)格式化后的版本。 |
||
第1,270行: | 第1,268行: | ||
==== string.gmatch ==== |
==== string.gmatch ==== |
||
<code |
<code>string.gmatch( s, pattern )</code> |
||
返回一个迭代器函数,每次被调用,都会从字符串<code>s</code>中的[[#Patterns|<code>pattern</code>]]返回下一个捕获。如果<code>pattern</code>不会指定捕获,则整个匹配都会在每次调用时产生。 |
返回一个迭代器函数,每次被调用,都会从字符串<code>s</code>中的[[#Patterns|<code>pattern</code>]]返回下一个捕获。如果<code>pattern</code>不会指定捕获,则整个匹配都会在每次调用时产生。 |
||
第1,279行: | 第1,277行: | ||
==== string.gsub ==== |
==== string.gsub ==== |
||
<code |
<code>string.gsub( s, pattern, repl, n )</code> |
||
将字符串<code>s</code>的所有(或者前<code>n</code>个,如果给定了)出现的[[#Patterns|<code>pattern</code>]]替换为由<code>repl</code>指定的替换物(replacement),这个替换物可以是字符串、表或者函数。<code>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 ==== |
==== string.len ==== |
||
<code |
<code>string.len( s )</code> |
||
返回字符串的字节长度。不会被ASCII NUL字符混淆。等同于[[#Length operator|#]]s。 |
返回字符串的字节长度。不会被ASCII NUL字符混淆。等同于[[#Length operator|#]]s。 |
||
第1,301行: | 第1,299行: | ||
==== string.lower ==== |
==== string.lower ==== |
||
<code |
<code>string.lower( s )</code> |
||
将字符串的所有ASCII大写字符转为小写后返回。所有其他字符不改变。 |
将字符串的所有ASCII大写字符转为小写后返回。所有其他字符不改变。 |
||
第1,308行: | 第1,306行: | ||
==== string.match ==== |
==== string.match ==== |
||
<code |
<code>string.match( s, pattern, init )</code> |
||
寻找字符串中[[#Patterns|<code>pattern</code>]]的第一个匹配,如果找到一个,则<code>match</code>返回从样式匹配中的捕获,否则返回nil。如果<code>pattern</code>不指定捕获,则返回整个字符串。 |
寻找字符串中[[#Patterns|<code>pattern</code>]]的第一个匹配,如果找到一个,则<code>match</code>返回从样式匹配中的捕获,否则返回nil。如果<code>pattern</code>不指定捕获,则返回整个字符串。 |
||
第1,317行: | 第1,315行: | ||
==== string.rep ==== |
==== string.rep ==== |
||
<code |
<code>string.rep( s, n )</code> |
||
返回字符串<code>s</code>重复<code>n</code>次并连接后的字符串。等价于[[#mw.ustring.rep|mw.ustring.rep()]]。 |
返回字符串<code>s</code>重复<code>n</code>次并连接后的字符串。等价于[[#mw.ustring.rep|mw.ustring.rep()]]。 |
||
==== string.reverse ==== |
==== string.reverse ==== |
||
<code |
<code>string.reverse( s )</code> |
||
返回字符串<code>s</code>被逆转后的字符串(按字节逆转)。 |
返回字符串<code>s</code>被逆转后的字符串(按字节逆转)。 |
||
==== string.sub ==== |
==== string.sub ==== |
||
<code |
<code>string.sub( s, i, j )</code> |
||
返回<code>s</code>的从<code>i</code>开始持续到<code>j</code>的子串(substring);<code>i</code>和<code>j</code>可以是负的。如果<code>j</code>是nil或未指定,则会一直到字符串末尾。 |
返回<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 |
特别地,调用<code>string.sub(s,1,j)</code>会返回字符串<code>s</code>的长度<code>j</code>的前缀,而<code>string.sub(s, -i)</code>会返回字符串<code>s</code>的长度为<code>i</code>的后缀。 |
||
参看[[#mw.ustring.sub|mw.ustring.sub()]]以了解使用字符而非字节值的类似函数。 |
参看[[#mw.ustring.sub|mw.ustring.sub()]]以了解使用字符而非字节值的类似函数。 |
||
==== string.upper ==== |
==== string.upper ==== |
||
<code |
<code>string.upper( s )</code> |
||
将字符串的所有ASCII小写字符转为大写后返回。所有其他字符不改变。 |
将字符串的所有ASCII小写字符转为大写后返回。所有其他字符不改变。 |
||
第1,439行: | 第1,437行: | ||
! scope="row" | <code>[{{var|set}}]</code> |
! 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 |
代表集合{{var|set}}中所有字符的组合。一系列字符可以通过用'<code>-</code>'分隔字符末尾来指定。上面讲到的所有的<code>%{{var|x}}</code>都可以是{{var|set}}中的一部分。{{var|set}}中所有其他字符代表其自身。 例如,<code>[%w_]</code>(或<code>[_%w]</code>)代表所有的字母数字字符加上下划线,<code>[0-7]</code>代表八进制数,<code>[0-7%l%-]</code>代表八进制数字加上小写字母加上字符'<code>-</code>'。 |
||
范围和类之间的交互是没被定义的,因此像<code>[%a-z]</code>或<code>[a-%%]</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项。 |
模式可以包括用小括号括起来的子模式(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>([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。 |
特殊情况,空的捕获<code>()</code>会捕获当前的字符串位置(一个数字)。比如我们对字符串<code>"flaaap"</code>执行模式<code>"()aa()"</code>,那么会有两个捕获:3和5。 |
||
第1,481行: | 第1,479行: | ||
==== table.concat ==== |
==== table.concat ==== |
||
<code |
<code>table.concat( table, sep, i, j )</code> |
||
给一个所有元素都是字符串或数字的数组,返回<code |
给一个所有元素都是字符串或数字的数组,返回<code>table[i] .. sep .. table[i+1] ··· sep .. table[j]</code>。 |
||
<code>sep</code>的默认值为空字符串,<code>i</code>的默认值为1,<code>j</code>的默认值为表的长度。如果<code>i</code>大于<code>j</code>,返回空字符串。 |
<code>sep</code>的默认值为空字符串,<code>i</code>的默认值为1,<code>j</code>的默认值为表的长度。如果<code>i</code>大于<code>j</code>,返回空字符串。 |
||
==== table.insert ==== |
==== table.insert ==== |
||
<code |
<code>table.insert( table, value )</code> |
||
<br/> |
<br/> |
||
<code |
<code>table.insert( table, pos, value )</code> |
||
在表<code>table</code>的位置<code>pos</code>处插入元素<code>value</code>,会将其他元素的位置增加1以给这个元素提供插入空间。<code>pos</code>的默认值为表的长度加1,所以调用<code |
在表<code>table</code>的位置<code>pos</code>处插入元素<code>value</code>,会将其他元素的位置增加1以给这个元素提供插入空间。<code>pos</code>的默认值为表的长度加1,所以调用<code>table.insert(t, x)</code>会在表<code>t</code>的末尾插入<code>x</code>。 |
||
大于<code>#table</code>的元素都会被提高,参考[[#Length operator|长度操作符]]以了解当表不是[[#sequence|序列]]时的注意事项。 |
大于<code>#table</code>的元素都会被提高,参考[[#Length operator|长度操作符]]以了解当表不是[[#sequence|序列]]时的注意事项。 |
||
==== table.maxn ==== |
==== table.maxn ==== |
||
<code |
<code>table.maxn( table )</code> |
||
返回给定的表的最大正数索引,或者表没有正数索引时返回零。 |
返回给定的表的最大正数索引,或者表没有正数索引时返回零。 |
||
第1,517行: | 第1,515行: | ||
==== table.remove ==== |
==== table.remove ==== |
||
<code |
<code>table.remove( table, pos )</code> |
||
从表格<code>table</code>中移走位于<code>pos</code>处的元素,将后面的元素前移。<code>pos</code>的默认值为表的长度,所以调用<code |
从表格<code>table</code>中移走位于<code>pos</code>处的元素,将后面的元素前移。<code>pos</code>的默认值为表的长度,所以调用<code>table.remove( t )</code>会移除表<code>t</code>的最后一个元素。 |
||
大于<code>#table</code>的元素都会被移动,参考[[#Length operator|长度操作符]]以了解当表不是[[#sequence|序列]]时的注意事项。 |
大于<code>#table</code>的元素都会被移动,参考[[#Length operator|长度操作符]]以了解当表不是[[#sequence|序列]]时的注意事项。 |
||
==== table.sort ==== |
==== table.sort ==== |
||
<code |
<code>table.sort( table, comp )</code> |
||
从<code>table[1]</code>到<code>table[#table]</code>,按照给定的次序给表的元素排序。如果给了<code>comp</code>,则它必须是接收两个表元素的函数,并且当第一个小于第二个时返回true(所以<code |
从<code>table[1]</code>到<code>table[#table]</code>,按照给定的次序给表的元素排序。如果给了<code>comp</code>,则它必须是接收两个表元素的函数,并且当第一个小于第二个时返回true(所以<code>not comp(a[i+1],a[i])</code>会在排序后为true)。如果没有给定<code>comp</code>,则使用标准的Lua操作符<code>%lt;</code>。 |
||
排序算法并不稳定;也就是说,当两个元素按照给定的顺序被看作相等时,它们在排序后的相对位置可能会改变。 |
排序算法并不稳定;也就是说,当两个元素按照给定的顺序被看作相等时,它们在排序后的相对位置可能会改变。 |
||
第1,537行: | 第1,535行: | ||
==== mw.addWarning ==== |
==== mw.addWarning ==== |
||
<code |
<code>mw.addWarning( text )</code> |
||
在预览编辑时加一个警告信息。<code>text</code>解析为 |
在预览编辑时加一个警告信息。<code>text</code>解析为wikitext。 |
||
==== mw.allToString ==== |
==== mw.allToString ==== |
||
<code |
<code>mw.allToString( ... )</code> |
||
对所有的参数调用[[#tostring|tostring()]],然后用制表符作为分隔符连接起来。 |
对所有的参数调用[[#tostring|tostring()]],然后用制表符作为分隔符连接起来。 |
||
==== mw.clone ==== |
==== mw.clone ==== |
||
<code |
<code>mw.clone( value )</code> |
||
深拷贝一个值。所有的表和它们的元表被重构,但是新表和旧表共用函数。 |
深拷贝一个值。所有的表和它们的元表被重构,但是新表和旧表共用函数。 |
||
第1,567行: | 第1,565行: | ||
==== mw.loadData ==== |
==== mw.loadData ==== |
||
<code |
<code>mw.loadData( module )</code> |
||
有时一个模块需要大量表格的数据,例如,用于转换计量单位的通用模块可能需要一张大表的已识别的单位及其转换系数。而且有时这些模块会在一个页面中使用多次。每次<code><nowiki>{{#invoke:}}</nowiki></code>都解析大表格的数据会用大量时间。<code>mw.loadData()</code>正是为了避免这个问题。 |
有时一个模块需要大量表格的数据,例如,用于转换计量单位的通用模块可能需要一张大表的已识别的单位及其转换系数。而且有时这些模块会在一个页面中使用多次。每次<code><nowiki>{{#invoke:}}</nowiki></code>都解析大表格的数据会用大量时间。<code>mw.loadData()</code>正是为了避免这个问题。 |
||
第1,579行: | 第1,577行: | ||
* 返回的表(和所有子表)不能有[[#Metatables|metatable]]元表。 |
* 返回的表(和所有子表)不能有[[#Metatables|metatable]]元表。 |
||
* 所有的表键必须是布尔值、数字、字符串。 |
* 所有的表键必须是布尔值、数字、字符串。 |
||
* 由<code>mw.loadData()</code>返回的表会元方法,可以提供只读获取由模块返回的表。因为不能直接包含数据,<code>[[#pairs|pairs()]]</code>和<code>[[#ipairs|ipairs()]]</code>会起作用,但是其他方法如<code>[[#Length operator|#值]]</code>、<code |
* 由<code>mw.loadData()</code>返回的表会元方法,可以提供只读获取由模块返回的表。因为不能直接包含数据,<code>[[#pairs|pairs()]]</code>和<code>[[#ipairs|ipairs()]]</code>会起作用,但是其他方法如<code>[[#Length operator|#值]]</code>、<code>[[#next|next()]]</code>和[[#Table library|表库]]的函数不会起作用。 |
||
上述假定的单位转换模块可能将其代码存储在“Module:Convert”然后将其数据存储在“Module:Convert/data”,且“Module:Convert”会使用<code |
上述假定的单位转换模块可能将其代码存储在“Module:Convert”然后将其数据存储在“Module:Convert/data”,且“Module:Convert”会使用<code>local data = mw.loadData( 'Module:Convert/data' )</code>来有效地加载数据。 |
||
==== mw.dumpObject ==== |
==== mw.dumpObject ==== |
||
<code |
<code>mw.dumpObject( object )</code> |
||
将<code>object</code>序列化为人类可读的字符串并返回。 |
将<code>object</code>序列化为人类可读的字符串并返回。 |
||
第1,590行: | 第1,588行: | ||
==== mw.log ==== |
==== mw.log ==== |
||
{{Anchor|print}} |
{{Anchor|print}} |
||
<code |
<code>mw.log( ... )</code> |
||
将参数传递到[[#mw.allToString|mw.allToString()]],然后将结果字符串加载控制台后。 |
将参数传递到[[#mw.allToString|mw.allToString()]],然后将结果字符串加载控制台后。 |
||
第1,597行: | 第1,595行: | ||
==== mw.logObject ==== |
==== mw.logObject ==== |
||
<code |
<code>mw.logObject( object )</code> |
||
<br/> |
<br/> |
||
<code |
<code>mw.logObject( object, prefix )</code> |
||
调用[[#mw.dumpObject|mw.dumpObject()]]然后将结果加到控制台输出的后面。如果给了<code>prefix</code>,则会被加到控制台输出并紧随一个等于号在序列化字符串之前,比如输出的字符串可以是"prefix = object-string"。 |
调用[[#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>获得。 |
注意没有框架库,也没有叫做<code>frame</code>的全局变量。框架对象通常为被<code><nowiki>{{#invoke:}}</nowiki></code>调用的函数的参数,当然也可以从<code>[[#mw.getCurrentFrame|mw.getCurrentFrame()]]</code>获得。 |
||
==== frame.args ==== |
==== frame.args ==== |
||
用来访问传递到frame的参数的表。例如,一个模块从如下的 |
用来访问传递到frame的参数的表。例如,一个模块从如下的wikitext调用 |
||
<nowiki>{{#invoke:module|function|arg1|arg2|name=arg3}}</nowiki> |
<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 |
那么<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>pairs( frame.args )</code>或<code>ipairs( frame.args )</code>。 |
||
然而由于Lua实现表迭代器,迭代的顺序不确定,参数出现在 |
然而由于Lua实现表迭代器,迭代的顺序不确定,参数出现在wikitext中的顺序也无从得知。 |
||
注意这个表中的值总是为字符串,<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>。 |
注意这个表中的值总是为字符串,<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)不会移除空格。 |
在MediaWiki模板调用中,命名参数(named arguments)会在传递到Lua前移除名称和值的多余空格,而匿名参数(unnamed arguments)不会移除空格。 |
||
考虑到性能,<code>frame.args</code>使用元表,而非直接包含参数。参数值会从根据需求从MediaWiki请求得到。这意味着大多数其他表格方法不会正常生效,包括<code>[[#Length operator|#frame.args]]</code>、<code |
考虑到性能,<code>frame.args</code>使用元表,而非直接包含参数。参数值会从根据需求从MediaWiki请求得到。这意味着大多数其他表格方法不会正常生效,包括<code>[[#Length operator|#frame.args]]</code>、<code>[[#next|next]]( frame.args )</code>和[[#Table library|表库]]中的函数。 |
||
如果在#invoke的参数中包含了像模板调用和三层括号变量这样的预处理器(preprocessor)语法,那么这些在传递到Lua之后不会被展开,直到值被Lua请求时才会展开。如果在#invoke的参数中包含了用XML标记形式写的特殊标签,例如<code><pre></code>、<code><nowiki></code>、<code><gallery></code>和<code><ref></code>,这些标签会被转化为[[strip marker]]——一种特殊字符串,由删除符(ASCII 127)开始,在从#invoke返回后转化为HTML。 |
如果在#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 ==== |
==== frame:callParserFunction ==== |
||
<code |
<code>frame:callParserFunction( name, args )</code> |
||
<br/> |
<br/> |
||
<code |
<code>frame:callParserFunction( name, ... )</code> |
||
<br/> |
<br/> |
||
<code |
<code>frame:callParserFunction{ name = string, args = table }</code> |
||
: ''注意使用了[[#named arguments|命名参数]]。'' |
: ''注意使用了[[#named arguments|命名参数]]。'' |
||
第1,634行: | 第1,632行: | ||
调用解析器函数,返回适当的字符串。这相比于<code>frame:preprocess</code>更优,但如果有可能,最好优先使用原生的Lua函数或Scribunto库函数。 |
调用解析器函数,返回适当的字符串。这相比于<code>frame:preprocess</code>更优,但如果有可能,最好优先使用原生的Lua函数或Scribunto库函数。 |
||
以下调用与以下 |
以下调用与以下wikitext基本相同: |
||
<syntaxhighlight lang="lua"> |
<syntaxhighlight lang="lua"> |
||
第1,655行: | 第1,653行: | ||
==== frame:expandTemplate ==== |
==== frame:expandTemplate ==== |
||
<code |
<code>frame:expandTemplate{ title = title, args = table }</code> |
||
: ''注意使用了[[#named arguments|命名参数]]。'' |
: ''注意使用了[[#named arguments|命名参数]]。'' |
||
第1,663行: | 第1,661行: | ||
frame:expandTemplate{ title = 'template', args = { 'arg1', 'arg2', name = 'arg3' } } |
frame:expandTemplate{ title = 'template', args = { 'arg1', 'arg2', name = 'arg3' } } |
||
在Lua脚本中的行为大致和<code><nowiki>{{template|arg1|arg2|name=arg3}}</nowiki></code>在 |
在Lua脚本中的行为大致和<code><nowiki>{{template|arg1|arg2|name=arg3}}</nowiki></code>在wikitext中的行为一样。如果页面名没有命名空间前缀,那么函数会认为页面在模板命名空间内。 |
||
注意标题与参数在传递到模版之前并未预处理: |
注意标题与参数在传递到模版之前并未预处理: |
||
<syntaxhighlight lang="lua"> |
<syntaxhighlight lang="lua"> |
||
-- 这与 |
-- 这与wikitext{{template|{{!}}}}基本相同 |
||
frame:expandTemplate{ title = 'template', args = { '|' } } |
frame:expandTemplate{ title = 'template', args = { '|' } } |
||
-- 这与 |
-- 这与wikitext{{template|{{((}}!{{))}}}}基本相同 |
||
frame:expandTemplate{ title = 'template', args = { '{{!}}' } } |
frame:expandTemplate{ title = 'template', args = { '{{!}}' } } |
||
</syntaxhighlight> |
</syntaxhighlight> |
||
==== frame:extensionTag ==== |
==== frame:extensionTag ==== |
||
<code |
<code>frame:extensionTag( name, content, args )</code> |
||
<br/> |
<br/> |
||
<code |
<code>frame:extensionTag{ name = string, content = string, args = table_or_string }</code> |
||
这大致相当于调用[[#frame:callParserFunction|frame:callParserFunction()]],其函数名称为<code |
这大致相当于调用[[#frame:callParserFunction|frame:callParserFunction()]],其函数名称为<code>'#tag:' .. name</code>而<code>content</code>加到参数<code>args</code>中。 |
||
<syntaxhighlight lang="lua"> |
<syntaxhighlight lang="lua"> |
||
第1,711行: | 第1,709行: | ||
==== frame:newChild ==== |
==== frame:newChild ==== |
||
<code |
<code>frame:newChild{ title = title, args = table }</code> |
||
: ''注意使用了[[#named arguments|命名参数]]。'' |
: ''注意使用了[[#named arguments|命名参数]]。'' |
||
第1,720行: | 第1,718行: | ||
==== frame:preprocess ==== |
==== frame:preprocess ==== |
||
<code |
<code>frame:preprocess( string )</code> |
||
<br/> |
<br/> |
||
<code |
<code>frame:preprocess{ text = string }</code> |
||
在当前框架环境下展开 |
在当前框架环境下展开wikitext,比如,模板、解析器函数以及像<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。 |
||
如果你使用单个模板,使用[[#frame:expandTemplate|<code>frame:expandTemplate</code>]]而非尝试建造 |
如果你使用单个模板,使用[[#frame:expandTemplate|<code>frame:expandTemplate</code>]]而非尝试建造wikitext以使用这个方法。这样更快且更不容易出错,尤其是参数包含管道符或其他wikitext标记时。 |
||
同理,展开单个解析器函数时应使用[[#frame:callParserFunction|<code>frame:callParserFunction</code>]]。 |
同理,展开单个解析器函数时应使用[[#frame:callParserFunction|<code>frame:callParserFunction</code>]]。 |
||
==== frame:getArgument ==== |
==== frame:getArgument ==== |
||
<code |
<code>frame:getArgument( arg )</code> |
||
<br/> |
<br/> |
||
<code |
<code>frame:getArgument{ name = arg }</code> |
||
获得特定参数的对象,或者没有提供参数时返回nil。 |
获得特定参数的对象,或者没有提供参数时返回nil。 |
||
返回的对象有一个方法,<code>object:expand()</code>,可以返回对应参数的展开后的 |
返回的对象有一个方法,<code>object:expand()</code>,可以返回对应参数的展开后的wikitext。 |
||
==== frame:newParserValue ==== |
==== frame:newParserValue ==== |
||
<code |
<code>frame:newParserValue( text )</code> |
||
<br/> |
<br/> |
||
<code |
<code>frame:newParserValue{ text = text }</code> |
||
返回有一个方法<code>object:expand()</code>的对象,该方法可以返回<code |
返回有一个方法<code>object:expand()</code>的对象,该方法可以返回<code>[[#frame:preprocess|frame:preprocess]]( text )</code>的结果。 |
||
==== frame:newTemplateParserValue ==== |
==== frame:newTemplateParserValue ==== |
||
<code |
<code>frame:newTemplateParserValue{ title = title, args = table }</code> |
||
: ''注意使用了[[#named arguments|命名参数]]。'' |
: ''注意使用了[[#named arguments|命名参数]]。'' |
||
第1,756行: | 第1,754行: | ||
<code>frame:argumentPairs()</code> |
<code>frame:argumentPairs()</code> |
||
等同于<code |
等同于<code>pairs( frame.args )</code>。考虑到向后兼容。 |
||
=== 哈希库 === |
=== 哈希库 === |
||
==== mw.hash.hashValue ==== |
==== mw.hash.hashValue ==== |
||
<code |
<code>mw.hash.hashValue( algo, value )</code> |
||
按照指定的算法算出字符串的哈希值。可以通过[[#mw.hash.listAlgorithms|mw.hash.listAlgorithms()]]获得有效的算法。 |
按照指定的算法算出字符串的哈希值。可以通过[[#mw.hash.listAlgorithms|mw.hash.listAlgorithms()]]获得有效的算法。 |
||
==== mw.hash.listAlgorithms ==== |
==== mw.hash.listAlgorithms ==== |
||
<code |
<code>mw.hash.listAlgorithms()</code> |
||
返回支持的哈希算法的列表,以用于[[#mw.hash.hashValue|mw.hash.hashValue()]]。 |
返回支持的哈希算法的列表,以用于[[#mw.hash.hashValue|mw.hash.hashValue()]]。 |
||
第1,791行: | 第1,789行: | ||
==== mw.html.create ==== |
==== mw.html.create ==== |
||
<code |
<code>mw.html.create( tagName, args )</code> |
||
创建一个新的mw.html对象,其包含一个标签名称为<code>tagName</code>的HTML元素。你也可以传递一个空的字符串或nil作为<code>tagName</code>,以创建一个新的空的mw.html对象。 |
创建一个新的mw.html对象,其包含一个标签名称为<code>tagName</code>的HTML元素。你也可以传递一个空的字符串或nil作为<code>tagName</code>,以创建一个新的空的mw.html对象。 |
||
第1,801行: | 第1,799行: | ||
==== mw.html:node ==== |
==== mw.html:node ==== |
||
<code |
<code>[[#mw.html-object|html]]:node( builder )</code> |
||
向当前的mw.html实例附加mw.html(<code>builder</code>)子节点。如果传递nil,那么函数不做任何事。(<code>builder</code>)节点是要创建的HTML元素的种类的字符串代表。 |
向当前的mw.html实例附加mw.html(<code>builder</code>)子节点。如果传递nil,那么函数不做任何事。(<code>builder</code>)节点是要创建的HTML元素的种类的字符串代表。 |
||
==== mw.html:wikitext ==== |
==== mw.html:wikitext ==== |
||
<code |
<code>[[#mw.html-object|html]]:wikitext( ... )</code> |
||
给mw.html对象加上不定数量的 |
给mw.html对象加上不定数量的wikitext字符串。 |
||
注意遇到第一个''nil''项就会停。 |
注意遇到第一个''nil''项就会停。 |
||
==== mw.html:newline ==== |
==== mw.html:newline ==== |
||
<code |
<code>[[#mw.html-object|html]]:newline()</code> |
||
给mw.html对象加新行。 |
给mw.html对象加新行。 |
||
==== mw.html:tag ==== |
==== mw.html:tag ==== |
||
<code |
<code>[[#mw.html-object|html]]:tag( tagName, args )</code> |
||
给mw.html对象添加一个新的节点,其标签名称为<code>tagName</code>,返回代表这个新的节点的mw.html实例。<code>args</code>参数和[[#mw.html.create|<code>mw.html.create</code>]]的参数是一样的。 |
给mw.html对象添加一个新的节点,其标签名称为<code>tagName</code>,返回代表这个新的节点的mw.html实例。<code>args</code>参数和[[#mw.html.create|<code>mw.html.create</code>]]的参数是一样的。 |
||
==== mw.html:attr ==== |
==== mw.html:attr ==== |
||
<code |
<code>[[#mw.html-object|html]]:attr( name, value )</code> |
||
<br/> |
<br/> |
||
<code |
<code>[[#mw.html-object|html]]:attr( table )</code> |
||
将节点的HTML属性的<code>name</code>属性的值设为<code>value</code>。也可以选择使用表,其键值对即为属性名称-值对。第一种形式中,如果值为nil,会导致这个给定名称的已被设置属性设为未被设置。 |
将节点的HTML属性的<code>name</code>属性的值设为<code>value</code>。也可以选择使用表,其键值对即为属性名称-值对。第一种形式中,如果值为nil,会导致这个给定名称的已被设置属性设为未被设置。 |
||
==== mw.html:getAttr ==== |
==== mw.html:getAttr ==== |
||
<code |
<code>[[#mw.html-object|html]]:getAttr( name )</code> |
||
获得已经通过[[#mw.html:attr|<code>html:attr()</code>]]设置的属性<code>name</code>的值。 |
获得已经通过[[#mw.html:attr|<code>html:attr()</code>]]设置的属性<code>name</code>的值。 |
||
==== mw.html:addClass ==== |
==== mw.html:addClass ==== |
||
<code |
<code>[[#mw.html-object|html]]:addClass( class )</code> |
||
给节点的类(class)属性添加一个类名称(class name)。如果参数为nil,则无效。 |
给节点的类(class)属性添加一个类名称(class name)。如果参数为nil,则无效。 |
||
==== mw.html:css ==== |
==== mw.html:css ==== |
||
<code |
<code>[[#mw.html-object|html]]:css( name, value )</code> |
||
<br/> |
<br/> |
||
<code |
<code>[[#mw.html-object|html]]:css( table )</code> |
||
使用给定的<code>name</code>和<code>value</code>给节点设置CSS属性。也可以选择使用表,其键值对即为CSS名称-值对。第一种形式中,如果值为nil,会导致这个给定名称的已被设置的CSS设为未被设置。 |
使用给定的<code>name</code>和<code>value</code>给节点设置CSS属性。也可以选择使用表,其键值对即为CSS名称-值对。第一种形式中,如果值为nil,会导致这个给定名称的已被设置的CSS设为未被设置。 |
||
==== mw.html:cssText ==== |
==== mw.html:cssText ==== |
||
<code |
<code>[[#mw.html-object|html]]:cssText( css )</code> |
||
给节点的属性添加一些纯<code>css</code>文本。如果参数为nil,则无效。 |
给节点的属性添加一些纯<code>css</code>文本。如果参数为nil,则无效。 |
||
==== mw.html:done ==== |
==== mw.html:done ==== |
||
<code |
<code>[[#mw.html-object|html]]:done()</code> |
||
返回当前节点被创建时所在的上级节点。类似于jQuery.end,这是个方便地函数可以允许创建多个子节点,而由一个语句串在一起。 |
返回当前节点被创建时所在的上级节点。类似于jQuery.end,这是个方便地函数可以允许创建多个子节点,而由一个语句串在一起。 |
||
==== mw.html:allDone ==== |
==== mw.html:allDone ==== |
||
<code |
<code>[[#mw.html-object|html]]:allDone()</code> |
||
类似于[[#mw.html:done|<code>html:done()</code>]],但是会遍历直到树节点的根部再返回。 |
类似于[[#mw.html:done|<code>html:done()</code>]],但是会遍历直到树节点的根部再返回。 |
||
第1,863行: | 第1,861行: | ||
=== 语言库 === |
=== 语言库 === |
||
语言代码在语言代码中由描述。很多MediaWiki的语言代码类似于[[ |
语言代码在语言代码中由描述。很多MediaWiki的语言代码类似于[[IETF语言标签]],但不是所有MediaWiki语言代码都是有效的IETF标签,反之亦然。 |
||
{{anchor|mw.language-object}} |
{{anchor|mw.language-object}} |
||
第1,869行: | 第1,867行: | ||
==== mw.language.fetchLanguageName ==== |
==== mw.language.fetchLanguageName ==== |
||
<code |
<code>mw.language.fetchLanguageName( code, inLanguage )</code> |
||
给定的语言代码的完整语言名称:默认为本地名称,如有<code>inLanguage</code>的值,则是被翻译为目标语言的语言名称。 |
给定的语言代码的完整语言名称:默认为本地名称,如有<code>inLanguage</code>的值,则是被翻译为目标语言的语言名称。 |
||
==== mw.language.fetchLanguageNames ==== |
==== mw.language.fetchLanguageNames ==== |
||
<code |
<code>mw.language.fetchLanguageNames()</code> |
||
<br/> |
<br/> |
||
<code |
<code>mw.language.fetchLanguageNames( inLanguage )</code> |
||
<br/> |
<br/> |
||
<code |
<code>mw.language.fetchLanguageNames( inLanguage, include )</code> |
||
获取MediaWiki已知的语言列表,返回将语言代码映射到语言名称的表。 |
获取MediaWiki已知的语言列表,返回将语言代码映射到语言名称的表。 |
||
第1,894行: | 第1,892行: | ||
==== mw.language.getFallbacksFor ==== |
==== mw.language.getFallbacksFor ==== |
||
[[File:MediaWiki fallback chains.svg| |
[[File:MediaWiki fallback chains.svg|缩略图|备选链]] |
||
<code |
<code>mw.language.getFallbacksFor( code )</code> |
||
返回MediaWiki针对指定语言代码的备选语言代码列表。 |
返回MediaWiki针对指定语言代码的备选语言代码列表。 |
||
==== mw.language.isKnownLanguageTag ==== |
==== mw.language.isKnownLanguageTag ==== |
||
<code |
<code>mw.language.isKnownLanguageTag( code )</code> |
||
若语言代码为MediaWiki已知的语言,返回true。 |
若语言代码为MediaWiki已知的语言,返回true。 |
||
第1,907行: | 第1,905行: | ||
==== mw.language.isSupportedLanguage ==== |
==== mw.language.isSupportedLanguage ==== |
||
<code |
<code>mw.language.isSupportedLanguage( code )</code> |
||
检查MediaWiki的语言代码内是否有任何本地化可用。 |
检查MediaWiki的语言代码内是否有任何本地化可用。 |
||
第1,916行: | 第1,914行: | ||
==== mw.language.isValidBuiltInCode ==== |
==== mw.language.isValidBuiltInCode ==== |
||
<code |
<code>mw.language.isValidBuiltInCode( code )</code> |
||
如果语言代码是用于MediaWiki内部自定义的有效形式,返回true。 |
如果语言代码是用于MediaWiki内部自定义的有效形式,返回true。 |
||
第1,927行: | 第1,925行: | ||
==== mw.language.isValidCode ==== |
==== mw.language.isValidCode ==== |
||
<code |
<code>mw.language.isValidCode( code )</code> |
||
若语言代码字符串是有效形式的,返回true,无论其是否存在。这包括了所有单独用于通过MediaWiki命名空间自定义使用的语言代码。 |
若语言代码字符串是有效形式的,返回true,无论其是否存在。这包括了所有单独用于通过MediaWiki命名空间自定义使用的语言代码。 |
||
第1,936行: | 第1,934行: | ||
==== mw.language.new ==== |
==== mw.language.new ==== |
||
<code |
<code>mw.language.new( code )</code> |
||
<br/> |
<br/> |
||
<code |
<code>mw.getLanguage( code )</code> |
||
创建新的语言对象。语言对象没有任何可公开获取的属性,不过可以含有几个方法,下面列出。 |
创建新的语言对象。语言对象没有任何可公开获取的属性,不过可以含有几个方法,下面列出。 |
||
第1,945行: | 第1,943行: | ||
==== mw.language:getCode ==== |
==== mw.language:getCode ==== |
||
<code |
<code>[[#mw.language-object|lang]]:getCode()</code> |
||
返回这个语言对象的语言代码。 |
返回这个语言对象的语言代码。 |
||
==== mw.language:getFallbackLanguages ==== |
==== mw.language:getFallbackLanguages ==== |
||
<code |
<code>[[#mw.language-object|lang]]:getFallbackLanguages()</code> |
||
返回MediaWiki针对此语言对象的备选语言代码列表。等同<code |
返回MediaWiki针对此语言对象的备选语言代码列表。等同<code>mw.language.getFallbacksFor( lang:getCode() )</code>。 |
||
==== mw.language:isRTL ==== |
==== mw.language:isRTL ==== |
||
<code |
<code>[[#mw.language-object|lang]]:isRTL()</code> |
||
若语言是从右至左写的,返回true,否则返回false。 |
若语言是从右至左写的,返回true,否则返回false。 |
||
==== mw.language:lc ==== |
==== mw.language:lc ==== |
||
<code |
<code>[[#mw.language-object|lang]]:lc( s )</code> |
||
将字符串转化为小写,但遵从给定的语言的任何特殊规则。 |
将字符串转化为小写,但遵从给定的语言的任何特殊规则。 |
||
当加载了[[#Ustring library|ustring库]],[[#mw.ustring.lower|mw.ustring.lower()]]函数就会通过调用<code |
当加载了[[#Ustring library|ustring库]],[[#mw.ustring.lower|mw.ustring.lower()]]函数就会通过调用<code>mw.language.getContentLanguage():lc( s )</code>来实现。 |
||
==== mw.language:lcfirst ==== |
==== mw.language:lcfirst ==== |
||
<code |
<code>[[#mw.language-object|lang]]:lcfirst( s )</code> |
||
将字符串的第一个字符转化为小写,就像[[#mw.language:lc|lang:lc()]]那样。 |
将字符串的第一个字符转化为小写,就像[[#mw.language:lc|lang:lc()]]那样。 |
||
==== mw.language:uc ==== |
==== mw.language:uc ==== |
||
<code |
<code>[[#mw.language-object|lang]]:uc( s )</code> |
||
将字符串转化为大写,但遵从给定的语言的任何特殊规则。 |
将字符串转化为大写,但遵从给定的语言的任何特殊规则。 |
||
当加载了[[#Ustring library|ustring库]],[[#mw.ustring.upper|mw.ustring.upper()]]函数就会通过调用<code |
当加载了[[#Ustring library|ustring库]],[[#mw.ustring.upper|mw.ustring.upper()]]函数就会通过调用<code>mw.language.getContentLanguage():lc( s )</code>来实现。 |
||
==== mw.language:ucfirst ==== |
==== mw.language:ucfirst ==== |
||
<code |
<code>[[#mw.language-object|lang]]:ucfirst( s )</code> |
||
将字符串的第一个字符转化为大写,就像[[#mw.language:uc|lang:lc()]]那样。 |
将字符串的第一个字符转化为大写,就像[[#mw.language:uc|lang:lc()]]那样。 |
||
==== mw.language:caseFold ==== |
==== mw.language:caseFold ==== |
||
<code |
<code>[[#mw.language-object|lang]]:caseFold( s )</code> |
||
将字符串转换为不区分大小写的比较表示形式。注意,显示其结果可能无任何意义。 |
将字符串转换为不区分大小写的比较表示形式。注意,显示其结果可能无任何意义。 |
||
==== mw.language:formatNum ==== |
==== mw.language:formatNum ==== |
||
<code |
<code>[[#mw.language-object|lang]]:formatNum( n )</code> |
||
<br/> |
<br/> |
||
<code |
<code>[[#mw.language-object|lang]]:formatNum( n, options )</code> |
||
格式化数字,使用给定语言的合适的分组符合小数点。给予123456.78,可能会产生123,456.78、123.456,78或甚至١٢٣٬٤٥٦٫٧٨,取决于语言和wiki配置。 |
格式化数字,使用给定语言的合适的分组符合小数点。给予123456.78,可能会产生123,456.78、123.456,78或甚至١٢٣٬٤٥٦٫٧٨,取决于语言和wiki配置。 |
||
第2,000行: | 第1,998行: | ||
==== mw.language:formatDate ==== |
==== mw.language:formatDate ==== |
||
<code |
<code>[[#mw.language-object|lang]]:formatDate( format, timestamp, local )</code> |
||
根据给定的格式字符串格式化一个日期。如果省略了<code>timestamp</code>,默认为当前时间。<code>local</code>的值必须是boolean或nil,如果是true,时间会格式化为wiki的当地时间而非UTC。 |
根据给定的格式字符串格式化一个日期。如果省略了<code>timestamp</code>,默认为当前时间。<code>local</code>的值必须是boolean或nil,如果是true,时间会格式化为wiki的当地时间而非UTC。 |
||
<code>timestamp</code>的格式字符串和支持的值与[[Extension:ParserFunctions]]的#time解析器函数完全相同。 |
<code>timestamp</code>的格式字符串和支持的值与[[Extension:ParserFunctions]]的#time解析器函数完全相同。 |
||
注意虽然反斜杠可能需要在Lua字符串字面量中写两次,由于Lua也使用反斜杠转义,而 |
注意虽然反斜杠可能需要在Lua字符串字面量中写两次,由于Lua也使用反斜杠转义,而wikitext不需要: |
||
<syntaxhighlight lang="lua"> |
<syntaxhighlight lang="lua"> |
||
第2,019行: | 第2,017行: | ||
==== mw.language:formatDuration ==== |
==== mw.language:formatDuration ==== |
||
<code |
<code>[[#mw.language-object|lang]]:formatDuration( seconds )</code> |
||
<br/> |
<br/> |
||
<code |
<code>[[#mw.language-object|lang]]:formatDuration( seconds, chosenIntervals )</code> |
||
将秒数的时间间隔转化为更加已读的单位,例如12345转化为3 hours, 25 minutes and 45 seconds(3时25分45秒),作为字符串返回结果。 |
将秒数的时间间隔转化为更加已读的单位,例如12345转化为3 hours, 25 minutes and 45 seconds(3时25分45秒),作为字符串返回结果。 |
||
第2,028行: | 第2,026行: | ||
==== mw.language:parseFormattedNumber ==== |
==== mw.language:parseFormattedNumber ==== |
||
<code |
<code>[[#mw.language-object|lang]]:parseFormattedNumber( s )</code> |
||
这需要一个以[[#mw.language:formatNum|lang:formatNum()]]格式化的数字,并返回实际数字。换句话说,这基本上是[[#tonumber|<code>tonumber()</code>]]根据语言转换的版本。 |
这需要一个以[[#mw.language:formatNum|lang:formatNum()]]格式化的数字,并返回实际数字。换句话说,这基本上是[[#tonumber|<code>tonumber()</code>]]根据语言转换的版本。 |
||
第2,034行: | 第2,032行: | ||
==== mw.language:convertPlural ==== |
==== mw.language:convertPlural ==== |
||
{{Anchor|mw.language:plural}} |
{{Anchor|mw.language:plural}} |
||
<code |
<code>[[#mw.language-object|lang]]:convertPlural( n, ... )</code> |
||
<br/> |
<br/> |
||
<code |
<code>[[#mw.language-object|lang]]:convertPlural( n, forms )</code> |
||
<br/> |
<br/> |
||
<code |
<code>[[#mw.language-object|lang]]:plural( n, ... )</code> |
||
<br/> |
<br/> |
||
<code |
<code>[[#mw.language-object|lang]]:plural( n, forms )</code> |
||
从<code>forms</code>(必须是[[#sequence|序列]]表)或<code>...</code>基于数字<code>n</code>选择合适的语法形式。例如,在英语你必须使用<code |
从<code>forms</code>(必须是[[#sequence|序列]]表)或<code>...</code>基于数字<code>n</code>选择合适的语法形式。例如,在英语你必须使用<code>n .. ' ' .. lang:plural( n, 'sock', 'socks' )</code>或<code>n .. ' ' .. lang:plural( n, { 'sock', 'socks' } )</code>来生成语法正确的文本:只有1 sock或200 socks。 |
||
序列的必填值取决于语言,详见[[mw:Help:Magic words#Localization|魔术字的本地化]]和[[translatewiki:Special:MyLanguage/FAQ#PLURAL|translatewiki针对PLURAL的常见问题]]。 |
序列的必填值取决于语言,详见[[mw:Help:Magic words#Localization|魔术字的本地化]]和[[translatewiki:Special:MyLanguage/FAQ#PLURAL|translatewiki针对PLURAL的常见问题]]。 |
||
第2,048行: | 第2,046行: | ||
==== mw.language:convertGrammar ==== |
==== mw.language:convertGrammar ==== |
||
{{Anchor|mw.language:grammar}} |
{{Anchor|mw.language:grammar}} |
||
<code |
<code>[[#mw.language-object|lang]]:convertGrammar( word, case )</code> |
||
<br/> |
<br/> |
||
<code |
<code>[[#mw.language-object|lang]]:grammar( case, word )</code> |
||
: ''注意两个别称之间的不同参数顺序。<code>convertGrammar</code>匹配MediaWiki的Language对象的相同名称的方法的顺序,而<code>grammar</code>匹配相同名称的解析器函数的顺序,可参考帮助:魔术字#本地化。'' |
: ''注意两个别称之间的不同参数顺序。<code>convertGrammar</code>匹配MediaWiki的Language对象的相同名称的方法的顺序,而<code>grammar</code>匹配相同名称的解析器函数的顺序,可参考帮助:魔术字#本地化。'' |
||
第2,059行: | 第2,057行: | ||
==== mw.language:gender ==== |
==== mw.language:gender ==== |
||
<code |
<code>[[#mw.language-object|lang]]:gender( what, masculine, feminine, neutral )</code> |
||
<br/> |
<br/> |
||
<code |
<code>[[#mw.language-object|lang]]:gender( what, { masculine, feminine, neutral } )</code> |
||
选择对应<code>what</code>的性别的字符串,可以是male、female或注册的用户名。 |
选择对应<code>what</code>的性别的字符串,可以是male、female或注册的用户名。 |
||
==== mw.language:getArrow ==== |
==== mw.language:getArrow ==== |
||
<code |
<code>[[#mw.language-object|lang]]:getArrow( direction )</code> |
||
返回对应方向<code>direction</code>的Unicode箭头字符: |
返回对应方向<code>direction</code>的Unicode箭头字符: |
||
第2,078行: | 第2,076行: | ||
==== mw.language:getDir ==== |
==== mw.language:getDir ==== |
||
<code |
<code>[[#mw.language-object|lang]]:getDir()</code> |
||
根据语言的书写方向,返回"ltr"(从左至右)或"rtl"(从右至左)。 |
根据语言的书写方向,返回"ltr"(从左至右)或"rtl"(从右至左)。 |
||
==== mw.language:getDirMark ==== |
==== mw.language:getDirMark ==== |
||
<code |
<code>[[#mw.language-object|lang]]:getDirMark( opposite )</code> |
||
返回包含U+200E(从左至右标记)或U+20F(从右至左标记)的字符串,取决于语言的书写方向以及<code>opposite</code>的值。 |
返回包含U+200E(从左至右标记)或U+20F(从右至左标记)的字符串,取决于语言的书写方向以及<code>opposite</code>的值。 |
||
==== mw.language:getDirMarkEntity ==== |
==== mw.language:getDirMarkEntity ==== |
||
<code |
<code>[[#mw.language-object|lang]]:getDirMarkEntity( opposite )</code> |
||
返回“&lrm;”或“&rlm;”,取决于语言的书写方向和<code>opposite</code>的值。 |
返回“&lrm;”或“&rlm;”,取决于语言的书写方向和<code>opposite</code>的值。 |
||
==== mw.language:getDurationIntervals ==== |
==== mw.language:getDurationIntervals ==== |
||
<code |
<code>[[#mw.language-object|lang]]:getDurationIntervals( seconds )</code> |
||
<br/> |
<br/> |
||
<code |
<code>[[#mw.language-object|lang]]:getDurationIntervals( seconds, chosenIntervals )</code> |
||
将秒数的时间间隔转化为更加已读的单位,例如12345转化为3 hours, 25 minutes and 45 seconds(3时25分45秒),返回从单位名称映射到数字的表。 |
将秒数的时间间隔转化为更加已读的单位,例如12345转化为3 hours, 25 minutes and 45 seconds(3时25分45秒),返回从单位名称映射到数字的表。 |
||
第2,111行: | 第2,109行: | ||
==== mw.message.new ==== |
==== mw.message.new ==== |
||
<code |
<code>mw.message.new( key, ... )</code> |
||
创建一个给定消息<code>key</code>的新消息对象。 |
创建一个给定消息<code>key</code>的新消息对象。 |
||
第2,119行: | 第2,117行: | ||
==== mw.message.newFallbackSequence ==== |
==== mw.message.newFallbackSequence ==== |
||
<code |
<code>mw.message.newFallbackSequence( ... )</code> |
||
创建给定的消息的新的消息对象(存在的第一个会被使用)。 |
创建给定的消息的新的消息对象(存在的第一个会被使用)。 |
||
第2,126行: | 第2,124行: | ||
==== mw.message.newRawMessage ==== |
==== mw.message.newRawMessage ==== |
||
<code |
<code>mw.message.newRawMessage( msg, ... )</code> |
||
创建新的消息对象,使用给定的文本,而不是查找国际化的(internationalized)消息。剩下的参数会传递到新对象的<code>[[#mw.message:params|params()]]</code>方法中。 |
创建新的消息对象,使用给定的文本,而不是查找国际化的(internationalized)消息。剩下的参数会传递到新对象的<code>[[#mw.message:params|params()]]</code>方法中。 |
||
第2,133行: | 第2,131行: | ||
==== mw.message.rawParam ==== |
==== mw.message.rawParam ==== |
||
<code |
<code>mw.message.rawParam( value )</code> |
||
包装(wrap)该值使之不会被<code>[[#mw.message:parse|msg:parse()]]</code>解析为 |
包装(wrap)该值使之不会被<code>[[#mw.message:parse|msg:parse()]]</code>解析为wikitext。 |
||
==== mw.message.numParam ==== |
==== mw.message.numParam ==== |
||
<code |
<code>mw.message.numParam( value )</code> |
||
包装(wrap)该值使之自动被格式化为<code>[[#mw.language:formatNum|lang:formatNum()]]</code>。注意这不依赖事实上有效的[[#Language library|语言库]]。 |
包装(wrap)该值使之自动被格式化为<code>[[#mw.language:formatNum|lang:formatNum()]]</code>。注意这不依赖事实上有效的[[#Language library|语言库]]。 |
||
==== mw.message.getDefaultLanguage ==== |
==== mw.message.getDefaultLanguage ==== |
||
<code |
<code>mw.message.getDefaultLanguage()</code> |
||
返回默认语言的语言对象。 |
返回默认语言的语言对象。 |
||
==== mw.message:params ==== |
==== mw.message:params ==== |
||
<code |
<code>[[#mw.message-object|msg]]:params( ... )</code> |
||
<br/> |
<br/> |
||
<code |
<code>[[#mw.message-object|msg]]:params( params )</code> |
||
给消息添加参数,参数可以一被传递为独立的参数或者作为一个[[#sequence|序列]]表。参数必须是数字、字符串或由[[#mw.message.numParam|mw.message.numParam()]]或[[#mw.message.rawParam|mw.message.rawParam()]]返回的特殊的值。如果使用序列表,参数必须是直接出现在表中,使用[[#Metatables|__index元方法]]的参考不起作用。 |
给消息添加参数,参数可以一被传递为独立的参数或者作为一个[[#sequence|序列]]表。参数必须是数字、字符串或由[[#mw.message.numParam|mw.message.numParam()]]或[[#mw.message.rawParam|mw.message.rawParam()]]返回的特殊的值。如果使用序列表,参数必须是直接出现在表中,使用[[#Metatables|__index元方法]]的参考不起作用。 |
||
第2,157行: | 第2,155行: | ||
==== mw.message:rawParams ==== |
==== mw.message:rawParams ==== |
||
<code |
<code>[[#mw.message-object|msg]]:rawParams( ... )</code> |
||
<br/> |
<br/> |
||
<code |
<code>[[#mw.message-object|msg]]:rawParams( params )</code> |
||
像[[#mw.message:params|:params()]],但是会先通过[[#mw.message.rawParam|mw.message.rawParam()]]传递所有的参数。 |
像[[#mw.message:params|:params()]],但是会先通过[[#mw.message.rawParam|mw.message.rawParam()]]传递所有的参数。 |
||
第2,166行: | 第2,164行: | ||
==== mw.message:numParams ==== |
==== mw.message:numParams ==== |
||
<code |
<code>[[#mw.message-object|msg]]:numParams( ... )</code> |
||
<br/> |
<br/> |
||
<code |
<code>[[#mw.message-object|msg]]:numParams( params )</code> |
||
像[[#mw.message:params|:params()]],但是会先通过[[#mw.message.numParam|mw.message.numParam()]]传递所有的参数。 |
像[[#mw.message:params|:params()]],但是会先通过[[#mw.message.numParam|mw.message.numParam()]]传递所有的参数。 |
||
第2,175行: | 第2,173行: | ||
==== mw.message:inLanguage ==== |
==== mw.message:inLanguage ==== |
||
<code |
<code>[[#mw.message-object|msg]]:inLanguage( lang )</code> |
||
指定一个语言,以在加工消息时使用。<code>lang</code>可以是字符串,或者带有<code>getCode()</code>元表的表(比如[[#Language library|语言对象]])。 |
指定一个语言,以在加工消息时使用。<code>lang</code>可以是字符串,或者带有<code>getCode()</code>元表的表(比如[[#Language library|语言对象]])。 |
||
第2,184行: | 第2,182行: | ||
==== mw.message:useDatabase ==== |
==== mw.message:useDatabase ==== |
||
<code |
<code>[[#mw.message-object|msg]]:useDatabase( bool )</code> |
||
指定是否在MediaWiki:命名空间查找消息(比如在数据库中查找),或者只是使用MediaWiki分配的默认消息。 |
指定是否在MediaWiki:命名空间查找消息(比如在数据库中查找),或者只是使用MediaWiki分配的默认消息。 |
||
第2,193行: | 第2,191行: | ||
==== mw.message:plain ==== |
==== mw.message:plain ==== |
||
<code |
<code>[[#mw.message-object|msg]]:plain()</code> |
||
替换参数按原样返回消息 |
替换参数按原样返回消息wikitext。模板调用和解析器函数都是完整的。 |
||
==== mw.message:exists ==== |
==== mw.message:exists ==== |
||
<code |
<code>[[#mw.message-object|msg]]:exists()</code> |
||
返回表示消息键是否存在的布尔值。 |
返回表示消息键是否存在的布尔值。 |
||
==== mw.message:isBlank ==== |
==== mw.message:isBlank ==== |
||
<code |
<code>[[#mw.message-object|msg]]:isBlank()</code> |
||
返回表示消息键是否有内容的布尔值。当消息键不存在或者消息是空字符串时返回true。 |
返回表示消息键是否有内容的布尔值。当消息键不存在或者消息是空字符串时返回true。 |
||
==== mw.message:isDisabled ==== |
==== mw.message:isDisabled ==== |
||
<code |
<code>[[#mw.message-object|msg]]:isDisabled()</code> |
||
返回表示消息键是否被禁用的布尔值。如果消息键不存在,或者消息是空字符串,或者是字符串"-"则返回true。 |
返回表示消息键是否被禁用的布尔值。如果消息键不存在,或者消息是空字符串,或者是字符串"-"则返回true。 |
||
===站点信息库 === |
=== 站点信息库 === |
||
==== mw.site.currentVersion ==== |
==== mw.site.currentVersion ==== |
||
第2,236行: | 第2,234行: | ||
* '''id''':命名空间数字。 |
* '''id''':命名空间数字。 |
||
* '''name''':本地命名空间名称。 |
* '''name''':本地命名空间名称。 |
||
*'''canonicalName''':规范(canonical)命名空间名称。 |
* '''canonicalName''':规范(canonical)命名空间名称。 |
||
* '''displayName''':为命名空间0设置,用于显示的名称(因为这个名称通常是空白字符串)。 |
* '''displayName''':为命名空间0设置,用于显示的名称(因为这个名称通常是空白字符串)。 |
||
* '''hasSubpages''':这个命名空间是否启用了子页面。 |
* '''hasSubpages''':这个命名空间是否启用了子页面。 |
||
第2,275行: | 第2,273行: | ||
==== mw.site.stats.pagesInCategory ==== |
==== mw.site.stats.pagesInCategory ==== |
||
<code |
<code>mw.site.stats.pagesInCategory( category, which )</code> |
||
: {{red|这个函数是高开销函数}} |
: {{red|这个函数是高开销函数}} |
||
第2,291行: | 第2,289行: | ||
==== mw.site.stats.pagesInNamespace ==== |
==== mw.site.stats.pagesInNamespace ==== |
||
<code |
<code>mw.site.stats.pagesInNamespace( ns )</code> |
||
返回给定的命名空间(由数字指定)的页面数量。 |
返回给定的命名空间(由数字指定)的页面数量。 |
||
==== mw.site.stats.usersInGroup ==== |
==== mw.site.stats.usersInGroup ==== |
||
<code |
<code>mw.site.stats.usersInGroup( group )</code> |
||
返回给定的用户组的用户数量。 |
返回给定的用户组的用户数量。 |
||
==== mw.site.interwikiMap ==== |
==== mw.site.interwikiMap ==== |
||
<code |
<code>mw.site.interwikiMap( filter )</code> |
||
返回包含可用的跨wiki前缀的数据的表。如果<code>filter</code>是字符串"local",则只会返回关于本地跨wiki前缀的数据。如果<code>filter</code>是字符串"!local",则只会返回非本地跨wiki前缀的数据。如果没有指定filter,则所有的前缀的数据都会返回。这个"local"前缀是同一个项目的。比如在英文维基百科,其他语言的维基百科都会考虑为本地的(local),而维基词典不会。 |
返回包含可用的跨wiki前缀的数据的表。如果<code>filter</code>是字符串"local",则只会返回关于本地跨wiki前缀的数据。如果<code>filter</code>是字符串"!local",则只会返回非本地跨wiki前缀的数据。如果没有指定filter,则所有的前缀的数据都会返回。这个"local"前缀是同一个项目的。比如在英文维基百科,其他语言的维基百科都会考虑为本地的(local),而维基词典不会。 |
||
第2,309行: | 第2,307行: | ||
* '''prefix'''——跨wiki前缀。 |
* '''prefix'''——跨wiki前缀。 |
||
* '''url'''——跨wiki指向的URL。页面名称由参数$1体现。 |
* '''url'''——跨wiki指向的URL。页面名称由参数$1体现。 |
||
* '''isProtocalRelative'''——布尔值,显示URL是否为[[ |
* '''isProtocalRelative'''——布尔值,显示URL是否为[[URL]]。 |
||
* '''isLocal'''——这个URL是否是当前wiki的站点的。 |
* '''isLocal'''——这个URL是否是当前wiki的站点的。 |
||
* '''isCurrentWiki'''——这个URL是否是为当前wiki的。 |
* '''isCurrentWiki'''——这个URL是否是为当前wiki的。 |
||
* '''isTranscludable'''——使用这个跨wiki前缀的页面能否[[ |
* '''isTranscludable'''——使用这个跨wiki前缀的页面能否[[Help:模板|嵌入包含]]。这一功能要求“scary transclusion”(即嵌入外站页面的功能),而这在求闻百科的wiki是禁用的。 |
||
* '''isExtraLanguageLink'''——跨wiki是否列举在了 |
* '''isExtraLanguageLink'''——跨wiki是否列举在了<code>$wgExtraInterlanguageLinkPrefixes</code>配置中。 |
||
* '''displayText'''——对于列举在$wgExtraInterlanguageLinkPrefixes中的链接,跨语言链接显示的文本。未指定时为nil。 |
* '''displayText'''——对于列举在<code>$wgExtraInterlanguageLinkPrefixes</code>中的链接,跨语言链接显示的文本。未指定时为nil。 |
||
* '''tooltip'''——对于列举在$wgExtraInterlanguageLinkPrefixes的链接,当用户悬浮在跨语言链接上时显示的浮窗提示文本。未指定时为nil。 |
* '''tooltip'''——对于列举在<code>$wgExtraInterlanguageLinkPrefixes</code>的链接,当用户悬浮在跨语言链接上时显示的浮窗提示文本。未指定时为nil。 |
||
=== 文本库 === |
=== 文本库 === |
||
第2,322行: | 第2,320行: | ||
==== mw.text.decode ==== |
==== mw.text.decode ==== |
||
<code |
<code>mw.text.decode( s )</code> |
||
<br/> |
<br/> |
||
<code |
<code>mw.text.decode( s, decodeNamedEntities )</code> |
||
将字符串中的[[ |
将字符串中的[[HTML元素]]替换为对应的字符。 |
||
如果布尔值<code>decodeNameEntities</code>被省略或者为false,则只有被命名的实体“&lt;”“&gt;”“&amp;”“&quot;”和“&nbsp;”会被认可。否则,认可的HTML5命名实体的列表会从PHP的[https://php.net/get_html_translation_table <code>get_html_translation_table</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 ==== |
==== mw.text.encode ==== |
||
<code |
<code>mw.text.encode( s )</code> |
||
<br/> |
<br/> |
||
<code |
<code>mw.text.encode( s, charset )</code> |
||
使用[[ |
使用[[HTML实体]]替换字符串中的字符。字符“<”“>”“&”“"”和非换行空格会被适当的命名实体替换,所有其他的都会被替换为数字实体。 |
||
如果提供了<code>charset</code>,则它应该是合适的字符串,且被[[#Ustring patterns|Ustring模式]]的括号括住,比如<code>[set]</code>中的“set”。默认的charset是<code>'<>&"\' '</code>(末尾的空格为非换行空格,U+00A0)。 |
如果提供了<code>charset</code>,则它应该是合适的字符串,且被[[#Ustring patterns|Ustring模式]]的括号括住,比如<code>[set]</code>中的“set”。默认的charset是<code>'<>&"\' '</code>(末尾的空格为非换行空格,U+00A0)。 |
||
==== mw.text.jsonDecode ==== |
==== mw.text.jsonDecode ==== |
||
<code |
<code>mw.text.jsonDecode( s )</code> |
||
<br/> |
<br/> |
||
<code |
<code>mw.text.jsonDecode( s, flags )</code> |
||
解析JSON字符串。<code>flags</code>是0或flags<code>mw.text.JSON_PRESERVE_KEYS</code>和<code>mw.text.JSON_TRY_FIXING</code>的组合(使用<code>+</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对象会丢弃含有null值的键。 |
||
* 不能直接分辨带有序列整数键的是JSON数组还是JSON对象。 |
* 不能直接分辨带有序列整数键的是JSON数组还是JSON对象。 |
||
* 带有序列整数键从1开始 |
* 带有序列整数键从1开始的JSON对象会被解析到作为有相同值的JSON数组的相同的表结构,尽管这些不一定总是相等,除非使用了<code>mw.text.JSON_PRESERVE_KEYS</code>。 |
||
==== mw.text.jsonEncode ==== |
==== mw.text.jsonEncode ==== |
||
<code |
<code>mw.text.jsonEncode( value )</code> |
||
<br/> |
<br/> |
||
<code |
<code>mw.text.jsonEncode( value, flags )</code> |
||
编码JSON字符串。如果传入的值不能被JSON编码则会报错。<code>flags</code>是0或flags<code>mw.text.JSON_PRESERVE_KEYS</code>和<code>mw.text.JSON_PRETTY</code>的组合(使用<code>+</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 ==== |
==== mw.text.killMarkers ==== |
||
<code |
<code>mw.text.killMarkers( s )</code> |
||
除去字符串中所有的[[strip marker]]。 |
除去字符串中所有的[[strip marker]]。 |
||
==== mw.text.listToText ==== |
==== mw.text.listToText ==== |
||
<code |
<code>mw.text.listToText( list )</code> |
||
<br/> |
<br/> |
||
<code |
<code>mw.text.listToText( list, separator, conjunction )</code> |
||
使用自然语言组合一个列表,类似于<code>[[#table.concat|table.concat()]]</code>,但是最后一项前面的分隔符不同。 |
使用自然语言组合一个列表,类似于<code>[[#table.concat|table.concat()]]</code>,但是最后一项前面的分隔符不同。 |
||
第2,407行: | 第2,405行: | ||
==== mw.text.nowiki ==== |
==== mw.text.nowiki ==== |
||
<code |
<code>mw.text.nowiki( s )</code> |
||
使用[[ |
使用[[HTML实体]]替换字符串中的多种字符,以避免被解析为wikitext。包括: |
||
* 以下字符:<code>"</code>、<code>&</code>、<code>'</code>、<code><</code>、<code>=</code>、<code>></code>、<code>[</code>、<code>]</code>、<code>{</code>、<code>|</code>、<code>}</code> |
* 以下字符:<code>"</code>、<code>&</code>、<code>'</code>、<code><</code>、<code>=</code>、<code>></code>、<code>[</code>、<code>]</code>、<code>{</code>、<code>|</code>、<code>}</code> |
||
* 字符串开头或新行后面 |
* 字符串开头或新行后面的以下字符:<code>#</code>、<code>*</code>、<code>:</code>、<code>;</code>、空格、制表符('\t') |
||
* 空行会有关联的新行或返回转义的字符(Blank lines will have one of the associated newline or carriage return characters escaped) |
* 空行会有关联的新行或返回转义的字符(Blank lines will have one of the associated newline or carriage return characters escaped) |
||
* 字符串开始处或新行后 |
* 字符串开始处或新行后的<code>----</code>会使得第一个<code>-</code>被转义 |
||
* <code>__</code>会使一个下划线被转义 |
* <code>__</code>会使一个下划线被转义 |
||
* <code>://</code>会使冒号被转义 |
* <code>://</code>会使冒号被转义 |
||
第2,420行: | 第2,418行: | ||
==== mw.text.split ==== |
==== mw.text.split ==== |
||
<code |
<code>mw.text.split( s, pattern, plain )</code> |
||
在匹配了[[#Ustring patterns|Ustring模式]]的<code>pattern</code>的地方分割字符串。如果指定了<code>plain</code>且为true,则<code>pattern</code>会被解释为纯字符串而不是Lua模式(就像<code>[[#mw.ustring.find|mw.ustring.find()]]</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>mw.text.split( 'a b\tc\nd', '%s' )</code>会返回表<code>{ 'a', 'b', 'c', 'd' }</code>。 |
||
如果<code>pattern</code>匹配空字符串,<code>s</code>会被分割成单个字符。 |
如果<code>pattern</code>匹配空字符串,<code>s</code>会被分割成单个字符。 |
||
==== mw.text.gsplit ==== |
==== mw.text.gsplit ==== |
||
<code |
<code>mw.text.gsplit( s, pattern, plain )</code> |
||
返回会迭代子字符串的[[#iterators|迭代器函数]],返回的相当于调用<code>[[#mw.text.split|mw.text.split()]]</code>。 |
返回会迭代子字符串的[[#iterators|迭代器函数]],返回的相当于调用<code>[[#mw.text.split|mw.text.split()]]</code>。 |
||
==== mw.text.tag ==== |
==== mw.text.tag ==== |
||
<code |
<code>mw.text.tag( name, attrs, content )</code> |
||
<br/> |
<br/> |
||
<code |
<code>mw.text.tag{ name = string, attrs = table, content = string|false }</code> |
||
: ''注意使用了[[#named arguments|命名参数]]。'' |
: ''注意使用了[[#named arguments|命名参数]]。'' |
||
第2,449行: | 第2,447行: | ||
==== mw.text.trim ==== |
==== mw.text.trim ==== |
||
<code |
<code>mw.text.trim( s )</code> |
||
<br/> |
<br/> |
||
<code |
<code>mw.text.trim( s, charset )</code> |
||
从字符串的开始和结尾移除空白字符或其他字符。 |
从字符串的开始和结尾移除空白字符或其他字符。 |
||
如果提供了<code>charset</code>,则它应该是合适的字符串,且被[[#Ustring patterns|Ustring模式]]的括号括住,比如<code>[set]</code>中的“set”。默认的charset是ASCII空白字符,<code |
如果提供了<code>charset</code>,则它应该是合适的字符串,且被[[#Ustring patterns|Ustring模式]]的括号括住,比如<code>[set]</code>中的“set”。默认的charset是ASCII空白字符,<code>"\t\r\n\f "</code>。 |
||
==== mw.text.truncate ==== |
==== mw.text.truncate ==== |
||
<code |
<code>mw.text.truncate( text, length )</code> |
||
<br/> |
<br/> |
||
<code |
<code>mw.text.truncate( text, length, ellipsis )</code> |
||
<br/> |
<br/> |
||
<code |
<code>mw.text.truncate( text, length, ellipsis, adjustLength )</code> |
||
将文本<code>text</code>裁剪到指定的长度,如果执行了裁剪,加入<code>ellipsis</code>(省略号)。如果长度为正,则字符串末尾被裁剪,如果为负,则字符串的开头会被裁剪。如果给定了<code>adjustLength</code>且为true,则包含省略号的字符串不会长于指定的长度。 |
将文本<code>text</code>裁剪到指定的长度,如果执行了裁剪,加入<code>ellipsis</code>(省略号)。如果长度为正,则字符串末尾被裁剪,如果为负,则字符串的开头会被裁剪。如果给定了<code>adjustLength</code>且为true,则包含省略号的字符串不会长于指定的长度。 |
||
第2,488行: | 第2,486行: | ||
==== mw.text.unstripNoWiki ==== |
==== mw.text.unstripNoWiki ==== |
||
<code |
<code>mw.text.unstripNoWiki( s )</code> |
||
将MediaWiki的<nowiki> [[strip marker]]替换为对应的文本。其他类型的strip marker不会改变。 |
将MediaWiki的<nowiki> [[strip marker]]替换为对应的文本。其他类型的strip marker不会改变。 |
||
==== mw.text.unstrip ==== |
==== mw.text.unstrip ==== |
||
<code |
<code>mw.text.unstrip( s )</code> |
||
等同于<code |
等同于<code>mw.text.killMarkers( mw.text.unstripNoWiki( s ) )</code>。 |
||
这个不在显示特殊页面嵌入包含、<ref>后的HTML,就像Scribunto早期版本的那样。 |
这个不在显示特殊页面嵌入包含、<ref>后的HTML,就像Scribunto早期版本的那样。 |
||
第2,502行: | 第2,500行: | ||
==== mw.title.equals ==== |
==== mw.title.equals ==== |
||
<code |
<code>mw.title.equals( a, b )</code> |
||
检测两个标题是否相等。注意比较时忽略碎片(fragments)。 |
检测两个标题是否相等。注意比较时忽略碎片(fragments)。 |
||
==== mw.title.compare ==== |
==== mw.title.compare ==== |
||
<code |
<code>mw.title.compare( a, b )</code> |
||
返回-1、0、1,表示标题<code>a</code>是否小于、等于或大于标题<code>b</code>。 |
返回-1、0、1,表示标题<code>a</code>是否小于、等于或大于标题<code>b</code>。 |
||
第2,514行: | 第2,512行: | ||
==== mw.title.getCurrentTitle ==== |
==== mw.title.getCurrentTitle ==== |
||
<code |
<code>mw.title.getCurrentTitle()</code> |
||
返回当前页面的标题对象。 |
返回当前页面的标题对象。 |
||
==== mw.title.new ==== |
==== mw.title.new ==== |
||
<code |
<code>mw.title.new( text, namespace )</code> |
||
<br/> |
<br/> |
||
<code |
<code>mw.title.new( id )</code> |
||
: {{red|用ID调用时该函数是高开销函数}} |
: {{red|用ID调用时该函数是高开销函数}} |
||
第2,532行: | 第2,530行: | ||
==== mw.title.makeTitle ==== |
==== mw.title.makeTitle ==== |
||
<code |
<code>mw.title.makeTitle( namespace, title, fragment, interwiki )</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>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 |
注意,不像<code>[[#mw.title.new|mw.title.new()]]</code>,这个方法总会应用指定的命名空间。比如,<code>mw.title.makeTitle( 'Template', 'Module:Foo' )</code> 会为页面Template:Module:Foo创建对象,而<code>mw.title.new( 'Module:Foo', 'Template' )</code>会为页面Module:Foo创建对象。 |
||
==== 标题对象 ==== |
==== 标题对象 ==== |
||
第2,557行: | 第2,555行: | ||
* '''subpageText''':如果这是个子页面,子页面名称。否则,和<code>title.text</code>相同。 |
* '''subpageText''':如果这是个子页面,子页面名称。否则,和<code>title.text</code>相同。 |
||
* '''canTalk''':这个标题的页面能否拥有讨论页。 |
* '''canTalk''':这个标题的页面能否拥有讨论页。 |
||
*'''exists''':该页面是否存在。Media命名空间页面的<code>file.exists</code>别名。对于File命名空间的页面,这将检查文件描述页面的存在,而不是文件本身。{{red|此函数[[#Expensive properties|可能为高开销]]}}。 |
* '''exists''':该页面是否存在。Media命名空间页面的<code>file.exists</code>别名。对于File命名空间的页面,这将检查文件描述页面的存在,而不是文件本身。{{red|此函数[[#Expensive properties|可能为高开销]]}}。 |
||
*'''file''','''fileExists''':参见下面的[[#File metadata|#文件元数据]]。 |
* '''file''','''fileExists''':参见下面的[[#File metadata|#文件元数据]]。 |
||
* '''isContentPage''':这个页面是否在内容命名空间内。 |
* '''isContentPage''':这个页面是否在内容命名空间内。 |
||
* '''isExternal''':此页面是否具有跨wiki的前缀。 |
* '''isExternal''':此页面是否具有跨wiki的前缀。 |
||
* '''isLocal''':此页面是否在此项目中。例如,在英语维基百科上,任何其他语言维基百科都被视为“本地”(Local),而维基 |
* '''isLocal''':此页面是否在此项目中。例如,在英语维基百科上,任何其他语言维基百科都被视为“本地”(Local),而维基词典等则被视为非“本地”。 |
||
* '''isRedirect''':是否是重定向页面的标题。{{red|此函数[[#Expensive properties|可能为高开销]]}}。 |
* '''isRedirect''':是否是重定向页面的标题。{{red|此函数[[#Expensive properties|可能为高开销]]}}。 |
||
* '''isSpecialPage''':该页面是否可能是特殊页面(即“Special”命名空间中的页面)。 |
* '''isSpecialPage''':该页面是否可能是特殊页面(即“Special”命名空间中的页面)。 |
||
第2,572行: | 第2,570行: | ||
* '''contentModel''':此标题的内容模型,字符串,{{red|可能会造成[[#Expensive properties|高开销]]}}。 |
* '''contentModel''':此标题的内容模型,字符串,{{red|可能会造成[[#Expensive properties|高开销]]}}。 |
||
<includeonly>* '''pageLanguage''':此标题的页面语言,语言对象类似于<code>[[#mw.language.getContentLanguage|mw.language.getContentLanguage]]</code>返回的默认值,但是取决于特定页面。{{red|此函数[[#Expensive properties|可能由较高开销]]}}。</includeonly> |
<includeonly>* '''pageLanguage''':此标题的页面语言,语言对象类似于<code>[[#mw.language.getContentLanguage|mw.language.getContentLanguage]]</code>返回的默认值,但是取决于特定页面。{{red|此函数[[#Expensive properties|可能由较高开销]]}}。</includeonly> |
||
* '''basePageTitle''':等同于<code |
* '''basePageTitle''':等同于<code>mw.title.makeTitle( title.namespace, title.baseText )</code>。 |
||
* '''rootPageTitle''':等同于<code |
* '''rootPageTitle''':等同于<code>mw.title.makeTitle( title.namespace, title.rootText )</code>。 |
||
* '''talkPageTitle''':等同于<code |
* '''talkPageTitle''':等同于<code>mw.title.makeTitle( mw.site.namespaces[title.namespace].talk.id, title.text )</code>,如果该标题没有讨论页则为<code>nil</code>。 |
||
* '''subjectPageTitle''':等同于<code |
* '''subjectPageTitle''':等同于<code>mw.title.makeTitle( mw.site.namespaces[title.namespace].subject.id, title.text )</code>。 |
||
* '''redirectTarget''':返回重定向页面的目标页面的标题对象,但如果不是重定向页面,则返回<code>false</code>。 |
* '''redirectTarget''':返回重定向页面的目标页面的标题对象,但如果不是重定向页面,则返回<code>false</code>。 |
||
* '''protectionLevels''':页面的保护等级。其值为一个表,键对应每个操作(如<code>"edit"</code>、<code>"move"</code>),值为数组,第一项是包含对应保护等级的字符串,如果页面未被保护,则表的值或者数组的项就会为<code>nil</code>。{{red|此函数高开销}}。 |
* '''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|此函数开销较高}}。 |
* '''cascadingProtection''':该页面应用的级联保护,为一个表,键为<code>"restrictions"</code>(自身为一个表,键类似于<code>protectionLevels</code>拥有的那些)和<code>"sources"</code>(列举保护级联来源的标题的数组)。如果没有保护级联到此页面,则<code>"restrictions"</code>和<code>"sources"</code>可能是空的。{{red|此函数开销较高}}。 |
||
* '''subPageTitle( text )''':等同于<code |
* '''subPageTitle( text )''':等同于<code>mw.title.makeTitle( title.namespace, title.text .. '/' .. <var>text</var> )</code>。 |
||
* '''partialUrl()''':返回编码的<code>title.text</code>,就像在URL中会有的那样。 |
* '''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>。 |
* '''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>。页面会被记录为嵌入包含。 |
* '''getContent()''':返回页面的(未解析的)内容,如果页面不存在则返回<code>nil</code>。页面会被记录为嵌入包含。 |
||
标题对象可以使用[[#Relational operators|关系运算符]]比较。<code |
标题对象可以使用[[#Relational operators|关系运算符]]比较。<code>[[#tostring|tostring]]( title )</code>会返回<code>title.prefixedText</code>。 |
||
由于这可能难以置信,所以请注意获取标题对象的任何[[#Expensive properties|高开销]]的字段会记录一次对页面的“链入”(就像[[Special:WhatLinksHere|Special:链入页面]]中展示的那样)。使用标题对象的<code>getContent()</code>方法或访问<code>redirectTarget</code>字段会记录为“{{int|istemplate}}”,访问标题对象的<code>file</code>或<code>fileExists</code>字段会记录为“{{int|isimage}}”。 |
由于这可能难以置信,所以请注意获取标题对象的任何[[#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属性。 |
* '''pages''':如果文件格式支持多页,这是包含文件每个页面的表,否则为<code>nil</code>。[[#Length operator|“#”操作符]]可以用于获取文件页数。每个单独的页面表都包含一个width和height属性。 |
||
* '''size''':文件的字节长度。 |
* '''size''':文件的字节长度。 |
||
* '''mimeType''':文件的[[ |
* '''mimeType''':文件的[[MIME类型]]。 |
||
* '''length''':媒体文件的长度,单位为秒。不支持长度的媒体则为0。 |
* '''length''':媒体文件的长度,单位为秒。不支持长度的媒体则为0。 |
||
第2,612行: | 第2,610行: | ||
==== mw.uri.encode ==== |
==== mw.uri.encode ==== |
||
<code |
<code>mw.uri.encode( s, enctype )</code> |
||
[[ |
[[百分号编码]]字符串。默认类型,<code>"QUERY"</code>,使用“+”编码空格以用于查询字符;<code>"PATH"</code>将空格编码为%20,<code>"WIKI"</code>将空格编码为“_”。 |
||
注意"WIKI"格式不是完全可以逆转的,因为空格和下划线都会编码为“_”。 |
注意"WIKI"格式不是完全可以逆转的,因为空格和下划线都会编码为“_”。 |
||
==== mw.uri.decode ==== |
==== mw.uri.decode ==== |
||
<code |
<code>mw.uri.decode( s, enctype )</code> |
||
[[百分号编码|百分号解码]]字符串。默认类型,<code>"QUERY"</code>,将“+”解码为空格;<code>"PATH"</code>不执行额外的解码,<code>"WIKI"</code>将“_”解码为空格。 |
[[百分号编码|百分号解码]]字符串。默认类型,<code>"QUERY"</code>,将“+”解码为空格;<code>"PATH"</code>不执行额外的解码,<code>"WIKI"</code>将“_”解码为空格。 |
||
==== mw.uri.anchorEncode ==== |
==== mw.uri.anchorEncode ==== |
||
<code |
<code>mw.uri.anchorEncode( s )</code> |
||
编码字符串以用于MediaWiki URI fragment。 |
编码字符串以用于MediaWiki URI fragment。 |
||
==== mw.uri.buildQueryString ==== |
==== mw.uri.buildQueryString ==== |
||
<code |
<code>mw.uri.buildQueryString( table )</code> |
||
将表编码为URI查询字符串。键必须是字符串,值可以是字符串、数字、序列表或布尔值false。 |
将表编码为URI查询字符串。键必须是字符串,值可以是字符串、数字、序列表或布尔值false。 |
||
==== mw.uri.parseQueryString ==== |
==== mw.uri.parseQueryString ==== |
||
<code |
<code>mw.uri.parseQueryString( s, i, j )</code> |
||
将查询字符串<code>s</code>解码为表。字符串中没有值的键会拥有false值,重复多次的键会有序列表作为其值,其他的都会有字符串作为值。 |
将查询字符串<code>s</code>解码为表。字符串中没有值的键会拥有false值,重复多次的键会有序列表作为其值,其他的都会有字符串作为值。 |
||
第2,641行: | 第2,639行: | ||
==== mw.uri.canonicalUrl ==== |
==== mw.uri.canonicalUrl ==== |
||
<code |
<code>mw.uri.canonicalUrl( page, query )</code> |
||
返回页面的[[Help:Magic_words#URL_data|规范URL]]的[[#URI object|URI对象]],可选查询字符串或表。 |
返回页面的[[Help:Magic_words#URL_data|规范URL]]的[[#URI object|URI对象]],可选查询字符串或表。 |
||
==== mw.uri.fullUrl ==== |
==== mw.uri.fullUrl ==== |
||
<code |
<code>mw.uri.fullUrl( page, query )</code> |
||
返回页面的[[Help:Magic_words#URL_data|完整URL]]的[[#URI object|URI对象]],可选查询字符串或表。 |
返回页面的[[Help:Magic_words#URL_data|完整URL]]的[[#URI object|URI对象]],可选查询字符串或表。 |
||
==== mw.uri.localUrl ==== |
==== mw.uri.localUrl ==== |
||
<code |
<code>mw.uri.localUrl( page, query )</code> |
||
返回页面的[[Help:Magic_words#URL_data|本地URL]]的[[#URI object|URI对象]],可选查询字符串或表。 |
返回页面的[[Help:Magic_words#URL_data|本地URL]]的[[#URI object|URI对象]],可选查询字符串或表。 |
||
==== mw.uri.new ==== |
==== mw.uri.new ==== |
||
<code |
<code>mw.uri.new( s )</code> |
||
利用传入的字符串或表构造一个新的[[#URI object|URI对象]]。参见URI对象的描述以了解表可能的字段。 |
利用传入的字符串或表构造一个新的[[#URI object|URI对象]]。参见URI对象的描述以了解表可能的字段。 |
||
==== mw.uri.validate ==== |
==== mw.uri.validate ==== |
||
<code |
<code>mw.uri.validate( table )</code> |
||
验证传入的表(或URI对象)是否有效。返回布尔值,以表示表是否有效,以及如果无效,一个描述问题发生原因的字符串。 |
验证传入的表(或URI对象)是否有效。返回布尔值,以表示表是否有效,以及如果无效,一个描述问题发生原因的字符串。 |
||
第2,690行: | 第2,688行: | ||
===== mw.uri:parse ===== |
===== mw.uri:parse ===== |
||
<code |
<code>uri:parse( s )</code> |
||
将字符串解析为当前的URI对象。字符串中指定的任何字段都会被当前的对象替换;未指定的字段都会保留旧值。 |
将字符串解析为当前的URI对象。字符串中指定的任何字段都会被当前的对象替换;未指定的字段都会保留旧值。 |
||
第2,700行: | 第2,698行: | ||
===== mw.uri:extend ===== |
===== mw.uri:extend ===== |
||
<code |
<code>uri:extend( parameters )</code> |
||
将参数表合并到对象的查询表。 |
将参数表合并到对象的查询表。 |
||
第2,717行: | 第2,715行: | ||
==== mw.ustring.byte ==== |
==== mw.ustring.byte ==== |
||
<code |
<code>mw.ustring.byte( s, i, j )</code> |
||
返回单独的字节,等同于[[#string.byte|string.byte()]]。 |
返回单独的字节,等同于[[#string.byte|string.byte()]]。 |
||
==== mw.ustring.byteoffset ==== |
==== mw.ustring.byteoffset ==== |
||
<code |
<code>mw.ustring.byteoffset( s, l, i )</code> |
||
返回字符在字符串内的字节偏移值。<code>l</code>和<code>i</code>的默认值都是1.<code>i</code>可以是负数,即倒过来计数。 |
返回字符在字符串内的字节偏移值。<code>l</code>和<code>i</code>的默认值都是1.<code>i</code>可以是负数,即倒过来计数。 |
||
第2,729行: | 第2,727行: | ||
==== mw.ustring.char ==== |
==== mw.ustring.char ==== |
||
<code |
<code>mw.ustring.char( ... )</code> |
||
非常像[[#string.char|string.char()]],但是整数为Unicode代码点而非字节值。 |
非常像[[#string.char|string.char()]],但是整数为Unicode代码点而非字节值。 |
||
第2,738行: | 第2,736行: | ||
==== mw.ustring.codepoint ==== |
==== mw.ustring.codepoint ==== |
||
<code |
<code>mw.ustring.codepoint( s, i, j )</code> |
||
很像[[#string.byte|string.byte()]],但是返回的值是代码点,且偏移值为字符而非字节。 |
很像[[#string.byte|string.byte()]],但是返回的值是代码点,且偏移值为字符而非字节。 |
||
==== mw.ustring.find ==== |
==== mw.ustring.find ==== |
||
<code |
<code>mw.ustring.find( s, pattern, init, plain )</code> |
||
非常像[[#string.find|string.find()]],但是匹配模式是扩展了的,在[[#Ustring patterns|Ustring patterns]]中有描述,且<code>init</code>是按照字符而非字节。 |
非常像[[#string.find|string.find()]],但是匹配模式是扩展了的,在[[#Ustring patterns|Ustring patterns]]中有描述,且<code>init</code>是按照字符而非字节。 |
||
==== mw.ustring.format ==== |
==== mw.ustring.format ==== |
||
<code |
<code>mw.ustring.format( format, ... )</code> |
||
等同于[[#string.format|string.format()]]。字符串的宽度和精度是以字节表达,而非编号。 |
等同于[[#string.format|string.format()]]。字符串的宽度和精度是以字节表达,而非编号。 |
||
==== mw.ustring.gcodepoint ==== |
==== mw.ustring.gcodepoint ==== |
||
<code |
<code>mw.ustring.gcodepoint( s, i, j )</code> |
||
返回用于在字符串内迭代代码点的三个值。<code>i</code>默认为1,<code>j</code>默认为-1。这是为了用于[[#iterators|<code>for</code>形式的迭代]]: |
返回用于在字符串内迭代代码点的三个值。<code>i</code>默认为1,<code>j</code>默认为-1。这是为了用于[[#iterators|<code>for</code>形式的迭代]]: |
||
第2,764行: | 第2,762行: | ||
==== mw.ustring.gmatch ==== |
==== mw.ustring.gmatch ==== |
||
<code |
<code>mw.ustring.gmatch( s, pattern )</code> |
||
非常像[[#string.gmatch|string.gmatch()]],但是匹配模式是扩展了的,在[[#Ustring patterns|ustring匹配模式]]中有描述。 |
非常像[[#string.gmatch|string.gmatch()]],但是匹配模式是扩展了的,在[[#Ustring patterns|ustring匹配模式]]中有描述。 |
||
==== mw.ustring.gsub ==== |
==== mw.ustring.gsub ==== |
||
<code |
<code>mw.ustring.gsub( s, pattern, repl, n )</code> |
||
非常像[[#string.gsub|string.gsub()]],但是匹配模式是扩展了的,在[[#Ustring patterns|ustring匹配模式]]中有描述。 |
非常像[[#string.gsub|string.gsub()]],但是匹配模式是扩展了的,在[[#Ustring patterns|ustring匹配模式]]中有描述。 |
||
==== mw.ustring.isutf8 ==== |
==== mw.ustring.isutf8 ==== |
||
<code |
<code>mw.ustring.isutf8( s )</code> |
||
若字符串是有效的UTF-8,返回true,否则返回false。 |
若字符串是有效的UTF-8,返回true,否则返回false。 |
||
==== mw.ustring.len ==== |
==== mw.ustring.len ==== |
||
<code |
<code>mw.ustring.len( s )</code> |
||
返回字符串的长度,或者不是有效的UTF-8时返回nil。 |
返回字符串的长度,或者不是有效的UTF-8时返回nil。 |
||
第2,786行: | 第2,784行: | ||
==== mw.ustring.lower ==== |
==== mw.ustring.lower ==== |
||
<code |
<code>mw.ustring.lower( s )</code> |
||
非常像[[#string.lower|string.lower()]],但是所有在Unicode中定义了小写到大写转换的字符都会被转换。 |
非常像[[#string.lower|string.lower()]],但是所有在Unicode中定义了小写到大写转换的字符都会被转换。 |
||
第2,793行: | 第2,791行: | ||
==== mw.ustring.match ==== |
==== mw.ustring.match ==== |
||
<code |
<code>mw.ustring.match( s, pattern, init )</code> |
||
非常像[[#string.match|string.match()]],但是匹配模式是扩展了的,在[[#Ustring patterns|ustring匹配模式]]中有描述,且<code>init</code>偏移是按照字符而非字节。 |
非常像[[#string.match|string.match()]],但是匹配模式是扩展了的,在[[#Ustring patterns|ustring匹配模式]]中有描述,且<code>init</code>偏移是按照字符而非字节。 |
||
==== mw.ustring.rep ==== |
==== mw.ustring.rep ==== |
||
<code |
<code>mw.ustring.rep( s, n )</code> |
||
等同于[[#string.rep|string.format()]]。 |
等同于[[#string.rep|string.format()]]。 |
||
==== mw.ustring.sub ==== |
==== mw.ustring.sub ==== |
||
<code |
<code>mw.ustring.sub( s, i, j )</code> |
||
非常像[[#string.sub|string.sub()]],但是偏移值为字符而非字节。 |
非常像[[#string.sub|string.sub()]],但是偏移值为字符而非字节。 |
||
==== mw.ustring.toNFC ==== |
==== mw.ustring.toNFC ==== |
||
<code |
<code>mw.ustring.toNFC( s )</code> |
||
将字符串转化为[[Unicode等价性|正规形式C]]。如果字符串不是有效的UTF-8则返回nil。 |
将字符串转化为[[Unicode等价性|正规形式C]]。如果字符串不是有效的UTF-8则返回nil。 |
||
==== mw.ustring.toNFD ==== |
==== mw.ustring.toNFD ==== |
||
<code |
<code>mw.ustring.toNFD( s )</code> |
||
将字符串转化为[[Unicode等价性|正规形式D]]。如果字符串不是有效的UTF-8则返回nil。 |
将字符串转化为[[Unicode等价性|正规形式D]]。如果字符串不是有效的UTF-8则返回nil。 |
||
==== mw.ustring.upper ==== |
==== mw.ustring.upper ==== |
||
<code |
<code>mw.ustring.upper( s )</code> |
||
非常像[[#string.upper|string.upper()]],但是所有在Unicode中定义了大写到小写转换的字符都会被转换。 |
非常像[[#string.upper|string.upper()]],但是所有在Unicode中定义了大写到小写转换的字符都会被转换。 |
||
第2,852行: | 第2,850行: | ||
bit32 = require( 'bit32' ) |
bit32 = require( 'bit32' ) |
||
bit32库提供了无符号的32位整数的[[ |
bit32库提供了无符号的32位整数的[[位运算]]。输入的整数会被截成整数(方法未指定)并用2<sup>32</sup>模除,这样值就是在0到2<sup>32</sup>-1之间的,返回的值也会是这个范围。 |
||
如果字节被编号(就像[[#bit32.extract|bit32.extract()]]中那样),那么0是最低位的字节(带有值2<sup>0</sup>的),31是最高位的(带有值2<sup>31</sup>的)。 |
如果字节被编号(就像[[#bit32.extract|bit32.extract()]]中那样),那么0是最低位的字节(带有值2<sup>0</sup>的),31是最高位的(带有值2<sup>31</sup>的)。 |
||
==== bit32.band ==== |
==== bit32.band ==== |
||
<code |
<code>bit32.band( ... )</code> |
||
返回参数的“按位与”运算:对于结果中的每一位,只有当所有参数中都设置了该位时,结果中才会有这一位。 |
返回参数的“按位与”运算:对于结果中的每一位,只有当所有参数中都设置了该位时,结果中才会有这一位。 |
||
第2,864行: | 第2,862行: | ||
==== bit32.bnot ==== |
==== bit32.bnot ==== |
||
<code |
<code>bit32.bnot( x )</code> |
||
返回<code>x</code>的“取反”。 |
返回<code>x</code>的“取反”。 |
||
==== bit32.bor ==== |
==== bit32.bor ==== |
||
<code |
<code>bit32.bor( ... )</code> |
||
返回参数的“按位或”运算:对于结果中的每一位,只要所有参数中有任何一个设置了该位,结果中就会有这一位。 |
返回参数的“按位或”运算:对于结果中的每一位,只要所有参数中有任何一个设置了该位,结果中就会有这一位。 |
||
第2,876行: | 第2,874行: | ||
==== bit32.btest ==== |
==== bit32.btest ==== |
||
<code |
<code>bit32.btest( ... )</code> |
||
等同于<code |
等同于<code>bit32.band( ... ) ~= 0</code> |
||
==== bit32.bxor ==== |
==== bit32.bxor ==== |
||
<code |
<code>bit32.bxor( ... )</code> |
||
返回参数的“按位异或”运算:对于结果中的每一位,只有所有参数中设置了该位的参数个数为奇数,结果中才会有这一位。 |
返回参数的“按位异或”运算:对于结果中的每一位,只有所有参数中设置了该位的参数个数为奇数,结果中才会有这一位。 |
||
第2,888行: | 第2,886行: | ||
==== bit32.extract ==== |
==== bit32.extract ==== |
||
<code |
<code>bit32.extract( n, field, width )</code> |
||
从<code>n</code>导出<code>width</code>位,以<code>field</code>为开始。访问0到31范围之外的位都是错误的。 |
从<code>n</code>导出<code>width</code>位,以<code>field</code>为开始。访问0到31范围之外的位都是错误的。 |
||
第2,895行: | 第2,893行: | ||
==== bit32.replace ==== |
==== bit32.replace ==== |
||
<code |
<code>bit32.replace( n, v, field, width )</code> |
||
替换<code>n</code>中的<code>width</code>位,以<code>field</code>位开始,<code>v</code>开始的低<code>width</code>位。访问0到31范围之外的位都是错误的。 |
替换<code>n</code>中的<code>width</code>位,以<code>field</code>位开始,<code>v</code>开始的低<code>width</code>位。访问0到31范围之外的位都是错误的。 |
||
第2,902行: | 第2,900行: | ||
==== bit32.lshift ==== |
==== bit32.lshift ==== |
||
<code |
<code>bit32.lshift( n, disp )</code> |
||
返回数<code>n</code>向左[[位操作#移位|移动]]<code>disp</code>位。这是一个[[位操作#逻辑移位|逻辑移位]]:插入的位为0。这通常相当于乘以2的<code>disp</code>次方。 |
返回数<code>n</code>向左[[位操作#移位|移动]]<code>disp</code>位。这是一个[[位操作#逻辑移位|逻辑移位]]:插入的位为0。这通常相当于乘以2的<code>disp</code>次方。 |
||
第2,909行: | 第2,907行: | ||
==== bit32.rshift ==== |
==== bit32.rshift ==== |
||
<code |
<code>bit32.rshift( n, disp )</code> |
||
返回数<code>n</code>向右[[位操作#移位|移动]]<code>disp</code>位。这是一个[[位操作#逻辑移位|逻辑移位]]:插入的位为0。这通常相当于除以2的<code>disp</code>次方。 |
返回数<code>n</code>向右[[位操作#移位|移动]]<code>disp</code>位。这是一个[[位操作#逻辑移位|逻辑移位]]:插入的位为0。这通常相当于除以2的<code>disp</code>次方。 |
||
第2,916行: | 第2,914行: | ||
==== bit32.arshift ==== |
==== bit32.arshift ==== |
||
<code |
<code>bit32.arshift( n, disp )</code> |
||
返回数<code>n</code>向右[[位操作#移位|移动]]<code>disp</code>位。这是一个[[ |
返回数<code>n</code>向右[[位操作#移位|移动]]<code>disp</code>位。这是一个[[算数移位]]:如果<code>disp</code>是正的,那么插入的位将会与原始数字的31位相同。 |
||
注意超过31的移位将会导致0或4294967295。 |
注意超过31的移位将会导致0或4294967295。 |
||
==== bit32.lrotate ==== |
==== bit32.lrotate ==== |
||
<code |
<code>bit32.lrotate( n, disp )</code> |
||
返回数<code>n</code>向左旋转<code>disp</code>位。 |
返回数<code>n</code>向左旋转<code>disp</code>位。 |
||
第2,930行: | 第2,928行: | ||
==== bit32.rrotate ==== |
==== bit32.rrotate ==== |
||
<code |
<code>bit32.rrotate( n, disp )</code> |
||
返回数<code>n</code>向右旋转<code>disp</code>位。 |
返回数<code>n</code>向右旋转<code>disp</code>位。 |
||
第2,943行: | 第2,941行: | ||
==== libraryUtil.checkType ==== |
==== libraryUtil.checkType ==== |
||
<code |
<code>libraryUtil.checkType( name, argIdx, arg, expectType, nilOk )</code> |
||
<code |
<code>[[#type|type]]( arg )</code>不符合预期类型<code>expectType</code>时报错。此外,如果<code>arg</code>是nil且<code>nilOk</code>为true,则不会报错。 |
||
<code>name</code>是调用函数的名称,<code>argIdx</code>是参数列表中参数的位置。这些用于格式化错误消息。 |
<code>name</code>是调用函数的名称,<code>argIdx</code>是参数列表中参数的位置。这些用于格式化错误消息。 |
||
==== libraryUtil.checkTypeMulti ==== |
==== libraryUtil.checkTypeMulti ==== |
||
<code |
<code>libraryUtil.checkTypeMulti( name, argIdx, arg, expectTypes )</code> |
||
<code |
<code>[[#type|type]]( arg )</code>不符合预期类型数组<code>expectTypes</code>中的任何字符串时报错。 |
||
用于可以有多个有效类型的参数。 |
用于可以有多个有效类型的参数。 |
||
==== libraryUtil.checkTypeForIndex ==== |
==== libraryUtil.checkTypeForIndex ==== |
||
<code |
<code>libraryUtil.checkTypeForIndex( index, value, expectType )</code> |
||
<code |
<code>[[#type|type]]( value )</code>不符合预期类型<code>expectType</code>时报错。 |
||
用于实现<code>__newindex</code>[[#Metatables|元方法]]。 |
用于实现<code>__newindex</code>[[#Metatables|元方法]]。 |
||
==== libraryUtil.checkTypeForNamedArg ==== |
==== libraryUtil.checkTypeForNamedArg ==== |
||
<code |
<code>libraryUtil.checkTypeForNamedArg( name, argName, arg, expectType, nilOk )</code> |
||
<code |
<code>[[#type|type]]( arg )</code>不符合预期类型<code>expectType</code>时报错。此外,如果<code>arg</code>是nil且<code>nilOk</code>为true,则不会报错。 |
||
在使用Lua的命名参数语法(<code |
在使用Lua的命名参数语法(<code>func{ name = value }</code>)中,此函数用作<code>[[#libraryUtil.checkType|libraryUtil.checkType()]]</code>的等效。 |
||
==== libraryUtil.makeCheckSelfFunction ==== |
==== libraryUtil.makeCheckSelfFunction ==== |
||
<code |
<code>libraryUtil.makeCheckSelfFunction( libraryName, varName, selfObj, selfObjDesc )</code> |
||
此函数用于在用于被<code>obj:method()</code>语法调用的对象表中实现“方法”,会返回一个应该在这些方法顶部调用的函数,并使用<code>self</code>参数和方法名称,如果<code>self</code>对象不是<code>selfObject</code>则会抛出错误。 |
此函数用于在用于被<code>obj:method()</code>语法调用的对象表中实现“方法”,会返回一个应该在这些方法顶部调用的函数,并使用<code>self</code>参数和方法名称,如果<code>self</code>对象不是<code>selfObject</code>则会抛出错误。 |
||
第3,067行: | 第3,065行: | ||
== 与标准Lua的不同之处 == |
== 与标准Lua的不同之处 == |
||
===改变的函数=== |
=== 改变的函数 === |
||
以下函数被'''修改'''了: |
以下函数被'''修改'''了: |
||
第3,083行: | 第3,081行: | ||
以下包被'''几乎移除'''。只有列出来的函数可用。 |
以下包被'''几乎移除'''。只有列出来的函数可用。 |
||
; |
; [https://www.lua.org/manual/5.1/manual.html#5.3 package.*]: 文件系统和对C库的取得被移除了。 可用的函数和表为: |
||
:; [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.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.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.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-package.seeall package.seeall()] |
||
; |
; [https://www.lua.org/manual/5.1/manual.html#5.8 os.*]: 有些不安全的函数,例如os.execute(),因而不被允许。 可用的函数为: |
||
:; [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.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.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.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-os.time os.time()] |
||
; |
; [https://www.lua.org/manual/5.1/manual.html#5.9 debug.*]: 大多数函数都是不安全的。 可用的函数为: |
||
:; [https://www.lua.org/manual/5.1/manual.html#pdf-debug.traceback debug.traceback()] |
:; [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引擎运行测试。 |
Scribunto扩展包括一个用于测试用例的基类<code>Scribunto_LuaEngineTestBase</code>,该类将针对LuaSandbox和LuaStandalone引擎运行测试。 |
||
库的测试用例应该扩展这个类,并且不应该覆盖<code>static function suite()</code>。 |
库的测试用例应该扩展这个类,并且不应该覆盖<code>static function suite()</code>。 |
||
在Scribunto扩展中,测试用例应该在<code>tests/engines/LuaCommon/''Name''LibraryTest.php</code>并添加到{{phpi|ScribuntoHooks::unitTestsList()}}中的数组中(在<code>common/Hooks.php</code>中),扩展应该在自己的<code>[[Manual:Hooks/UnitTestsList|UnitTestsList]]</code>钩子函数中添加测试用例,可能取决于是否设置了<code>$wgAutoloadClasses['Scribunto_LuaEngineTestBase']</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测试: |
||
# 针对核心运行phpunit,允许tests/phpunit/suites/ExtensionsTestSuite.php使用[[Manual:Hooks/UnitTestsList|UnitTestsList]]钩子找到扩展的测试。 如果您的扩展的测试类名称都包含一个唯一的组件(例如扩展的名称),则可以使用<code>--filter</code>选项以仅运行您的扩展的测试。 |
# 针对核心运行phpunit,允许tests/phpunit/suites/ExtensionsTestSuite.php使用[[mw:Manual:Hooks/UnitTestsList|UnitTestsList]]钩子找到扩展的测试。 如果您的扩展的测试类名称都包含一个唯一的组件(例如扩展的名称),则可以使用<code>--filter</code>选项以仅运行您的扩展的测试。 |
||
# 对扩展目录运行phpunit,这将获取以“Test.php”结尾的任何文件。 |
# 对扩展目录运行phpunit,这将获取以“Test.php”结尾的任何文件。 |
||
第3,232行: | 第3,230行: | ||
Scribunto中包含的模块应该在上面的[[#Scribunto libraries|Scribunto库]]部分中包含文档。扩展库应该在其自己的扩展页面的子页面中包含文档,并从上方的[[#Extension library|扩展库]]章节中链接到该文档。 |
Scribunto中包含的模块应该在上面的[[#Scribunto libraries|Scribunto库]]部分中包含文档。扩展库应该在其自己的扩展页面的子页面中包含文档,并从上方的[[#Extension library|扩展库]]章节中链接到该文档。 |
||
==参见== |
== 参见 == |
||
* [[Lua]] |
* [[Lua]] |
||
{{anchor|License}} |
{{anchor|License}} |
||
== 许可协议 == |
== 许可协议 == |
||
本手册取自[[mw:Extension:Scribunto/Lua_reference_manual/zh|MediaWiki网站]],以[[cc-by-sa:3.0|CC BY-SA 3.0]]授权。 |
本手册(中文翻译)取自[[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许可证]下可用。 |
本手册(英文原文)取自[https://www.lua.org/manual/5.1/index.html Lua 5.1 参考手册],在[https://www.lua.org/license.html MIT许可证]下可用。 |
||
第3,243行: | 第3,241行: | ||
{{MIT License|year=1994–2012|Lua.org,PUC-Rio}} |
{{MIT License|year=1994–2012|Lua.org,PUC-Rio}} |
||
{{-}} |
|||
⚫ | |||
{{帮助页面}} |
|||
⚫ |