je vais mettre ceci ici comme une référence pour quiconque recherche - cela repose sur aucun javascript du tout..

<?php

/**
 * Quick and easy progress script
 * The script will slow iterate through an array and display progress as it goes.
 */

#First progress
$array1  = array(2, 4, 56, 3, 3);
$current = 0;

foreach ($array1 as $element) {
    $current++;
    outputProgress($current, count($array1));
}
echo "<br>";

#Second progress
$array2  = array(2, 4, 66, 54);
$current = 0;

foreach ($array2 as $element) {
    $current++;
    outputProgress($current, count($array2));
}

/**
 * Output span with progress.
 *
 * @param $current integer Current progress out of total
 * @param $total   integer Total steps required to complete
 */
function outputProgress($current, $total) {
    echo "<span style='position: absolute;z-index:$current;background:#FFF;'>" . round($current / $total * 100) . "% </span>";
    myFlush();
    sleep(1);
}

/**
 * Flush output buffer
 */
function myFlush() {
    echo(str_repeat(' ', 256));
    if (@ob_get_contents()) {
        @ob_end_flush();
    }
    flush();
}

?>

c'est un peu difficile, (FYI) le processus PHP et votre requête AJAX sont traités par thread séparé, donc vous ne pouvez pas obtenir la valeur $progress .

une solution rapide: vous pouvez écrire la valeur de progression à $_SESSION['some_progress'] chaque fois qu'il est mis à jour, puis votre demande AJAX peut obtenir la valeur de progression en accédant au $_SESSION['some_progress'] .

vous aurez besoin de JavaScript setInterval() ou setTimeout() pour continuer à appeler le gestionnaire AJAX, jusqu'à ce que vous obteniez le retour en tant que 100 .

il n'est pas la solution parfaite, mais sa rapide et facile.

comme vous ne pouvez pas utiliser la même session deux fois en même temps, utilisez plutôt une base de données. Écrivez l'État à une base de données et lire à partir de cela avec l'appel ajax intervalle.

c'est une vieille question mais j'avais un besoin similaire. Je voulais lancer un script avec la commande php system() et afficher la sortie.

Je l'ai fait sans sondage.

pour la deuxième affaire Rikudoit devrait être quelque chose comme ceci:

JavaScript

document.getElementById("formatRaid").onclick=function(){
    var xhr = new XMLHttpRequest();     
    xhr.addEventListener("progress", function(evt) {
        var lines = evt.currentTarget.response.split("\n");
        if(lines.length)
           var progress = lines[lines.length-1];
        else
            var progress = 0;
        document.getElementById("progress").innerHTML = progress;
    }, false);
    xhr.open('POST', "getProgress.php", true);
    xhr.send();
}

PHP

<?php 
header('Content-Type: application/octet-stream');
header('Cache-Control: no-cache'); // recommended to prevent caching of event data.

// Turn off output buffering
ini_set('output_buffering', 'off');
// Turn off PHP output compression
ini_set('zlib.output_compression', false);
// Implicitly flush the buffer(s)
ini_set('implicit_flush', true);
ob_implicit_flush(true);
// Clear, and turn off output buffering
while (ob_get_level() > 0) {
    // Get the curent level
    $level = ob_get_level();
    // End the buffering
    ob_end_clean();
    // If the current level has not changed, abort
    if (ob_get_level() == $level) break;
}   

while($progress < 100) {
    // STUFF TO DO...
    echo '\n' . $progress;
}
?>

les Solutions sont :

1. Ajax d'interrogation Sur le côté serveur de stocker les progrès quelque part et ensuite utiliser un appel ajax pour récupérer les progrès à intervalles réguliers.

2. Server sent events - une fonctionnalité html5 qui permet de générer des événements dom à partir de la sortie envoyer par le serveur. C'est la meilleure solution pour un tel cas, mais IE 10 ne le soutient pas.

3. Script / Iframe streaming-utilisez une iframe pour diffuser la sortie du script à long terme qui produirait des balises de script comme intervalles qui peuvent générer une certaine réaction dans le navigateur.

avez-vous envisagé d'extraire javascript et d'utiliser un stream flush? Il ressemblerait à quelque chose comme ceci

echo '<script type="text/javascript> update_progress('.($progress->get_progress()).');</script>';
flush();

cette sortie est envoyée immédiatement au navigateur en raison de la chasse d'eau. Faites-le périodiquement à partir du scénario à long terme et il devrait fonctionner magnifiquement.

ici je voulais juste ajouter 2 préoccupations en plus de ce que @Jarod Law a écrit au-dessus de https://stackoverflow.com/a/7049321/2012407

très simple et efficace en effet. J'ai trafiqué et utilisé :) Donc mes 2 préoccupations sont:

1. plutôt que d'utiliser setInterval() ou setTimeout() utilisez un appel récursif dans le callback comme:

   function trackProgress()
   {
       $.getJSON(window.location, 'ajaxTrackProgress=1', function(response)
       {
           var progress = response.progress;
           $('#progress').text(progress);
   
           if (progress < 100) trackProgress();// You can add a delay here if you want it is not risky then.
       });
   }
   

   comme les appels sont asynchrones peut revenir indésirable en ordonner autrement.

2. économiser dans $_SESSION['some_progress'] est intelligent et vous pouvez, pas besoin de stockage de base de données. Ce dont vous avez réellement besoin est de permettre aux deux scripts d'être appelés simultanément et de ne pas être mis en file d'attente par PHP. Donc ce dont vous avez le plus besoin c'est session_write_close() ! J'ai posté un exemple de démonstration très simple ici: https://stackoverflow.com/a/38334673/2012407

fréquemment dans les applications web, nous pouvons avoir une requête vers le système de bout en bout qui peut déclencher un processus de longue durée tel que la recherche énorme quantité de données ou un processus de base de données de longue durée. Ensuite, la page Web avant peut être suspendue et attendre que le processus soit terminé. Au cours de ce processus, si l'on peut fournir à l'utilisateur des informations sur l'avancement de la fin du processus, il peut améliorer l'expérience utilisateur. Malheureusement, dans les applications web, cela ne semble pas une tâche facile parce que les langages de script web ne prennent pas en charge le multithreading et HTTP est apatride. Nous pouvons maintenant avoir AJAX pour simuler le processus en temps réel.

en gros, nous avons besoin de trois fichiers pour traiter la demande. Le premier est le script qui exécute le travail réel de longue durée et il a besoin d'une variable de session pour stocker la progression. Le second script est le script d'état qui va faire écho à la variable session dans le script de travail en cours d'exécution. Le dernier est le script AJAX côté client qui peut Poller le script de statut fréquemment.

pour les détails de la mise en œuvre, vous pouvez vous référer à PHP pour obtenir la progression du processus de longue durée dynamiquement