可选logger?: Logger可选transport?: Transport受保护_is受保护client可选data受保护prefix受保护request受保护transport静态 只读capture静态capture设置或获取所有发射器的默认 captureRejection 值。
静态default静态 只读error此符号用于安装仅用于监控 'error' 事件的监听器。使用此符号安装的监听器会在调用常规 'error' 监听器之前被调用。
使用此符号安装监听器不会改变 'error' 事件发出后的行为，因此如果未安装常规 'error' 监听器，进程仍会崩溃。
检索 nvim API 信息
获取当前缓冲区
缓冲区句柄
设置当前缓冲区
获取有关所有打开的通道的信息
通道数组
获取定义的颜色映射
颜色映射
获取缓冲区局部 |user-commands| 的映射。
更改全局工作目录
目录路径
获取当前行
当前行字符串
设置当前行
行内容
获取当前模式。 |mode()| "blocking" 为 true 表示 Nvim 正在等待输入。
模式信息
getNamespaces() 的别名
获取 "runtimepath" 中包含的路径
路径列表
获取窗口标签页
包含窗口的标签页
设置当前的 tabpage
获取一个表示附加的 UI 的字典列表。
UI 字典数组 每个字典包含以下键： "height" UI 请求的高度 "width" UI 请求的宽度 "rgb" UI 是否使用 RGB 颜色（false 意味着 cterm 颜色） "ext_..." 请求的 UI 扩展，参见 |ui-options| "chan" 远程 UI 的通道 ID（在 TUI 中不存在）
获取当前窗口
窗口句柄
设置当前窗口
窗口句柄
如果缓冲区应该被分离，则返回 true
同步调用为名为 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。
从 GUI 发送鼠标事件。
调用是非阻塞的。它不等待任何结果操作，而是将事件排队以供事件循环尽快处理。
注意：目前不支持通过在循环中多次调用此方法来“脚本化”多个鼠标事件：中间鼠标位置将被忽略。它应该用于在 GUI 中实现实时鼠标输入。已弃用的伪键形式（“
鼠标按钮：其中之一为 "left"、"right"、"middle"、"wheel"。
对于普通按钮，其中之一为 "press"、"drag"、"release"。对于滚轮，其中之一为 "up"、"down"、"left"、"right"。
每个修饰符由单个字符表示的字符串。与按键相同，使用相同的规范，但“-” 分隔符是可选的，所以 "C-A-"、"c-a" 和 "CA" 都可以用来指定 Ctrl+Alt+单击。
如果客户端使用 |ui-multigrid|，则为网格编号，否则为 0。
鼠标行位置（以零为基准，就像重绘事件一样）
鼠标列位置（以零为基准，就像重绘事件一样）
将 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[]为名为 eventName 的事件添加一个_一次性_ listener 函数到侦听器数组的_开头_。下次触发 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() 最多会从侦听器数组中删除 listener 的一个实例。如果某个 listener 已多次添加到指定 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[]在补全弹出菜单中选择一个项目。
如果 |ins-completion| 未激活，此 API 调用将被静默忽略。对使用 |ui-popupmenu| 控制弹出菜单的外部 UI 很有用。也可以在映射中使用；使用
要选择的项目的索引（从零开始）。值为 -1 表示不选择任何内容并恢复原始文本。
是否应将选择插入缓冲区。
完成补全并关闭弹出菜单。意味着 insert。
可选参数。为将来使用保留。
设置当前窗口
窗口句柄
winClose 的公共别名
winConfig 的公共别名
Staticget返回名为 eventName 的事件的监听器数组的副本。
对于 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 发出给定事件时，该 Promise 将被兑现，或者如果 EventEmitter 在等待时发出 'error'，则该 Promise 将被拒绝。 该 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();
'error' 事件的特殊处理仅在使用 events.once() 等待另一个事件时使用。 如果使用 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
Neovim API