Yahoo Web Search

Search results

  1. Jun 26, 2015 · Using ES6 promises, how do I create a promise without defining the logic for resolving it? Here's a basic example (some TypeScript): var promises = {}; function waitFor(key: string): Promise<an...

  2. Resolving Promise without executor from outside: const promise = Promise.exposed().then(console.log); promise.resolve("This should show up in the console."); Racing with the executor's setTimeout from outside:

  3. Jan 26, 2016 · var promise = new Promise(function (resolve, reject) { /*....*/}); if (typeof cb === 'function') { promise.then(cb); } else { return promise; }

    • Overview
    • Syntax
    • Description
    • Examples
    • Browser compatibility

    The Promise.resolve() static method "resolves" a given value to a Promise. If the value is a promise, that promise is returned; if the value is a thenable, Promise.resolve() will call the then() method with two callbacks it prepared; otherwise the returned promise will be fulfilled with the value.

    This function flattens nested layers of promise-like objects (e.g. a promise that fulfills to a promise that fulfills to something) into a single layer — a promise that fulfills to a non-thenable value.

    Parameters

    value Argument to be resolved by this Promise. Can also be a Promise or a thenable to resolve.

    Return value

    A Promise that is resolved with the given value, or the promise passed as value, if the value was a promise object. A resolved promise can be in any of the states — fulfilled, rejected, or pending. For example, resolving a rejected promise will still result in a rejected promise.

    Promise.resolve() resolves a promise, which is not the same as fulfilling or rejecting the promise. See Promise description for definitions of the terminology. In brief, Promise.resolve() returns a promise whose eventual state depends on another promise, thenable object, or other value.

    Promise.resolve() is generic and supports subclassing, which means it can be called on subclasses of Promise, and the result will be a promise of the subclass type. To do so, the subclass's constructor must implement the same signature as the Promise() constructor — accepting a single executor function that can be called with the resolve and reject callbacks as parameters.

    Promise.resolve() special-cases native Promise instances. If value belongs to Promise or a subclass, and value.constructor === Promise, then value is directly returned by Promise.resolve(), without creating a new Promise instance. Otherwise, Promise.resolve() is essentially a shorthand for new Promise((resolve) => resolve(value)).

    The bulk of the resolving logic is actually implemented by the resolve function passed by the Promise() constructor. In summary:

    •If a non-thenable value is passed, the returned promise is already fulfilled with that value.

    •If a thenable is passed, the returned promise will adopt the state of that thenable by calling the then method and passing a pair of resolving functions as arguments. (But because native promises directly pass through Promise.resolve() without creating a wrapper, the then method is not called on native promises.) If the resolve function receives another thenable object, it will be resolved again, so that the eventual fulfillment value of the promise will never be thenable.

    Using the static Promise.resolve method
    Resolving an array
    Resolving another Promise
    Promise.resolve() reuses existing Promise instances. If it's resolving a native promise, it returns the same promise instance without creating a wrapper. The inverted order of the logs is due to the fact that the then handlers are called asynchronously. See the then() reference for more information.
    Resolving thenables and throwing Errors
    Nested thenables will be "deeply flattened" to a single promise.

    BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

  4. Dec 15, 2020 · let promise = new Promise(function(resolve, reject) { // Make an asynchronous call and either resolve or reject }); In most cases, a promise may be used for an asynchronous operation. However, technically, you can resolve/reject on both synchronous and asynchronous operations.

    • how to resolve a promise in javascript without1
    • how to resolve a promise in javascript without2
    • how to resolve a promise in javascript without3
    • how to resolve a promise in javascript without4
    • how to resolve a promise in javascript without5
  5. Oct 7, 2024 · The promise constructor takes an executor function that lets us resolve or reject a promise manually. Since setTimeout() doesn't really fail, we left out reject in this case. For more information on how the executor function works, see the Promise() reference.

  6. People also ask

  7. Oct 7, 2024 · Promise.resolve() Returns a Promise object that is resolved with the given value. If the value is a thenable (i.e. has a then method), the returned promise will "follow" that thenable, adopting its eventual state; otherwise, the returned promise will be fulfilled with the value. Promise.try() Experimental

  1. People also search for