Token

目录

• 简介
• Properties
  • type ✅
  • images
  • links
  • embeds
• Methods
  • safeReplaceWith
  • createComment
  • createElement
  • createTextNode
  • createRange
  • caretPositionFromIndex
  • caretPositionFromPoint
  • elementFromIndex
  • elementFromPoint
  • elementsFromIndex
  • elementsFromPoint
  • isInterwiki
  • cloneNode
  • sections
  • section
  • findEnclosingHtml
  • getCategories
  • expand
  • solveConst
  • flatten
  • toHtml

Other Languages

• English

简介

这是所有特定维基语法对应节点的父类。Token 类的父类 AstElement 是仿照 HTMLElement 类设计的。本页面仅介绍 Token 类新增的属性和方法。

✅ 在 Mini 和 Browser 版本中可用。

Properties

type

✅ 展开

type: string
节点类型。

// type
assert.strictEqual(Parser.parse('').type, 'root');

images

展开

type: Token[]
所有图片节点，只读。

// images (main)
var root = Parser.parse('[[file:a]]'),
	{firstChild} = root;
assert.equal(firstChild, '[[file:a]]');
assert.deepStrictEqual(root.images, [firstChild]);

links

展开

type: Token[]
所有内链、外链、自由外链和图片链接，只读。

// links (main)
var root = Parser.parse([[a]][//b]http://c[[file:d|link=e]]'),
	{childNodes: [link, extLink, magicLink, {lastChild}]} = root;
assert.equal(link, '[[a]]');
assert.equal(extLink, '[//b]');
assert.equal(magicLink, 'http://c');
assert.equal(lastChild, 'link=e');
assert.deepStrictEqual(root.links, [
	link,
	extLink,
	magicLink,
	lastChild,
]);

embeds

展开

type: Token[]
所有嵌入的模板和模块，只读。

// embeds (main)
var root = Parser.parse('{{a}}{{#invoke:b|c}}'),
	{firstChild, lastChild} = root;
assert.equal(firstChild, '{{a}}');
assert.equal(lastChild, '{{#invoke:b|c}}');
assert.deepStrictEqual(root.embeds, [firstChild, lastChild]);

Methods

safeReplaceWith

展开

param: this 待替换的节点
一些具有特殊语法作用的节点只能使用这个方法替换为同类节点。注意需要使用这个方法的场合一般也需要搭配 AstNode.prototype.destroy 方法。

// safeReplaceWith (main)
var {firstChild, lastChild: {lastChild}} = Parser.parse('<p><p lang="zh">'),
	attrs = lastChild.cloneNode();
assert.equal(firstChild, '<p>');
assert.equal(lastChild, ' lang="zh"');
assert.equal(attrs, ' lang="zh"');
try {
	firstChild.lastChild.replaceWith(attrs);
} catch (e) {
	assert(e instanceof Error);
	assert.equal(e.message, 'HtmlToken cannot insert child nodes!');
}
firstChild.lastChild.safeReplaceWith(attrs);

createComment

展开

param: string 注释内容
returns: CommentToken
生成一个 HTML 注释。

// createComment (main)
var {firstChild} = Parser.parse('<!--a-->');
assert.equal(firstChild, '<!--a-->');
assert.deepStrictEqual(firstChild.createComment('a'), firstChild);

createElement

展开

param: string 标签名
param: {closing?: boolean, selfClosing?: boolean} 选项
returns: Token
生成一个 HTML 标签或扩展标签。

// createElement (main)
var root = Parser.parse('</p><ref/>'),
	{firstChild, lastChild} = root;
assert.equal(firstChild, '</p>');
assert.equal(lastChild, '<ref/>');
assert.deepStrictEqual(
	root.createElement('p', {closing: true}),
	firstChild,
);
assert.deepStrictEqual(
	root.createElement('ref', {selfClosing: true}),
	lastChild,
);

createTextNode

展开

param: string
returns: AstText
生成一个纯文本节点。

// createTextNode (main)
var root = Parser.parse('text');
assert.deepStrictEqual(root.createTextNode('text'), root.firstChild);

createRange

展开

returns: AstRange
生成一个 AstRange 对象。

// createRange (main)
var root = Parser.parse('text'),
	{firstChild} = root,
	range = root.createRange();
range.setStart(firstChild, 1);
range.setEnd(firstChild, 3);
assert.strictEqual(range.toString(), 'ex');

caretPositionFromIndex

展开

param: number 字符位置
returns: {offsetNode: AstNode, offset: number}
找到给定位置。

// caretPositionFromIndex (main)
var root = Parser.parse('[[a]]'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.deepStrictEqual(root.caretPositionFromIndex(1), {
	offsetNode: firstChild,
	offset: 1,
});

caretPositionFromPoint

展开

param: number 字符所在列
param: number 字符所在行
returns: {offsetNode: AstNode, offset: number}
找到给定位置。

// caretPositionFromPoint (main)
var root = Parser.parse('[[a]]'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.deepStrictEqual(root.caretPositionFromPoint(1, 0), {
	offsetNode: firstChild,
	offset: 1,
});

elementFromIndex

展开

param: number 字符位置
returns: AstNode
找到给定位置所在的最外层节点。

// elementFromIndex (main)
var root = Parser.parse('[[a]]'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.strictEqual(root.elementFromIndex(1), firstChild);

elementFromPoint

展开

param: number 字符所在列
param: number 字符所在行
returns: AstNode
找到给定位置所在的最外层节点。

// elementFromPoint (main)
var root = Parser.parse('[[a]]'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.strictEqual(root.elementFromPoint(1, 0), firstChild);

elementsFromIndex

展开

param: number 字符位置
returns: AstNode[]
找到给定位置所在的所有节点。

// elementsFromIndex (main)
var root = Parser.parse('[[a]]'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.deepStrictEqual(root.elementsFromIndex(1), [root, firstChild]);

elementsFromPoint

展开

param: number 字符行
param: number 字符列
returns: AstNode[]
找到给定位置所在的所有节点。

// elementsFromPoint (main)
var root = Parser.parse('[[a]]'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.deepStrictEqual(root.elementsFromPoint(1, 0), [root, firstChild]);

isInterwiki

展开

param: string 链接标题
returns: RegExpExecArray | null
类似 Parser.isInterwiki 方法，但使用与当前节点相同的解析设置。

cloneNode

展开

returns: this
深拷贝节点。不同类型的节点采用了不同的深拷贝算法。

sections

展开

returns: AstRange[]
获取全部章节（含序言），每个章节均是一个数组。只可用于根节点。

// sections (main)
var root = Parser.parse('a\n==b==\nc'),
	[s1, s2] = root.sections(),
	{childNodes: [a, b, c]} = root;
assert.equal(a, 'a\n');
assert.equal(b, '==b==');
assert.equal(c, '\nc');
assert.deepStrictEqual(s1.startContainer, root);
assert.deepStrictEqual(s1.endContainer, root);
assert.equal(s1.startOffset, 0);
assert.equal(s1.endOffset, 1);
assert.deepStrictEqual(s2.startContainer, root);
assert.deepStrictEqual(s2.endContainer, root);
assert.equal(s2.startOffset, 1);
assert.equal(s2.endOffset, 3);

section

展开

param: number 章节序号
returns: AstRange
获取指定章节。只可用于根节点。

// section (main)
var root = Parser.parse('a\n==b==\nc'),
	section = root.section(1),
	{childNodes: [, b, c]} = root;
assert.equal(b, '==b==');
assert.equal(c, '\nc');
assert.deepStrictEqual(section.startContainer, root);
assert.deepStrictEqual(section.endContainer, root);
assert.equal(section.startOffset, 1);
assert.equal(section.endOffset, 3);

findEnclosingHtml

展开

param: string HTML 标签名（可省略）
returns: [HtmlToken, HtmlToken]
获取指定的外层HTML标签。注意纯文本节点无法使用此方法。

// findEnclosingHtml (main)
var {childNodes: [start, link, end]} = Parser.parse('<p>[[a]]</p>'),
	range = link.createRange();
assert.equal(start, '<p>');
assert.equal(link, '[[a]]');
assert.equal(end, '</p>');
range.setStartBefore(start);
range.setEndAfter(end);
assert.deepStrictEqual(link.findEnclosingHtml(), range);

getCategories

展开

returns: [string, string | undefined][]
获取全部分类及其排序关键词。

// getCategories (main)
assert.deepStrictEqual(
	Parser.parse([[category:a]][[category:b|c]]').getCategories(),
	[
		['Category:A', undefined],
		['Category:B', 'c'],
	],
);

expand

展开

加入的版本：1.10.0

returns: Token
展开模板和部分魔术字。

// expand (main)
var root, copy;
Parser.templates.set(
	'Template:Link_start',
	`[[{{{1|<noinclude>Template:Link start]]</noinclude>}}}<noinclude>
{{doc}}</noinclude>`,
);
root = Parser.parse('{{link start|a}}b|c]]');
copy = root.expand();
assert.deepStrictEqual(copy.childNodes.map(({type}) => type), ['link']);
assert.equal(copy, '[[ab|c]]');

solveConst

展开

returns: Token
解析参变量和部分魔术字。

// solveConst (main)
var root = Parser.parse(
		`{{{null}}}{{{|[[a]]}}}{{#if:||[//b]}}{{#switch:|#default={{c}}}}{{#switch:d|d|e=}}`,
	),
	copy = root.solveConst();
assert.deepStrictEqual(
	copy.childNodes.map(({type}) => type),
	['text', 'link', 'ext-link', 'template'],
);
assert.deepStrictEqual(
	copy.childNodes.map(String),
	['{{{null}}}', '[[a]]', '[//b]', '{{c}}'],
);

flatten

展开

合并普通节点的普通子节点。

// flatten (main)
var root = Parser.parse(''),
	plain = Parser.parse('a'),
	{firstChild} = plain;
root.append(plain);
root.flatten();
assert.strictEqual(root.lastChild, firstChild);

toHtml

展开

加入的版本: 1.10.0

param: boolean 是否禁用换行
returns: string
转换为 HTML。

// toHtml (main)
var root;
Parser.templates.set('Template:Dt', ';');
root = Parser.parse('{{dt}}{{dt}}a:b');
assert.strictEqual(
	root.toHtml(),
	`<dl><dt></dt>\n<dt>a</dt>\n<dd>b</dd></dl>`,
);