How to use where clause in Knex
Create refunds with Stripe
Load HTML with Cheerio
How to send POST request with Axios
Find intersection of array in Lodash
Powered by Official white Bloop logo with a period

Terms / Privacy / Search / Support

  • class MyAsyncCallbacks {
      init(asyncId, type, triggerAsyncId, resource) { }
      destroy(asyncId) {}
    class MyAddedCallbacks extends MyAsyncCallbacks {
      before(asyncId) { }
      after(asyncId) { }
    const asyncHook = async_hooks.createHook(new MyAddedCallbacks());
  • const async_hooks = require('async_hooks');
    const asyncHook = async_hooks.createHook({
      init(asyncId, type, triggerAsyncId, resource) { },
      destroy(asyncId) { }
  • import { createHook } from 'async_hooks';
    const asyncHook = createHook({
      init(asyncId, type, triggerAsyncId, resource) { },
      destroy(asyncId) { }
  • import { AsyncResource, executionAsyncId } from 'async_hooks';
    // AsyncResource() is meant to be extended. Instantiating a
    // new AsyncResource() also triggers init. If triggerAsyncId is omitted then
    // async_hook.executionAsyncId() is used.
    const asyncResource = new AsyncResource(
      type, { triggerAsyncId: executionAsyncId(), requireManualDestroy: false }
    // Run a function in the execution context of the resource. This will
    // * establish the context of the resource
    // * trigger the AsyncHooks before callbacks
    // * call the provided function `fn` with the supplied arguments
    // * trigger the AsyncHooks after callbacks
    // * restore the original execution context
    asyncResource.runInAsyncScope(fn, thisArg, ...args);
    // Call AsyncHooks destroy callbacks.
    // Return the unique ID assigned to the AsyncResource instance.
    // Return the trigger ID for the AsyncResource instance.
  • import async_hooks from 'async_hooks';
    // Return the ID of the current execution context.
    const eid = async_hooks.executionAsyncId();
    // Return the ID of the handle responsible for triggering the callback of the
    // current execution scope to call.
    const tid = async_hooks.triggerAsyncId();
    // Create a new AsyncHook instance. All of these callbacks are optional.
    const asyncHook =
        async_hooks.createHook({ init, before, after, destroy, promiseResolve });
    // Allow callbacks of this AsyncHook instance to call. This is not an implicit
    // action after running the constructor, and must be explicitly run to begin
    // executing callbacks.
    // Disable listening for new asynchronous events.
    // The following are the callbacks that can be passed to createHook().
    // init() is called during object construction. The resource may not have
    // completed construction when this callback runs. Therefore, all fields of the
    // resource referenced by "asyncId" may not have been populated.
    function init(asyncId, type, triggerAsyncId, resource) { }
    // before() is called just before the resource's callback is called. It can be
    // called 0-N times for handles (such as TCPWrap), and will be called exactly 1
    // time for requests (such as FSReqCallback).
    function before(asyncId) { }
    // after() is called just after the resource's callback has finished.
    function after(asyncId) { }
    // destroy() is called when the resource is destroyed.
    function destroy(asyncId) { }
    // promiseResolve() is called only for promise resources, when the
    // resolve() function passed to the Promise constructor is invoked
    // (either directly or through other means of resolving a promise).
    function promiseResolve(asyncId) { }
  • Powered by Official black Bloop logo with a period
    download the IDE extension

    View other examples