Protected_isProtectedclientOptionaldataProtectedprefixProtectedtransportStatic ReadonlycaptureStaticcapture设置或获取所有发射器的默认 captureRejection 值。
StaticdefaultStatic Readonlyerror此符号用于安装仅用于监视 'error' 事件的侦听器。使用此符号安装的侦听器在调用常规 'error' 侦听器之前被调用。
使用此符号安装侦听器不会在发出 'error' 事件后更改行为，因此如果未安装常规 'error' 侦听器，则进程仍会崩溃。
检索 nvim API 信息
获取当前缓冲区
缓冲区句柄
设置当前缓冲区
获取有关所有打开通道的信息
通道数组
获取定义的颜色映射
颜色映射
获取缓冲区本地 |user-commands| 的映射。
更改全局工作目录
目录路径
获取当前行
当前行字符串
设置当前行
行内容
获取当前模式。|mode()| "blocking" 为 true 表示 Nvim 正在等待输入。
模式信息
getNamespaces() 的别名
获取 "runtimepath" 中包含的路径
路径列表
获取窗口标签页
包含窗口的标签页
设置当前标签页
获取一个代表已附加 UI 的字典列表。
UI 字典数组 每个字典都有以下键： "height" UI 的请求高度 "width" UI 的请求宽度 "rgb" UI 是否使用 rgb 颜色（false 表示 cterm 颜色） "ext_..." 请求的 UI 扩展，参见 |ui-options| "chan" 远程 UI 的通道 ID（对于 TUI 不存在）
获取当前窗口
窗口句柄
设置当前窗口
窗口句柄
同步调用为名为 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() 最多将从侦听器数组中删除侦听器的单个实例。如果同一个侦听器已多次添加到指定 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一个类方法，返回为给定的eventName注册到给定的emitter上的监听器数量。
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就会被fulfilled，如果EventEmitter在等待时发出'error'，则该Promise会被rejected。该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
Neovim API