AstNode

目录

• 简介
• Properties
  • childNodes ✅
  • firstChild ✅
  • lastChild ✅
  • parentNode ✅
  • nextSibling ✅
  • previousSibling ✅
  • offsetHeight ✅
  • offsetWidth ✅
  • nextElementSibling
  • previousElementSibling
  • nextVisibleSibling
  • previousVisibleSibling
  • isConnected
  • eof
  • offsetTop
  • offsetLeft
  • style
  • font
  • bold
  • italic
• Methods
  • getRootNode ✅
  • posFromIndex ✅
  • getRelativeIndex ✅
  • getAbsoluteIndex ✅
  • is ✅
  • isEqualNode
  • after
  • before
  • remove
  • replaceWith
  • contains
  • addEventListener
  • removeEventListener
  • removeAllEventListeners
  • listEventListeners
  • dispatchEvent
  • getAncestors
  • compareDocumentPosition
  • indexFromPos
  • getBoundingClientRect
  • destroy
  • getLine

Other Languages

• English

简介

AstNode 是所有纯文本节点和其他节点的父类，仿照 Node 类设计，属性和方法也和 Node 类非常相似。

✅ 在 Mini 和 Browser 版本中可用。

Properties

childNodes

✅ 展开

type: AstNode[]
全部子节点构成的数组，只读。

// childNodes
var root = Parser.parse([[a]]b'),
	{firstChild, lastChild} = root;
assert.equal(firstChild, '[[a]]');
assert.equal(lastChild, 'b');
assert.deepStrictEqual(root.childNodes, [firstChild, lastChild]);
assert.deepStrictEqual(lastChild.childNodes, []);

firstChild

✅ 展开

type: AstNode
首位子节点，只读。

// firstChild
var root = Parser.parse('a'),
	{firstChild} = root;
assert.equal(firstChild, 'a');
assert.strictEqual(firstChild.firstChild, undefined);

lastChild

✅ 展开

type: AstNode
末位子节点，只读。

// lastChild
var root = Parser.parse('a'),
	{lastChild} = root;
assert.equal(lastChild, 'a');
assert.strictEqual(lastChild.lastChild, undefined);

parentNode

✅ 展开

type: Token
父节点，只读。

// parentNode
var root = Parser.parse('a'),
	{firstChild} = root;
assert.equal(firstChild, 'a');
assert.strictEqual(firstChild.parentNode, root);
assert.strictEqual(root.parentNode, undefined);

nextSibling

✅ 展开

type: AstNode
后一个兄弟节点，只读。

// nextSibling
var {firstChild, lastChild} = Parser.parse([[a]]b');
assert.equal(firstChild, '[[a]]');
assert.equal(lastChild, 'b');
assert.strictEqual(firstChild.nextSibling, lastChild);
assert.strictEqual(lastChild.nextSibling, undefined);

previousSibling

✅ 展开

type: AstNode
前一个兄弟节点，只读。

// previousSibling
var {firstChild, lastChild} = Parser.parse([[a]]b');
assert.equal(firstChild, '[[a]]');
assert.equal(lastChild, 'b');
assert.strictEqual(lastChild.previousSibling, firstChild);
assert.strictEqual(firstChild.previousSibling, undefined);

offsetHeight

✅ 展开

type: number
行数，只读。

// offsetHeight
var root = Parser.parse('a\nb');
assert.strictEqual(root.offsetHeight, 2);

offsetWidth

✅ 展开

type: number
最后一行的列数，只读。

// offsetWidth
var root = Parser.parse('ab\nc');
assert.strictEqual(root.offsetWidth, 1);

nextElementSibling

展开

type: Token
后一个非文本兄弟节点，只读。

// nextElementSibling (main)
var {childNodes: [a, b, c]} = Parser.parse([[a]]b{{c}}');
assert.equal(a, '[[a]]');
assert.equal(b, 'b');
assert.equal(c, '{{c}}');
assert.strictEqual(a.nextElementSibling, c);
assert.strictEqual(b.nextElementSibling, c);
assert.strictEqual(c.nextElementSibling, undefined);

previousElementSibling

展开

type: Token
前一个非文本兄弟节点，只读。

// previousElementSibling (main)
var {childNodes: [a, b, c]} = Parser.parse([[a]]b{{c}}');
assert.equal(a, '[[a]]');
assert.equal(b, 'b');
assert.equal(c, '{{c}}');
assert.strictEqual(c.previousElementSibling, a);
assert.strictEqual(b.previousElementSibling, a);
assert.strictEqual(a.previousElementSibling, undefined);

nextVisibleSibling

展开

type: AstNode
后一个可见的兄弟节点，只读。

// nextVisibleSibling (main)
var {firstChild, lastChild} = Parser.parse([[a]]<!--b--><noinclude>c');
assert.equal(firstChild, '[[a]]');
assert.equal(lastChild, 'c');
assert.strictEqual(firstChild.nextVisibleSibling, lastChild);

previousVisibleSibling

展开

type: AstNode
前一个可见的兄弟节点，只读。

// previousVisibleSibling (main)
var {firstChild, lastChild} = Parser.parse('a<!--b--><noinclude>{{c}}');
assert.equal(firstChild, 'a');
assert.equal(lastChild, '{{c}}');
assert.strictEqual(lastChild.previousVisibleSibling, firstChild);

isConnected

展开

type: boolean
是否具有根节点，只读。

// isConnected (main)
var root = Parser.parse('a'),
	{firstChild} = root;
assert(root.isConnected);
assert(firstChild.isConnected);
firstChild.remove();
assert(!firstChild.isConnected);
root.append(firstChild);
assert(firstChild.isConnected);

eof

展开

type: boolean
后方是否还有其他节点（不含后代），只读。

// eof (main)
var root = Parser.parse('a[[b]]\n'),
	{firstChild, firstElementChild} = root,
	{lastChild} = firstElementChild;
assert.equal(firstChild, 'a');
assert.equal(firstElementChild, '[[b]]');
assert.equal(lastChild, 'b');
assert(root.eof);
assert(!firstChild.eof);
assert(firstElementChild.eof); // 忽略末尾的空白字符
assert(lastChild.eof);

offsetTop

展开

type: number
相对于父容器的行号（从 0 开始计数），只读。

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

offsetLeft

展开

type: number
相对于父容器的列号（从 0 开始计数），只读。

// offsetLeft (main)
var root = Parser.parse([[a]]\nb'),
	{firstChild, lastChild} = root;
assert.equal(firstChild, '[[a]]');
assert.strictEqual(root.offsetLeft, 0);
assert.strictEqual(firstChild.offsetLeft, 0);
assert.strictEqual(lastChild.offsetLeft, 5);

style

展开

type: {top: number, left: number, height: number, width: number, padding: number}
位置、大小和 padding，只读。

// style (main)
var root = Parser.parse('a\n[[b]]'),
	{firstChild, lastChild} = root;
assert.equal(lastChild, '[[b]]');
assert.deepStrictEqual(root.style, {
	top: 0,
	left: 0,
	height: 2,
	width: 5,
	padding: 0,
});
assert.deepStrictEqual(firstChild.style, {
	top: 0,
	left: 0,
	height: 2,
	width: 0,
	padding: 0,
});
assert.deepStrictEqual(lastChild.style, {
	top: 1,
	left: 0,
	height: 1,
	width: 5,
	padding: 2, // `[[`
});

font

展开

加入的版本: 1.8.0

字体样式。

// font (main)
var {
	childNodes: [, text],
	lastChild: {lastChild},
} = Parser.parse("''a'''\n'''''[//b c''d]");
assert.equal(text, "a'");
assert.equal(lastChild, "c''d");
assert.deepStrictEqual(text.font, {
	italic: true,
	bold: false,
});
assert.deepStrictEqual(lastChild.firstChild.font, {
	italic: true,
	bold: true,
});
assert.deepStrictEqual(lastChild.lastChild.font, {
	italic: false,
	bold: true,
});

bold

展开

加入的版本: 1.8.0

是否粗体。

// bold (main)
var {
	childNodes: [, text],
	lastChild: {lastChild},
} = Parser.parse("''a'''\n'''''[//b c''d]");
assert.equal(text, "a'");
assert.equal(lastChild, "c''d");
assert(text.bold === false);
assert(lastChild.firstChild.bold === true);
assert(lastChild.lastChild.bold === true);

italic

展开

加入的版本: 1.8.0

是否斜体。

// italic (main)
var {
	childNodes: [, text],
	lastChild: {lastChild},
} = Parser.parse("''a'''\n'''''[//b c''d]");
assert.equal(text, "a'");
assert.equal(lastChild, "c''d");
assert(text.italic === true);
assert(lastChild.firstChild.italic === true);
assert(lastChild.lastChild.italic === false);

Methods

getRootNode

✅ 展开

returns: Token
获取根节点。

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

posFromIndex

✅ 展开

param: number 字符位置
returns: {top: number, left: number}
将字符位置转换为行列号。

// posFromIndex
var root = Parser.parse('a\nb');
assert.deepStrictEqual(root.posFromIndex(3), {top: 1, left: 1});
assert.strictEqual(root.posFromIndex(4), undefined);

getRelativeIndex

✅ 展开

returns: number
获取指定子节点（或当前节点自身）相对于其父节点的字符位置。

// getRelativeIndex
var root = Parser.parse('a[[b]]'),
	{lastChild} = root,
	{firstChild} = lastChild;
assert.equal(lastChild, '[[b]]');
assert.equal(firstChild, 'b');
assert.strictEqual(root.getRelativeIndex(), 0);
assert.strictEqual(root.getRelativeIndex(0), 0);
assert.strictEqual(root.getRelativeIndex(1), 1);
assert.strictEqual(root.getRelativeIndex(2), 6);
assert.strictEqual(lastChild.getRelativeIndex(), 1);
assert.strictEqual(lastChild.getRelativeIndex(0), 2);
// delimiter `|` is required to append a second child node
assert.strictEqual(lastChild.getRelativeIndex(1), 4);
assert.strictEqual(firstChild.getRelativeIndex(), 2);
assert.strictEqual(firstChild.getRelativeIndex(0), 0);

getAbsoluteIndex

✅ 展开

returns: number
获取当前节点的绝对位置。

// getAbsoluteIndex
var root = Parser.parse('a[[b]]'),
	{lastChild} = root,
	{firstChild} = lastChild;
assert.equal(lastChild, '[[b]]');
assert.equal(firstChild, 'b');
assert.strictEqual(root.getAbsoluteIndex(), 0);
assert.strictEqual(lastChild.getAbsoluteIndex(), 1);
assert.strictEqual(firstChild.getAbsoluteIndex(), 3);

is

✅ 展开

加入的版本：1.10.0

param: string Node type
returns: boolean
判断是否是指定类型的节点。

// is
var root = Parser.parse('a');
assert(root.is('root'));
assert(!root.firstChild.is('link'));

isEqualNode

展开

param: AstNode 待比较的节点
returns: boolean
是否是全同节点。

// isEqualNode (main)
var a = Parser.parse('[[a]]'),
	b = Parser.parse('[[a]]'),
	c = Parser.parse('[[ a]]'),
	d = a.firstChild,
	e = Parser.parse('<!--[[a]]-->').firstChild.firstChild,
	f = Parser.parse('[[a]]', true);
assert.equal(d, '[[a]]');
assert.equal(e, '[[a]]');
assert(a.isEqualNode(b));
assert(!a.isEqualNode(c));
assert(!a.isEqualNode(d));
assert(!a.isEqualNode(e));
assert(a.isEqualNode(f));
assert(!d.isEqualNode(e));

after

展开

param: AstNode | string 插入节点
在后方批量插入兄弟节点。

// after (main)
var root = Parser.parse('a'),
	{firstChild} = root;
firstChild.after('b', 'c');
assert.equal(root, 'abc');

before

展开

param: AstNode | string 插入节点
在前方批量插入兄弟节点。

// before (main)
var root = Parser.parse('a'),
	{firstChild} = root;
firstChild.before('b', 'c');
assert.equal(root, 'bca');

remove

展开

移除当前节点。

// remove (main)
var root = Parser.parse('[[a|b]]'),
	{firstChild} = root,
	{lastChild} = firstChild;
assert.equal(firstChild, '[[a|b]]');
assert.equal(lastChild, 'b');
lastChild.remove();
assert.equal(root, '[[a]]');
firstChild.remove();
assert.equal(root, '');

replaceWith

展开

param: AstNode | string 插入节点
将当前节点批量替换为新的节点。

// replaceWith (main)
var root = Parser.parse('a'),
	{firstChild} = root;
firstChild.replaceWith('b', 'c');
assert.equal(root, 'bc');

contains

展开

param: AstNode 待检测节点
是否是自身或后代节点。

// contains (main)
var root = Parser.parse('a'),
	{firstChild} = root;
assert(root.contains(root));
assert(root.contains(firstChild));
assert(!firstChild.contains(root));

addEventListener

展开

param: string | string[] 事件类型
param: Function 监听函数
param: {once?: boolean} 选项
添加事件监听。需搭配 dispatchEvent 方法使用。

// addEventListener (main)
var root = Parser.parse(''),
	counter = 0;
var listener = (_, data) => {
	counter += data;
};
root.addEventListener('x', listener);
root.addEventListener('y', listener, {once: true});
root.dispatchEvent(new Event('x'), 1);
assert.strictEqual(counter, 1);
root.dispatchEvent(new Event('x'), 2);
assert.strictEqual(counter, 3);
root.dispatchEvent(new Event('y'), 3);
assert.strictEqual(counter, 6);
root.dispatchEvent(new Event('y'), 4);
assert.strictEqual(counter, 6);

removeEventListener

展开

param: string | string[] 事件类型
param: Function 监听函数
移除事件监听。

// removeEventListener (main)
var root = Parser.parse(''),
	counter = 0;
var listener = () => {
	counter++;
};
root.addEventListener('x', listener);
root.dispatchEvent(new Event('x'));
assert.strictEqual(counter, 1);
root.removeEventListener('x', listener);
root.dispatchEvent(new Event('x'));
assert.strictEqual(counter, 1);

removeAllEventListeners

展开

param: string | string[] 事件类型
移除事件的所有监听。

// removeAllEventListeners (main)
var root = Parser.parse(''),
	counter = 0;
var f = () => {
	counter++;
};
var g = () => {
	counter += 2;
};
root.addEventListener('x', f);
root.addEventListener('x', g);
root.dispatchEvent(new Event('x'));
assert.strictEqual(counter, 3);
root.removeAllEventListeners('x');
root.dispatchEvent(new Event('x'));
assert.strictEqual(counter, 3);

listEventListeners

展开

param: string 事件类型
列举事件监听。

// listEventListeners (main)
var {firstChild} = Parser.parse('[[a]]'),
	listeners = firstChild.listEventListeners('remove');
assert.strictEqual(listeners.length, 1);
assert.strictEqual(listeners[0].name, 'linkListener'); // 解析器预置的监听函数

dispatchEvent

展开

param: Event 事件对象
param: any 事件数据
触发事件。

// dispatchEvent (main)
var root = Parser.parse('a'),
	{firstChild} = root,
	record = '';
var listener = ({target, currentTarget, prevTarget}) => {
	record += `${target.type} ${currentTarget.type} ${prevTarget?.type}\n`;
};
root.addEventListener('x', listener, {once: true});
firstChild.addEventListener('x', listener);
firstChild.dispatchEvent(new Event('x', {bubbles: true}));
assert.strictEqual(record, 'text text undefined\ntext root text\n');
firstChild.dispatchEvent(new Event('x', {bubbles: true}));
assert.strictEqual(
	record,
	'text text undefined\ntext root text\ntext text undefined\n',
);

getAncestors

展开

returns: Token[]
获取所有祖先节点（自下而上）。

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

compareDocumentPosition

展开

param: AstNode
returns: number
比较和另一个节点的相对位置。

// compareDocumentPosition (main)
var root = Parser.parse([[a]]b'),
	{firstElementChild, lastChild} = root,
	{firstChild} = firstElementChild;
assert.equal(firstElementChild, '[[a]]');
assert.equal(firstChild, 'a');
assert.strictEqual(root.compareDocumentPosition(root), 0);
assert(root.compareDocumentPosition(firstChild) < 0);
assert(firstChild.compareDocumentPosition(root) > 0);
assert(firstElementChild.compareDocumentPosition(lastChild) < 0);
assert(lastChild.compareDocumentPosition(firstElementChild) > 0);
assert(firstChild.compareDocumentPosition(lastChild) < 0);
assert(lastChild.compareDocumentPosition(firstChild) > 0);

indexFromPos

展开

param: number 行号
param: number 列号
returns: number
将字符位置转换为行列号。

// indexFromPos (main)
var root = Parser.parse('a\nb');
assert.strictEqual(root.indexFromPos(0, 0), 0);
assert.strictEqual(root.indexFromPos(0, 1), 1);
assert.strictEqual(root.indexFromPos(1, 0), 2);
assert.strictEqual(root.indexFromPos(1, 1), 3);
assert.strictEqual(root.indexFromPos(2, 0), undefined);

getBoundingClientRect

展开

returns: {top: number, left: number, height: number, width: number}
获取当前节点的行列位置和大小。

// getBoundingClientRect (main)
var {firstChild, lastChild} = Parser.parse('a\n[[b]]');
assert.equal(lastChild, '[[b]]');
assert.deepStrictEqual(firstChild.getBoundingClientRect(), {
	top: 0,
	left: 0,
	height: 2,
	width: 0,
});
assert.deepStrictEqual(lastChild.getBoundingClientRect(), {
	top: 1,
	left: 0,
	height: 1,
	width: 5,
});

destroy

展开

销毁节点。会连锁销毁所有祖先节点，所以使用前请先使用 remove 方法从父节点上剥离。

getLine

展开

param: number 行号
returns: string
获取某一行的源文本。

// getLine (main)
assert.strictEqual(Parser.parse('a\nb').getLine(1), 'b');