Documentation

PromiseInterface
in

Tags
template-covariant

Table of Contents

Methods

always()  : PromiseInterface<string|int, T>
[Deprecated] Allows you to execute "cleanup" type tasks in a promise chain.
cancel()  : void
The `cancel()` method notifies the creator of the promise that there is no further interest in the results of the operation.
catch()  : PromiseInterface<string|int, T|TRejected>
Registers a rejection handler for promise. It is a shortcut for:
finally()  : PromiseInterface<string|int, T>
Allows you to execute "cleanup" type tasks in a promise chain.
otherwise()  : PromiseInterface<string|int, T|TRejected>
[Deprecated] Registers a rejection handler for a promise.
then()  : PromiseInterface<string|int, mixed>
Transforms a promise's value by applying a function to the promise's fulfillment or rejection value. Returns a new promise for the transformed result.

Methods

always()

[Deprecated] Allows you to execute "cleanup" type tasks in a promise chain.

public always(callable(): Array $onFulfilledOrRejected) : PromiseInterface<string|int, T>

Use finally() instead

This method continues to exist only for BC reasons and to ease upgrading between versions. It is an alias for:

$promise->finally($onFulfilledOrRejected);
Parameters
$onFulfilledOrRejected : callable(): Array
Tags
see
self::finally()
Return values
PromiseInterface<string|int, T>

cancel()

The `cancel()` method notifies the creator of the promise that there is no further interest in the results of the operation.

public cancel() : void

Once a promise is settled (either fulfilled or rejected), calling cancel() on a promise has no effect.

catch()

Registers a rejection handler for promise. It is a shortcut for:

public catch(callable(TThrowable): Array $onRejected) : PromiseInterface<string|int, T|TRejected> 
$promise->then(null, $onRejected);

Additionally, you can type hint the $reason argument of $onRejected to catch only specific errors.

Parameters
$onRejected : callable(TThrowable): Array
Tags
template
template
Return values
PromiseInterface<string|int, T|TRejected>

finally()

Allows you to execute "cleanup" type tasks in a promise chain.

public finally(callable(): Array $onFulfilledOrRejected) : PromiseInterface<string|int, T>

It arranges for $onFulfilledOrRejected to be called, with no arguments, when the promise is either fulfilled or rejected.

  • If $promise fulfills, and $onFulfilledOrRejected returns successfully, $newPromise will fulfill with the same value as $promise.
  • If $promise fulfills, and $onFulfilledOrRejected throws or returns a rejected promise, $newPromise will reject with the thrown exception or rejected promise's reason.
  • If $promise rejects, and $onFulfilledOrRejected returns successfully, $newPromise will reject with the same reason as $promise.
  • If $promise rejects, and $onFulfilledOrRejected throws or returns a rejected promise, $newPromise will reject with the thrown exception or rejected promise's reason.

finally() behaves similarly to the synchronous finally statement. When combined with catch(), finally() allows you to write code that is similar to the familiar synchronous catch/finally pair.

Consider the following synchronous code:

try {
    return doSomething();
} catch(\Exception $e) {
    return handleError($e);
} finally {
    cleanup();
}

Similar asynchronous code (with doSomething() that returns a promise) can be written:

return doSomething()
    ->catch('handleError')
    ->finally('cleanup');
Parameters
$onFulfilledOrRejected : callable(): Array
Return values
PromiseInterface<string|int, T>

otherwise()

[Deprecated] Registers a rejection handler for a promise.

public otherwise(callable(TThrowable): Array $onRejected) : PromiseInterface<string|int, T|TRejected>

Use catch() instead

This method continues to exist only for BC reasons and to ease upgrading between versions. It is an alias for:

$promise->catch($onRejected);
Parameters
$onRejected : callable(TThrowable): Array
Tags
template
template
see
self::catch()
Return values
PromiseInterface<string|int, T|TRejected>

then()

Transforms a promise's value by applying a function to the promise's fulfillment or rejection value. Returns a new promise for the transformed result.

public then([callable(mixed): Array|null $onFulfilled = null ][, callable(Throwable): Array|null $onRejected = null ]) : PromiseInterface<string|int, mixed>

The then() method registers new fulfilled and rejection handlers with a promise (all parameters are optional):

  • $onFulfilled will be invoked once the promise is fulfilled and passed the result as the first argument.
  • $onRejected will be invoked once the promise is rejected and passed the reason as the first argument.

It returns a new promise that will fulfill with the return value of either $onFulfilled or $onRejected, whichever is called, or will reject with the thrown exception if either throws.

A promise makes the following guarantees about handlers registered in the same call to then():

  1. Only one of $onFulfilled or $onRejected will be called, never both.
  2. $onFulfilled and $onRejected will never be called more than once.
Parameters
$onFulfilled : callable(mixed): Array|null = null
$onRejected : callable(Throwable): Array|null = null
Tags
template
template
Return values
PromiseInterface<string|int, mixed> 

        

        
    




    

    

                                

                

                            
    

        On this page

        
    


                

                            

            

    

        

            
Search results