Comment télécharger un fichier avec l'ajax en petits morceaux et vérifier échoue, re-télécharger les parties qui ont échoué.

J'ai un fichier téléchargé par un utilisateur, et j'aimerais atteindre les objectifs suivants.

  1. Diviser le fichier en plusieurs morceaux sur un mégaoctet.
  2. Télécharger chaque morceau, et attendre qu'il ait fini avant de commencer à télécharger le segment suivant.
  3. Pour chaque morceau d'obtenir le succès ou l'échec de rapport.
  4. Re-télécharger l'échec de morceaux.
  5. Obtenir des progrès dans les pourcentages.

Voici un aperçu de JavaScript. Je suis littéralement perdu. A obtenu un peu de code en ligne et a essayé de le modifier.

$.chunky = function(file, name){        
                var loaded = 0;
                var step = 1048576//1024*1024;
                var total = file.size;
                var start = 0;
                var reader = new FileReader();

                reader.onload = function(e){

                var d = {file:reader.result}
                $.ajax({
                    url:"../record/c/index.php",
                    type:"POST", 
                    data:d}).done(function(r){
                    $('.record_reply_g').html(r);

                    loaded += step;                 
                    $('.upload_rpogress').html((loaded/total) * 100);

                        if(loaded <= total){
                            blob = file.slice(loaded,loaded+step);
                            reader.readAsBinaryString(blob);
                        } else {
                            loaded = total;
                        }
                })              
                };

                var blob = file.slice(start,step);
                reader.readAsBinaryString(blob);
            }

Comment puis-je obtenir ci-dessus. Veuillez expliquer ce qui se passe si il y a une solution viable.

avez-vous essayé github.com/blueimp/jQuery-File-Upload/wiki/Chunked-file-uploads
pas un mauvais départ, vous devez couper avec une accumulation de gamme, chargé sera le gros morceau de la taille, et l'étape semble être constant... en général, essayez de diviser le problème en petits morceaux, comme quelque chose qui peut télécharger une plage de données à partir d'un fichier, puis d'une partie que l'on peut appeler la distance uploader sur chaque partie d'un fichier, d'une part pour gérer les erreurs, puis une partie d'annoncer "je suis fait", ... bref, de plus en plus de petites fonctions, moins d'un gros onload de la fonction.
J'ai une autre fonction qui peut faire de gros morceaux seulement, le problème est en attente pour chaque morceau à télécharger. son un tableau qui contient des morceaux d'environ 1 mo chacune.

OriginalL'auteur Relm | 2015-11-05

  1. 6

    Tu ne fais rien de l'échec de tout morceau de téléchargement.

    $.chunky = function(file, name){        
    var loaded = 0;
    var step = 1048576//1024*1024; size of one chunk
    var total = file.size;  //total size of file
    var start = 0;          //starting position
    var reader = new FileReader();
    var blob = file.slice(start,step); //a single chunk in starting of step size
    reader.readAsBinaryString(blob);   //reading that chunk. when it read it, onload will be invoked

    reader.onload = function(e){            
        var d = {file:reader.result}
        $.ajax({
            url:"../record/c/index.php",
            type:"POST", 
            data:d                     //d is the chunk got by readAsBinaryString(...)
        }).done(function(r){           //if 'd' is uploaded successfully then ->
                $('.record_reply_g').html(r);   //updating status in html view

                loaded += step;                 //increasing loaded which is being used as start position for next chunk
                $('.upload_rpogress').html((loaded/total) * 100);

                if(loaded <= total){            //if file is not completely uploaded
                    blob = file.slice(loaded,loaded+step);  //getting next chunk
                    reader.readAsBinaryString(blob);        //reading it through file reader which will call onload again. So it will happen recursively until file is completely uploaded.
                } else {                       //if file is uploaded completely
                    loaded = total;            //just changed loaded which could be used to show status.
                }
            })              
        };
}

    MODIFIER

    Pour le téléchargement a échoué morceau de nouveau, vous pouvez effectuer les opérations suivantes :

    var totalFailures = 0;
reader.onload = function(e) {
    ....
}).done(function(r){
    totalFailures = 0;
    ....
}).fail(function(r){   //if upload failed
   if((totalFailure++) < 3) { //atleast try 3 times to upload file even on failure
     reader.readAsBinaryString(blob);
   } else {                   //if file upload is failed 4th time
      //show message to user that file uploading process is failed
   }
});
    si(chargé <= total) si le fichier n'est pas complètement chargé, comment est-ajax téléchargement le reste du fichier, ne devrait pas Ajax être appelé à nouveau de télécharger le reste du fichier? Et comment puis-je vérifier si un morceau a échoué?
    lorsque reader.readAsBinaryString(blob) est appelé ensuite reader.onload est de nouveau appelé. Donc le téléchargement du fichier qui se passe de manière récursive.
    ohhhhh ok ,fait sens, peut-on vérifier si, pour chaque morceau?
    n'est-ce pas "var d = {fichier:reader.résultat}", de télécharger l'ensemble du dossier? n'est-il pas supposé être le "blob", qui est un morceau?
    var d={file:reader.result} n'est pas le téléchargement de fichiers. mais il est la lecture du fichier, et seulement une partie de celui-ci.

    OriginalL'auteur afzalex