Other Languages

English

简介

模板或魔术字。这个类继承了 Token 类的全部属性和方法，这里不再列出。

✅ 在 Mini 和 Browser 版本中可用。

Properties

modifier

✅ 展开

type: string
subst 和 safesubst 等，包含 :，只读。

// modifier
var magicWord = Parser
	.parse("<includeonly>{{subst:REVISIONUSER}}</includeonly>", true)
	.querySelector("magic-word");
assert.equal(magicWord, "{{subst:REVISIONUSER}}");
assert.strictEqual(magicWord.modifier, "subst:");

name

✅ 展开

type: string
模板名（含名字空间）或魔术字，只读。

// name
var {firstChild, lastChild} = Parser.parse("{{a}}{{!}}");
assert.equal(firstChild, "{{a}}");
assert.equal(lastChild, "{{!}}");
assert.strictEqual(firstChild.name, "Template:A");
assert.strictEqual(lastChild.name, "!");

// name (main)
var {firstChild} = Parser.parse("{{a}}");
firstChild.firstChild.setText("b", 0);
assert.strictEqual(firstChild.name, "Template:B");

module

✅ 展开

加入的版本：1.21.0

type: string | undefined
模块名（含名字空间），只读。

// module
var {firstChild, lastChild} = Parser.parse("{{#invoke:a|b}}{{c}}");
assert.equal(firstChild, "{{#invoke:a|b}}");
assert.equal(lastChild, "{{c}}");
assert.strictEqual(firstChild.module, "Module:A");
assert.strictEqual(lastChild.module, undefined);
firstChild.childNodes[1].setText("b", 0);
assert.strictEqual(firstChild.module, "Module:B");

function

✅ 展开

加入的版本：1.21.2

type: string | undefined
模块函数名，只读。

// function
var {firstChild, lastChild} = Parser.parse("{{#invoke:a|b}}{{c}}");
assert.equal(firstChild, "{{#invoke:a|b}}");
assert.equal(lastChild, "{{c}}");
assert.strictEqual(firstChild.function, "b");
assert.strictEqual(lastChild.function, undefined);
firstChild.childNodes[2].setText("a", 0);
assert.strictEqual(firstChild.function, "a");

anonCount

展开

加入的版本：1.36.0

type: number
匿名参数的个数，只读。

// anonCount (main)
var {firstChild} = Parser.parse("{{a|b|1=b}}");
assert.equal(firstChild, "{{a|b|1=b}}");
assert.strictEqual(firstChild.anonCount, 1);

duplication

展开

type: boolean
是否存在重复参数。

// duplication (main)
var {firstChild} = Parser.parse("{{a|b|1=b}}");
assert.equal(firstChild, "{{a|b|1=b}}");
assert.ok(firstChild.duplication);

Methods

setModifier

✅ 展开

param: string 引用修饰符
设置引用修饰符。

// setModifier
var {firstChild} = Parser.parse("{{a}}");
assert.equal(firstChild, "{{a}}");
firstChild.setModifier("subst:");
assert.equal(firstChild, "{{subst:a}}");

isTemplate

✅ 展开

returns: boolean
是否是模板或模块。

// isTemplate
var {firstChild, lastChild} = Parser.parse("{{a}}{{!}}");
assert.equal(firstChild, "{{a}}");
assert.equal(lastChild, "{{!}}");
assert.ok(firstChild.isTemplate());
assert.ok(!lastChild.isTemplate());

lint

✅ 展开

returns: LintError[]
报告潜在语法错误。

// lint
var [a, b] = Parser.parse("{{#invoke:[a]}}{{#invoke:b#b|b|b=1|b=2}}")
	.querySelectorAll("magic-word");
assert.equal(a, "{{#invoke:[a]}}");
assert.equal(b, "{{#invoke:b#b|b|b=1|b=2}}");
assert.deepStrictEqual(a.lint(), [
	{
		rule: "invalid-invoke",
		severity: "error",
		message: "invalid Scribunto module name",
		startLine: 0,
		startCol: 10,
		startIndex: 10,
		endLine: 0,
		endCol: 13,
		endIndex: 13,
	},
	{
		rule: "invalid-invoke",
		severity: "error",
		message: "missing Scribunto module function name",
		startLine: 0,
		startCol: 0,
		startIndex: 0,
		endLine: 0,
		endCol: 15,
		endIndex: 15,
	},
]);
assert.deepStrictEqual(b.lint(), [
	{
		rule: "no-ignored",
		severity: "warning",
		message: "useless fragment",
		startLine: 0,
		startCol: 25,
		startIndex: 25,
		endLine: 0,
		endCol: 28,
		endIndex: 28,
		suggestions: [
			{
				range: [26, 28],
				text: "",
				desc: "remove",
			},
		],
	},
	{
		rule: "no-duplicate",
		severity: "error",
		message: "duplicate template parameter",
		startLine: 0,
		startCol: 31,
		startIndex: 31,
		endLine: 0,
		endCol: 34,
		endIndex: 34,
		suggestions: [
			{
				desc: "remove",
				range: [30, 34],
				text: "",
			},
		],
	},
	{
		rule: "no-duplicate",
		severity: "error",
		message: "duplicate template parameter",
		startLine: 0,
		startCol: 35,
		startIndex: 35,
		endLine: 0,
		endCol: 38,
		endIndex: 38,
		suggestions: [
			{
				desc: "remove",
				range: [34, 38],
				text: "",
			},
		],
	},
]);

getAllArgs

展开

returns: ParameterToken[]
获取所有参数。

// getAllArgs (main)
var {firstChild} = Parser.parse("{{a|b|c=1}}");
assert.equal(firstChild, "{{a|b|c=1}}");
assert.deepStrictEqual(
	firstChild.getAllArgs(),
	firstChild.querySelectorAll("parameter"),
);

getAnonArgs

展开

returns: ParameterToken[]
获取所有匿名参数。

// getAnonArgs (main)
var {firstChild} = Parser.parse("{{a|b|c=1}}");
assert.equal(firstChild, "{{a|b|c=1}}");
assert.deepStrictEqual(
	firstChild.getAnonArgs(),
	[firstChild.querySelector("parameter")],
);

getArgs

✅ 展开

param: string | number
returns: Set<ParameterToken>
获取指定参数。

// getArgs
var {firstChild} = Parser.parse("{{a|b|1=c}}");
assert.equal(firstChild, "{{a|b|1=c}}");
assert.deepStrictEqual(
	firstChild.getArgs(1),
	new Set(firstChild.querySelectorAll("parameter")),
);

getDuplicatedArgs

✅ 展开

returns: [string, ParameterToken[]][]
获取重名参数。

// getDuplicatedArgs
var {firstChild} = Parser.parse("{{a|b|1=c}}");
assert.equal(firstChild, "{{a|b|1=c}}");
assert.deepStrictEqual(
	firstChild.getDuplicatedArgs(),
	[["1", firstChild.querySelectorAll("parameter")]],
);

getPossibleValues

✅ 展开

returns: Token[]
对特定魔术字获取可能的取值。

// getPossibleValues
var {firstChild} = Parser.parse("{{#if:a|b|c}}"),
	{childNodes: [, a, b, c]} = firstChild;
assert.equal(firstChild, "{{#if:a|b|c}}");
assert.equal(a, "a");
assert.equal(b, "b");
assert.equal(c, "c");
assert.deepStrictEqual(
	firstChild.getPossibleValues(),
	[b.lastChild, c.lastChild],
);

getModule

展开

加入的版本：1.16.4

returns: [string, string]
获取模块名和函数名。

// getModule (main)
var {firstChild} = Parser.parse("{{#invoke:a|b}}");
assert.equal(firstChild, "{{#invoke:a|b}}");
assert.deepStrictEqual(
	firstChild.getModule(),
	["Module:A", "b"],
);

getFrame

展开

加入的版本：1.22.0

returns: Frame
获取一个用于 #invoke 解析器函数的基本的 JSON frame 对象。

// getFrame (main)
var {firstChild} = Parser.parse("{{#invoke:a a|b|c|1=d}}");
assert.equal(firstChild, "{{#invoke:a a|b|c|1=d}}");
assert.deepStrictEqual(
	firstChild.getFrame(),
	{
		args: {1: "d"},
		parent: undefined,
		title: "Module:A a",
	},
);

cloneNode

展开

returns: this
深拷贝节点。

// cloneNode (main)
var {firstChild, lastChild} = Parser.parse("{{a}}{{!}}");
assert.equal(firstChild, "{{a}}");
assert.equal(lastChild, "{{!}}");
assert.deepStrictEqual(firstChild.cloneNode(), firstChild);
assert.deepStrictEqual(lastChild.cloneNode(), lastChild);

subst

展开

替换引用。

// subst (main)
var {firstChild} = Parser.parse("{{a}}");
assert.equal(firstChild, "{{a}}");
firstChild.subst();
assert.equal(firstChild, "{{subst:a}}");

safesubst

展开

安全的替换引用。

// safesubst (main)
var {firstChild} = Parser.parse("{{a}}");
assert.equal(firstChild, "{{a}}");
firstChild.safesubst();
assert.equal(firstChild, "{{safesubst:a}}");

hasArg

展开

param: string | number 参数名
returns: boolean
是否具有某参数。

// hasArg (main)
var {firstChild} = Parser.parse("{{a|b}}");
assert.equal(firstChild, "{{a|b}}");
assert.ok(firstChild.hasArg(1));

getArg

展开

param: string | number 参数名
returns: ParameterToken
获取生效的指定参数。

// getArg (main)
var {firstChild} = Parser.parse("{{a|b|1=c}}");
assert.equal(firstChild, "{{a|b|1=c}}");
assert.strictEqual(firstChild.getArg(1), firstChild.lastChild);

removeArg

展开

param: string | number 参数名
移除指定参数。

// removeArg (main)
var {firstChild} = Parser.parse("{{a|b|c}}");
assert.equal(firstChild, "{{a|b|c}}");
firstChild.removeArg(1);
assert.equal(firstChild, "{{a|2=c}}");

getKeys

展开

returns: string[]
获取所有参数名。

// getKeys (main)
var {firstChild} = Parser.parse("{{a|b|c=1}}");
assert.equal(firstChild, "{{a|b|c=1}}");
assert.deepStrictEqual(firstChild.getKeys(), ["1", "c"]);
firstChild.lastChild.firstChild.setText("d", 0);
assert.deepStrictEqual(firstChild.getKeys(), ["1", "d"]);

getValues

展开

param: string | number 参数名
returns: string[]
获取参数值。

// getValues (main)
var {firstChild} = Parser.parse("{{a|b|1=c}}");
assert.equal(firstChild, "{{a|b|1=c}}");
assert.deepStrictEqual(firstChild.getValues(1), ["b", "c"]);

getValue

展开

param: string | number 参数名
returns: string
获取生效的指定参数值。

// getValue (main)
var {firstChild} = Parser.parse("{{a|b|1=c}}");
assert.equal(firstChild, "{{a|b|1=c}}");
assert.deepStrictEqual(firstChild.getValue(1), "c");

newAnonArg

展开

param: string 参数值
param: boolean 是否在添加参数时另起一行
插入匿名参数。

// newAnonArg (main)
var {firstChild} = Parser.parse("{{a}}");
assert.equal(firstChild, "{{a}}");
firstChild.newAnonArg("b");
firstChild.newAnonArg("c", true);
firstChild.setValue("d", "");
firstChild.newAnonArg("e", true);
assert.equal(firstChild, "{{a|b|c|d=\n|e}}");
({firstChild} = Parser.parse("{{#if:x}}"));
assert.equal(firstChild, "{{#if:x}}");
firstChild.newAnonArg("y", true);
assert.equal(firstChild, "{{#if:x\n|y}}");

setValue

展开

param: string 参数名
param: string 参数值
param: boolean 是否在添加参数时另起一行
设置参数值。

// setValue (main)
var {firstChild} = Parser.parse("{{a|b}}");
assert.equal(firstChild, "{{a|b}}");
firstChild.setValue("1", "c");
firstChild.setValue("2", "d", true);
firstChild.setValue("e", "", true);
assert.equal(firstChild, "{{a|c|2=d\n|e=}}");

anonToNamed

展开

将匿名参数改写为命名参数。

// anonToNamed (main)
var {firstChild} = Parser.parse("{{a|b|c}}");
assert.equal(firstChild, "{{a|b|c}}");
firstChild.anonToNamed();
assert.equal(firstChild, "{{a|1=b|2=c}}");

replaceTemplate

展开

param: string 模板名
替换模板名。

// replaceTemplate (main)
var {firstChild} = Parser.parse("{{a}}");
assert.equal(firstChild, "{{a}}");
firstChild.replaceTemplate("b");
assert.equal(firstChild, "{{b}}");

replaceModule

展开

param: string 模块名
替换模块名。

// replaceModule (main)
var {firstChild} = Parser.parse("{{#invoke:a|b}}");
assert.equal(firstChild, "{{#invoke:a|b}}");
firstChild.replaceModule("c");
assert.equal(firstChild, "{{#invoke:c|b}}");

replaceFunction

展开

param: string 模块函数名
替换模块函数。

// replaceFunction (main)
var {firstChild} = Parser.parse("{{#invoke:a|b}}");
assert.equal(firstChild, "{{#invoke:a|b}}");
firstChild.replaceFunction("c");
assert.equal(firstChild, "{{#invoke:a|c}}");

hasDuplicatedArgs

展开

returns: number
重复参数计数。

// hasDuplicatedArgs (main)
var {firstChild} = Parser.parse("{{a|b|1=c}}");
assert.equal(firstChild, "{{a|b|1=c}}");
assert.strictEqual(firstChild.hasDuplicatedArgs(), 1);

fixDuplication

展开

returns: string[]
修复重名参数。

// fixDuplication (main)
var {firstChild} = Parser.parse("{{a|b|1=b|1=}}");
assert.equal(firstChild, "{{a|b|1=b|1=}}");
firstChild.fixDuplication();
assert.equal(firstChild, "{{a|b}}");

escapeTables

展开

returns: this
转义模板内的表格。

// escapeTables (main)
var root = Parser.parse("{{a|\n{|\n|-\n|rowspan=2|d\n|}\n}}"),
	{firstChild} = root;
assert.equal(firstChild, "{{a|\n{|\n|-\n|rowspan=2|d\n|}\n}}");
assert.strictEqual(firstChild.length, 7);
firstChild.escapeTables();
assert.equal(
	root,
	"{{a|\n{{{!}}\n{{!}}-\n{{!}}rowspan{{=}}2{{!}}d\n{{!}}}\n}}",
);
assert.strictEqual(root.firstChild.length, 2);

TranscludeToken - bhsd-harry/wikiparser-node GitHub Wiki

Other Languages

简介

Properties

modifier

name

module

function

anonCount

duplication

Methods

setModifier

isTemplate

lint

getAllArgs

getAnonArgs

getArgs

getDuplicatedArgs

getPossibleValues

getModule

getFrame

cloneNode

subst

safesubst

hasArg

getArg

removeArg

getKeys

getValues

getValue

newAnonArg

setValue

anonToNamed

replaceTemplate

replaceModule

replaceFunction

hasDuplicatedArgs

fixDuplication

escapeTables

相关软件包

Related Packages

⚠️ **GitHub.com Fallback** ⚠️

⚠️ GitHub.com Fallback ⚠️