Protected_isProtectedclientOptionaldataProtectedtransportStatic ReadonlycaptureStaticcaptureStaticdefaultStatic Readonlyerror此符号应用于仅安装 'error' 事件的监听器。使用此符号安装的监听器在调用常规 'error' 监听器之前被调用。
使用此符号安装监听器不会更改 'error' 事件发出后的行为，因此如果未安装常规 'error' 监听器，则进程仍将崩溃。
获取缓冲区的更改时间戳
获取缓冲区的 bufnr
缓冲区中的总行数
获取缓冲区中的行
检查缓冲区是否有效且已加载。有关未加载缓冲区的更多信息，请参见 |api-buffer|。
获取缓冲区名称
设置当前缓冲区名称
当前缓冲区是否有效
向缓冲区添加高亮。
对于动态生成缓冲区高亮（例如语义高亮或代码分析）的插件非常有用。该函数向缓冲区添加单个高亮。与 |matchaddpos()| 不同，高亮会随着行号更改而变化（例如，在高亮行上方插入/删除行），就像符号和标记一样。
命名空间用于批量删除/更新一组高亮。要创建命名空间，请使用 |nvim_create_namespace|，它会返回一个命名空间 ID。将其作为 ns_id 传递给此函数，以向命名空间添加高亮。然后，可以使用单个 |nvim_buf_clear_namespace| 调用来清除同一命名空间中的所有高亮。如果高亮永远不会通过 API 调用被删除，请传递 ns_id = -1。
作为简写，ns_id = 0 可用于为高亮创建新的命名空间，然后返回分配的 ID。如果 hl_group 是空字符串，则不会添加高亮，但仍然会返回新的 ns_id。这支持向后兼容性，新代码应使用 |nvim_create_namespace| 创建新的空命名空间。
同步调用为名为 eventName 的事件注册的每个侦听器，以注册顺序，将提供的参数传递给每个侦听器。
如果事件有侦听器，则返回 true，否则返回 false。
const EventEmitter = require('events');
const myEmitter = new EventEmitter();
// First listener
myEmitter.on('event', function firstListener() {
console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
const parameters = args.join(', ');
console.log(`event with parameters ${parameters} in third listener`);
});
console.log(myEmitter.listeners('event'));
myEmitter.emit('event', 1, 2, 3, 4, 5);
// Prints:
// [
// [Function: firstListener],
// [Function: secondListener],
// [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener
Rest...args: any[]返回一个数组，列出发射器已为其注册侦听器的事件。数组中的值是字符串或 Symbol。
const EventEmitter = require('events');
const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});
const sym = Symbol('symbol');
myEE.on(sym, () => {});
console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]
返回 EventEmitter 的当前最大监听器值，该值由 emitter.setMaxListeners(n) 设置，或默认为 defaultMaxListeners。
将 listener 函数添加到名为 eventName 的事件的监听器数组的末尾。不会进行任何检查以查看 listener 是否已添加。多次调用传递相同 eventName 和 listener 组合会导致 listener 被添加和调用多次。
server.on('connection', (stream) => {
console.log('someone connected!');
});
返回对 EventEmitter 的引用，以便可以链接调用。
默认情况下，事件监听器按添加顺序调用。emitter.prependListener() 方法可以用作另一种添加事件监听器到监听器数组开头的替代方法。
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
// b
// a
事件的名称。
回调函数
Rest...args: any[]为名为 eventName 的事件添加一个 **一次性** listener 函数。下次触发 eventName 时，此监听器将被删除，然后调用。
server.once('connection', (stream) => {
console.log('Ah, we have our first user!');
});
返回对 EventEmitter 的引用，以便可以链接调用。
默认情况下，事件监听器按添加顺序调用。emitter.prependOnceListener() 方法可以用作另一种添加事件监听器到监听器数组开头的替代方法。
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
// b
// a
事件的名称。
回调函数
Rest...args: any[]将 listener 函数添加到名为 eventName 的事件的监听器数组的开头。不会进行任何检查以查看 listener 是否已添加。多次调用传递相同 eventName 和 listener 组合会导致 listener 被添加和调用多次。
server.prependListener('connection', (stream) => {
console.log('someone connected!');
});
返回对 EventEmitter 的引用，以便可以链接调用。
事件的名称。
回调函数
Rest...args: any[]将一个 **一次性** listener 函数添加到名为 eventName 的事件的监听器数组的开头。下次触发 eventName 时，此监听器将被删除，然后调用。
server.prependOnceListener('connection', (stream) => {
console.log('Ah, we have our first user!');
});
返回对 EventEmitter 的引用，以便可以链接调用。
事件的名称。
回调函数
Rest...args: any[]返回名为 eventName 的事件的监听器数组的副本，包括任何包装器（例如 .once() 创建的包装器）。
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));
// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];
// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();
// Logs "log once" to the console and removes the listener
logFnWrapper();
emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');
// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');
从名为 eventName 的事件的监听器数组中删除指定的 listener。
const callback = (stream) => {
console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
removeListener() 最多会从监听器数组中删除一个监听器实例。如果任何单个监听器已多次添加到指定 eventName 的监听器数组中，则必须多次调用 removeListener() 以删除每个实例。
一旦事件被发射，所有在发射时附加到它的监听器都会按顺序被调用。这意味着任何在发射后和最后一个监听器完成执行之前的 removeListener() 或 removeAllListeners() 调用都不会将它们从正在进行的 emit() 中删除。后续事件的行为按预期进行。
const myEmitter = new MyEmitter();
const callbackA = () => {
console.log('A');
myEmitter.removeListener('event', callbackB);
};
const callbackB = () => {
console.log('B');
};
myEmitter.on('event', callbackA);
myEmitter.on('event', callbackB);
// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
// A
// B
// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
// A
由于监听器是使用内部数组管理的，因此调用此方法将更改在删除的监听器之后注册的任何监听器的位置索引。这不会影响监听器被调用的顺序，但意味着 emitter.listeners() 方法返回的监听器数组的任何副本都需要重新创建。
当单个函数作为处理程序多次添加到单个事件（如以下示例）时，removeListener() 将删除最近添加的实例。在示例中，once('ping') 监听器被删除
const ee = new EventEmitter();
function pong() {
console.log('pong');
}
ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);
ee.emit('ping');
ee.emit('ping');
返回对 EventEmitter 的引用，以便可以链接调用。
Rest...args: any[]设置缓冲区行的虚拟文本（注释）。
默认情况下（也是目前唯一的选项），文本将放置在缓冲区文本之后。 虚拟文本永远不会引起回流，而是虚拟文本将在屏幕行的末尾被截断。 虚拟文本将在普通文本之后开始一个单元格（|lcs-eol| 或空格）。
命名空间用于支持虚拟文本的批处理删除/更新。 要创建命名空间，请使用 |nvim_create_namespace|。 虚拟文本使用 |nvim_buf_clear_namespace| 清除。 相同的 ns_id 可用于 |nvim_buf_add_highlight| 添加的虚拟文本和高亮显示，两者都可以通过对 |nvim_buf_clear_namespace| 的单次调用来清除。 如果虚拟文本永远不会被 API 调用清除，则传递 ns_id = -1。
作为简写，ns_id = 0 可用于为虚拟文本创建新的命名空间，分配的 ID 然后被返回。
要使用的命名空间或 0 来创建命名空间，或 -1 用于非分组注释
使用虚拟文本注释的行（从零开始索引）
一个 [text, hl_group] 数组列表，每个数组表示一个具有指定高亮的文本块。 hl_group 元素可以省略，表示不使用高亮显示。
可选参数。 目前未使用。
Staticget返回名为 事件名称 的事件的监听器数组的副本。
对于 EventEmitter，此行为与在发射器上调用 .listeners 完全相同。
对于 EventTarget，这是获取事件目标事件监听器的唯一方法。 这对于调试和诊断目的很有用。
const { getEventListeners, EventEmitter } = require('events');
{
const ee = new EventEmitter();
const listener = () => console.log('Events are fun');
ee.on('foo', listener);
getEventListeners(ee, 'foo'); // [listener]
}
{
const et = new EventTarget();
const listener = () => console.log('Events are fun');
et.addEventListener('foo', listener);
getEventListeners(et, 'foo'); // [listener]
}
Staticlistener一个类方法，它返回在给定 emitter 上注册的给定 eventName 的监听器数量。
const { EventEmitter, listenerCount } = require('events');
const myEmitter = new EventEmitter();
myEmitter.on('event', () => {});
myEmitter.on('event', () => {});
console.log(listenerCount(myEmitter, 'event'));
// Prints: 2
要查询的发射器
事件名称
Staticonconst { on, EventEmitter } = require('events');
(async () => {
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
});
for await (const event of on(ee, 'foo')) {
// The execution of this inner block is synchronous and it
// processes one event at a time (even with await). Do not use
// if concurrent execution is required.
console.log(event); // prints ['bar'] [42]
}
// Unreachable here
})();
返回一个 AsyncIterator，它迭代 eventName 事件。 如果 EventEmitter 发射 'error'，它将抛出异常。 它在退出循环时删除所有监听器。 每次迭代返回的 value 是一个数组，它由发射的事件参数组成。
AbortSignal 可用于取消等待事件
const { on, EventEmitter } = require('events');
const ac = new AbortController();
(async () => {
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
});
for await (const event of on(ee, 'foo', { signal: ac.signal })) {
// The execution of this inner block is synchronous and it
// processes one event at a time (even with await). Do not use
// if concurrent execution is required.
console.log(event); // prints ['bar'] [42]
}
// Unreachable here
})();
process.nextTick(() => ac.abort());
正在监听的事件的名称
Optionaloptions: StaticEventEmitterOptions它迭代 emitter 发射的 eventName 事件
Staticonce创建一个 Promise，当 EventEmitter 发射给定事件时，它将被实现，或者当 EventEmitter 在等待时发射 'error' 时，它将被拒绝。 Promise 将使用传递给给定事件的所有参数的数组解析。
此方法有意泛型，适用于 Web 平台 EventTarget 接口，该接口没有特殊的 'error' 事件语义，也不监听 'error' 事件。
const { once, EventEmitter } = require('events');
async function run() {
const ee = new EventEmitter();
process.nextTick(() => {
ee.emit('myevent', 42);
});
const [value] = await once(ee, 'myevent');
console.log(value);
const err = new Error('kaboom');
process.nextTick(() => {
ee.emit('error', err);
});
try {
await once(ee, 'myevent');
} catch (err) {
console.log('error happened', err);
}
}
run();
仅当 events.once() 用于等待另一个事件时，才使用对 'error' 事件的特殊处理。 如果 events.once() 用于等待 'error' 事件本身，那么它将被视为任何其他类型的事件，没有特殊处理。
const { EventEmitter, once } = require('events');
const ee = new EventEmitter();
once(ee, 'error')
.then(([err]) => console.log('ok', err.message))
.catch((err) => console.log('error', err.message));
ee.emit('error', new Error('boom'));
// Prints: ok boom
AbortSignal 可用于取消等待事件
const { EventEmitter, once } = require('events');
const ee = new EventEmitter();
const ac = new AbortController();
async function foo(emitter, event, signal) {
try {
await once(emitter, event, { signal });
console.log('event emitted!');
} catch (error) {
if (error.name === 'AbortError') {
console.error('Waiting for the event was canceled!');
} else {
console.error('There was an error', error.message);
}
}
}
foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled!
Optionaloptions: StaticEventEmitterOptionsOptionaloptions: StaticEventEmitterOptions
设置或获取所有发射器的默认 captureRejection 值。