php_timers_promise_async_await_thread

THIMERS, promesse, asynchrone, attendre et fil parallèle (RPC)

Guide à usage complet sur YouTube

Php ^ 7.2 || ^ 8.0

 const DEVELOPER_INFO = [
    " autor " => " Matheus Johann Araújo " ,
    " country " => " Brasil " ,
    " state " => " Pernambuco " ,
    " date " => " 2022-03-12 "
];

• Le terme callback signifie la fonction passée comme un paramètre d'une fonction, qui sera appelée par une fonction. Dans PHP les callbacks sont de type callable qui signifie Chamable;

• La classe appelée Closure est chargée de représenter les fonctions anonymes et arrow functions (fonctions de flèche);

• callback est généralement des fonctions anonymes (fonctions anonymes ou flèches) qui sont transmises par paramètre, mais rien empêche une fonction nommée d'être transmise sous forme de paramètre!

La bibliothèque des minuteries sert à définir des rappels qui doivent être effectués après une certaine heure, comme c'est le cas en langue javascript

Timers implémente SetInterval, setTimeout, ClearInterval et ClearTimeout:

• setInterval(callback, milliseconds) effectue la fonction de rappel dans le temps infiniment informé. La fonction renvoie un UID qui peut être utilisé dans la fonction clearInterval pour supprimer setInterval de la ligne d'exécution;

• setTimeout(callback, milliseconds) effectue l'appel de la fonction de rappel dans le temps informé de manière unique. La fonction renvoie un UID qui peut être utilisé dans la fonction clearTimeout pour supprimer le setTimeout de la ligne d'exécution;

• clearInterval(UID) complète l'exécution future de setInterval qui a l' UID informé. La fonction renvoie true (fini) ou false (n'a pas terminé ou n'a pas trouvé la tâche planifiée);

• clearTimeout(UID) finalise l'exécution future du setTimeout qui a l' UID informé. La fonction renvoie true (fini) ou false (n'a pas terminé ou n'a pas trouvé la tâche planifiée).

Utilisation de la bibliothèque des minuteries:

 <?php

// EN-US: Include at the beginning of the first file to be interpreted, on the WEB server use TICK sparingly
// PT-BR: Incluir no início do primeiro arquivo a ser interpretado, no servidor WEB use o TICK com moderação
declare (ticks= 1 );

require_once " lib/code.php " ;

echo " Start " , PHP_EOL ;

$ counter = 1 ;

$ uid = setInterval ( function () use (& $ counter ) {
    echo " Counter: " , $ counter ++, PHP_EOL ;
}, 100 );

setTimeout ( function () {
    echo " Half of the increments " , PHP_EOL ;
}, 1000 );

setTimeout ( function () use ( $ uid ) {
    echo " Stopping the counter " , PHP_EOL ;
    clearInterval ( $ uid );
}, 2000 );

echo " Processing... " , PHP_EOL ;

// EN-US: Include after timed calls
// PT-BR: Incluir após chamadas programadas (agendadas)
$ count = workWait ( function () { usleep ( 1 ); });
echo " workRun has been run $ {count} times " , PHP_EOL ;

echo " End " , PHP_EOL ;

Remarque: La bibliothèque des minuteries permet de mettre à l'échelle l'utilisation du noyau de traitement, donnant l'impression que l'exécution du code est en mode "asynchrone", mais tout se produit de manière synchrone.

Promise est une bibliothèque qui met en œuvre le modèle d'exploitation de Promise en JavaScript .

• then(callback) appelée lorsque la promesse est résolue. callback sera exécuté et recevra en tant que paramètre, la valeur transmise sur la fonction resolve ;

• Méthode catch(callback) appelé lorsque la promesse est rejetée. callback sera effectué et recevra en tant que paramètre, la valeur transmise sur la fonction reject ;

• finally(callback) Méthode appelée après une promesse résolue ou rejetée, qui licencie l'exécution du callback informé en tant que paramètre.

Je vois l'exemple ci-dessous comment utiliser:

 <?php

// EN-US: Include at the beginning of the first file to be interpreted, on the WEB server use TICK sparingly
// PT-BR: Incluir no início do primeiro arquivo a ser interpretado, no servidor WEB use o TICK com moderação
declare (ticks= 1 );

require_once " lib/code.php " ;

echo " Start " , PHP_EOL ;

$ promise = new Promise ( function ( $ resolve , $ reject ) {
    $ call = rand ( 0 , 1 ) ? $ resolve : $ reject ;
    setTimeout ( function () use ( $ call ) {
        $ call ( " message " );
    }, 1000 );
});

function info_promise () {
    global $ promise ;
    echo " > monitor: " , $ promise -> getMonitor (), PHP_EOL ;
    echo " > state: " , $ promise -> getState (), PHP_EOL ;
}

info_promise ();

$ promise -> then ( function ( $ result ) {
    echo " then ( $ {result} ) " , PHP_EOL ;
    info_promise ();
})-> catch ( function ( $ error ) {
    echo " catch ( $ {error} ) " , PHP_EOL ;
    info_promise ();
})-> finally ( function () {
    echo " finally " , PHP_EOL ;
    info_promise ();
});

echo " Processing... " , PHP_EOL ;
for ( $ counter = 0 ; $ counter < 10 ; $ counter ++) {
    echo " Counter: $ {counter}" , PHP_EOL ;
    usleep ( 200000 );
}

// EN-US: Include after timed calls
// PT-BR: Incluir após chamadas programadas (agendadas)
$ count = workWait ( function () { usleep ( 1 ); });
echo " workRun has been run $ {count} times " , PHP_EOL ;

echo " End " , PHP_EOL ;