TableToken

TableToken

表格。

原型属性

closed: boolean

• 表格是否闭合。

var root = Parser.parse('{|\n!a\n|-\n|b'),
    table = root.firstChild;
assert(table.closed === false);

原型方法

printLayout(): void

• 打印表格布局。

var root = Parser.parse('{|\n!rowspan=2 colspan=2| ||\n|-\n|\n|-\n| ||colspan=2|\n|}'),
    table = root.firstChild;
table.printLayout();

getRowCount(): number

• 表格的有效行数。

var root = Parser.parse('{|\n|\n|-\n|}'),
    table = root.firstChild;
assert.strictEqual(table.getRowCount(), 1); // 表格首行可以直接写在 TableToken 下，没有内容的表格行是无效行。

getNthRow(n: number): TrToken

• 第 n 个有效行。

var root = Parser.parse('{|\n|rowspan=2| ||\n|-\n|\n|}'),
    table = root.firstChild;
assert.strictEqual(table.getNthRow(0), table);
assert.strictEqual(table.getNthRow(1), table.querySelector('tr'));

表格示意
第 0 行 第 0 行 第 1 行

getNthCell(coords: {row: number, column: number}|{x: number, y: number}): TdToken

• 获取指定位置的单元格，指定位置可以基于 raw HTML 或渲染后的表格。

var root = Parser.parse('{|\n|rowspan=2 colspan=2| ||\n|-\n|\n|-\n| || ||\n|}'),
    table = root.firstChild,
    td = table.querySelector('td');
assert.strictEqual(table.getNthCell({row: 0, column: 0}), td);
assert.strictEqual(table.getNthCell({x: 1, y: 1}), td); // 该单元格跨了 2 行 2 列

(row, column)	(y, x)
(0, 0) (0, 1) (1, 0) (2, 0) (2, 1) (2, 2)	(0, 0), (0, 1) (1, 0), (1, 1) (0, 2) (1, 2) (2, 0) (2, 1) (2, 2)

getFullRow(y: number): Map<TdToken, boolean>

• 获取一行的所有单元格。

var root = Parser.parse('{|\n|rowspan=2| ||\n|-\n|\n|}'),
    table = root.firstChild,
    [a,, c] = table.querySelectorAll('td');
assert.deepStrictEqual(table.getFullRow(1), new Map([[a, false], [c, true]])); // 起始位置位于该行的单元格值为 `true`

表格	选中第 1 行
	false   true

getFullCol(x: number): Map<TdToken, boolean>

• 获取一列的所有单元格。

var root = Parser.parse('{|\n|colspan=2|\n|-\n| ||\n|}'),
    table = root.firstChild,
    [a,, c] = table.querySelectorAll('td');
assert.deepStrictEqual(table.getFullCol(1), new Map([[a, false], [c, true]])); // 起始位置位于该列的单元格值为 `true`

表格	选中第 1 列
	false   true

formatTableRow(y: number, attr: string|Record<string, string|boolean>, multiRow?: boolean = false): void

• 批量设置一行单元格的属性。

var root = Parser.parse('{|\n|rowspan=2| ||\n|-\n|\n|}'),
    table = root.firstChild;
table.formatTableRow(1, 'th'); // `multiRow` 为假时忽略起始位置不在该行的单元格
assert.strictEqual(root.toString(), '{|\n|rowspan=2| ||\n|-\n!\n|}');

原表格	将第 1 行设为<th> multiRow = false	将第 1 行设为<th> multiRow = true
td td td	td td th	th td th

formatTableCol(x: number, attr: string|Record<string, string|boolean>, multiCol?: boolean = false): void

• 批量设置一列单元格的属性。

var root = Parser.parse('{|\n|colspan=2|\n|-\n| ||\n|}'),
    table = root.firstChild;
table.formatTableCol(1, 'th', true); // `multiCol` 为真时包含起始位置不在该列的单元格
assert.strictEqual(root.toString(), '{|\n!colspan=2|\n|-\n| \n!\n|}');

原表格	将第 1 列设为<th> multiCol = false	将第 1 列设为<th> multiCol = true
td td td	td td th	th td th

fillTableRow(y: number, inner: string, subtype?: 'td'|'th' = 'td', attr?: Record<string, string>): void

• 填补表格行中缺失的单元格。

var root = Parser.parse('{|\n|a||rowspan=2|b||c\n|-\n|d\n|}'),
    table = root.firstChild;
table.fillTableRow(1, 'e', 'th', {class: 'missing'});
assert.strictEqual(root.toString(), '{|\n|a||rowspan=2|b||c\n|-\n|d\n!class="missing"|e\n|}');

原表格	填补第 1 行
a b c d	a b c d e

fillTable(inner: string, subtype?: 'td'|'th' = 'td', attr?: Record<string, string>): void

• 填补表格中缺失的单元格。

var root = Parser.parse('{|\n|a||rowspan=2|b||rowspan=3|c||d\n|-\n|e\n|-\n|f\n|}'),
    table = root.firstChild;
table.fillTable('g', 'th');
assert.strictEqual(root.toString(), '{|\n|a||rowspan=2|b||rowspan=3|c||d\n|-\n|e\n!g\n|-\n|f\n!g\n!g\n|}');

原表格	填补后
a b c d e f	a b c d e g f g g

insertTableRow(row: number, attr: Record<string, string|boolean>, inner?: string, subtype?: 'td'|'th' = 'td', innerAttr?: Record<string, string|boolean>): TrToken

• 插入空行或一行单元格。

var root = Parser.parse('{|\n|a||rowspan=2|b||c\n|-\n|d||e\n|}'),
    table = root.firstChild;
table.insertTableRow(1, {class: 'tr'}); // 不填写 `inner` 等后续参数时会插入一个空行，且此时是无效行。
table.insertTableRow(1, {}, 'f', 'th', {class: 'th'});
assert.strictEqual(root.toString(), '{|\n|a||rowspan="3"|b||c\n|-class="tr"\n|-\n!class="th"|f\n!class="th"|f\n|-\n|d||e\n|}');

原表格	插入 1 行
a b c d e	a b c f f d e

insertTableCol(x: number, inner: string, subtype?: 'td'|'th' = 'td', attr?: Record<string, string|boolean>): void

• 插入一列单元格。

var root = Parser.parse('{|\n|colspan=2|a\n|-\n|b||c\n|}'),
    table = root.firstChild;
table.insertTableCol(1, 'd', 'th', {class: 'th'});
assert.strictEqual(root.toString(), '{|\n|colspan="3"|a\n|-\n|b\n!class="th"|d\n|c\n|}');

原表格	插入 1 列
a b c	a b d c

insertTableCell(inner: string, coords: {row: number, column: number}|{x: number, y: number}, subtype?: 'td'|'th' = 'td', attr?: Record<string, string|boolean>): TdToken

• 插入一个单元格。

var root = Parser.parse('{|\n|rowspan=2 colspan=2|a||b\n|-\n|c\n|-\n|d||e||f\n|}'),
    table = root.firstChild;
table.insertTableCell('g', {row: 0, column: 2}, 'th');
table.insertTableCell('h', {x: 2, y: 1}, 'th', {rowspan: 2});
assert.strictEqual(root.toString(), '{|\n|rowspan=2 colspan=2|a||b\n!g\n|-\n!rowspan="2"|h\n|c\n|-\n|d||e||f\n|}');

原表格	插入 2 格
a b c d e f	a b g h c d e f

removeTableRow(y: number): TrToken

• 删除一行。

var root = Parser.parse('{|\n|rowspan=2|a||b||c\n|-\n!rowspan=2 class="th"|d||e\n|-\n|f||g\n|}'),
    table = root.firstChild;
table.removeTableRow(1);
assert.strictEqual(root.toString(), '{|\n|a||b||c\n|-\n|f\n!class="th"|\n|g\n|}'); // 自动调整跨行单元格的 rowspan

原表格	删除第 1 行
a b c d e f g	a b c f g

removeTableCol(x: number): void

• 删除一列。

var root = Parser.parse('{|\n|colspan=2|a||b\n|-\n|c\n!colspan=2 class="th"|d\n|-\n|e\n!f\n|g\n|}'),
    table = root.firstChild;
table.removeTableCol(1);
assert.strictEqual(root.toString(), '{|\n|a||b\n|-\n|c\n! class="th"|\n|-\n|e\n|g\n|}'); // 自动调整跨列单元格的 colspan

原表格	删除第 1 列
a b c d e f g	a b c e g

mergeCells(xlim: [number, number], ylim: [number, number]): TdToken

• 合并单元格。

var root = Parser.parse('{|\n!a\n|b||c\n|-\n|d||e||f\n|-\n|g||h||i\n|}'),
    table = root.firstChild;
table.mergeCells([0, 2], [0, 2]); // 被合并的单元格的属性和内部文本均会丢失
assert.strictEqual(root.toString(), '{|\n!rowspan="2" colspan="2"|a\n|c\n|-\n|f\n|-\n|g||h||i\n|}');

原表格	合并单元格
a b c d e f g h i	a c f g h i

splitIntoRows(coords: {row: number, column: number}|{x: number, y: number}): void

• 将单元格分裂到不同行。

var root = Parser.parse('{|\n|a||b\n!rowspan=3|c\n|-\n|d\n|-\n|e||f\n|}'),
    table = root.firstChild;
table.splitIntoRows({x: 2, y: 0});
assert.strictEqual(root.toString(), '{|\n|a||b\n!c\n|-\n|d\n|-\n|e||f\n!\n|}'); // 第 1 行由于缺失第 1 列的单元格，分裂后的第 2 列不会保留

原表格	按行分裂单元格
a b c d e f	a b c d e f

splitIntoCols(coords: {row: number, column: number}|{x: number, y: number}): void

• 将单元格分裂到不同列。

var root = Parser.parse('{|\n!colspan=2 class="th"|a\n|}'),
    table = root.firstChild;
table.splitIntoCols({x: 1, y: 0});
assert.strictEqual(root.toString(), '{|\n! class="th"|a\n!class="th"|\n|}'); // 分裂继承属性

原表格	按列分裂单元格
a	a

splitIntoCells(coords: {row: number, column: number}|{x: number, y: number}): void

• 将单元格分裂成最小单元格。

var root = Parser.parse('{|\n!rowspan=2 colspan=2|a\n|b\n|-\n|c\n|-\n|d||e||f\n|}'),
    table = root.firstChild;
table.splitIntoCells({x: 0, y: 0});
assert.strictEqual(root.toString(), '{|\n! |a\n!\n|b\n|-\n!\n!\n|c\n|-\n|d||e||f\n|}');

原表格	分裂单元格
a b c d e f	a b c d e f

replicateTableRow(row: number): TrToken

• 复制一行并插入该行之前

var root = Parser.parse('{|\n|rowspan=2|a||b||c\n|-\n!rowspan=2|d||e\n|-\n|f||g\n|}'),
    table = root.firstChild;
table.replicateTableRow(1);
assert.strictEqual(root.toString(), '{|\n|rowspan="3"|a||b||c\n|-\n!d||e\n|-\n!rowspan=2|d||e\n|-\n|f||g\n|}'); // 复制行内的单元格`rowspan`总是为1

原表格	复制第 1 行
a b c d e f g	a b c d e d e f g

replicateTableCol(x: number): TdToken[]

• 复制一列并插入该列之前

var root = Parser.parse('{|\n|colspan=2|a||b\n|-\n|c\n!colspan=2|d\n|-\n|e\n!f\n|g\n|}'),
    table = root.firstChild;
table.replicateTableCol(1);
assert.strictEqual(root.toString(), '{|\n|colspan="3"|a||b\n|-\n|c\n!d\n!colspan=2|d\n|-\n|e\n!f\n!f\n|g\n|}'); // 复制列内的单元格`colspan`总是为1

原表格	复制第 1 列
a b c d e f g	a b c d d e f f g

moveTableRowBefore(y: number, before: number): TrToken

• 移动表格行。

var root = Parser.parse('{|\n|rowspan=2|a||b||c||d\n|-\n|colspan=2|e||f\n|-\n|rowspan=2|g||h||i||j\n|-\n!rowspan=2|k||colspan=2|l\n|-\n|m||n||o\n|}'),
    table = root.firstChild;
table.moveTableRowBefore(3, 1);
assert.strictEqual(root.toString(), '{|\n|rowspan="3"|a||b||c||d\n|-\n!k||colspan=2|l\n|-\n|colspan=2|e||f\n|-\n|g||h||i||j\n|-\n|m\n!\n|n||o\n|}');

原表格	移动第 3 行至第 1 行前
a b c d e f g h i j k l m n o	a b c d k l e f g h i j m n o

moveTableRowAfter(y: number, after: number): TrToken

• 移动表格行。

var root = Parser.parse('{|\n|rowspan=2|a||colspan=2|b||c\n|-\n|d||e||f\n|-\n|rowspan=2|g||h||i||j\n|-\n!rowspan=2|k||colspan=2|l\n|-\n|m||n||o\n|}'),
    table = root.firstChild;
table.moveTableRowAfter(3, 0);
assert.strictEqual(root.toString(), '{|\n|rowspan="3"|a||colspan=2|b||c\n|-\n!k||colspan=2|l\n|-\n|d||e||f\n|-\n|g||h||i||j\n|-\n|m\n!\n|n||o\n|}');

原表格	移动第 3 行至第 0 行后
a b c d e f g h i j k l m n o	a b c k l d e f g h i j m n o

moveTableColBefore(x: number, before: number): void

• 移动表格列。

var root = Parser.parse('{|\n|colspan=2|a||colspan=2|b||c\n|-\n|d||rowspan=2|e||f\n!colspan=2|g\n|-\n|h||i\n!rowspan=2|j\n|k\n|-\n|l||m||n||o\n|}'),
    table = root.firstChild;
table.moveTableColBefore(3, 1);
assert.strictEqual(root.toString(), '{|\n|colspan="3"|a||b||c\n|-\n|d\n!g\n|rowspan=2|e||f\n!\n|-\n|h\n!rowspan=2|j\n|i\n|k\n|-\n|l||m||n||o\n|}');

原表格	移动第 3 列至第 1 列前
a b c d e f g h i j k l m n o	a b c d g e f h j i k l m n o

moveTableColAfter(x: number, after: number): void

• 移动表格列。

var root = Parser.parse('{|\n|colspan=2|a||colspan=2|b||c\n|-\n|rowspan=2|d||e||f\n!colspan=2|g\n|-\n|h||i\n!rowspan=2|j\n|k\n|-\n|l||m||n||o\n|}'),
    table = root.firstChild;
table.moveTableColAfter(3, 0);
assert.strictEqual(root.toString(), '{|\n|colspan="3"|a||b||c\n|-\n|rowspan=2|d\n!g\n|e||f\n!\n|-\n!rowspan=2|j\n|h||i\n|k\n|-\n|l||m||n||o\n|}');

原表格	移动第 3 列至第 0 列后
a b c d e f g h i j k l m n o	a b c d g e f j h i k l m n o

escape(): void

• 转义表格语法。

var root = Parser.parse('{|\n!a||b\n|-\n|c\n|d\n|}'),
    table = root.firstChild;
table.escape();
assert.strictEqual(root.toString(), '{{(!}}\n!a{{!!}}b\n{{!}}-\n{{!}}c\n{{!}}d\n{{!)}}');