How to solve the problem that large file slice upload cannot process files above 48MB?

Break through the 48MB limit: Solve the problem of uploading large file slices

During the process of uploading large file slices, do you encounter a situation where more than 48MB files cannot be processed? This article will analyze the root cause of the problem and provide solutions in front-end, back-end and server configuration.

Problem analysis

When uploading a large file, after the 48th slice (about 48MB), the subsequent request returns 500 errors. Even if the slice size is adjusted, the 40MB limit cannot be exceeded. This indicates that the problem may lie in the server-side or back-end processing logic and requires in-depth troubleshooting.

Front-end code optimization

First, check the front-end code. Previous code might use the same FormData object every time the slice is sent, causing data accumulation to exceed the server limit.

Solution: Recreate the FormData object every time the upload function is called. In this way, each request only contains the current slice data, avoiding data accumulation.

Sample code snippet (improved sendfile function):

 function sendfile(blob, file) {
    if (is_stop == 0) {
        var xhr = new XMLHttpRequest();
        var form_data = new FormData(); // Recreate the FormData object var total_blob_num = Math.ceil(file.size / length);
        form_data.append('file', blob);
        form_data.append('blob_num', blob_num);
        form_data.append('total_blob_num', total_blob_num);
        form_data.append('file_name', file.name);

        xhr.open('POST', '/upload.php', false);
        xhr.onreadystatechange = function () {
            // ... (The rest of the code remains the same) ...
        };
        xhr.send(form_data); // Send request}
}

Backend code improvements

Backend code may cause memory overflow due to processing large files directly in memory. It is recommended to use streaming or temporary file merging . Save each slice to a temporary file and merge it into the final file.

Sample code snippet (PHP, improved fileMerge function):

 private function fileMerge() {
    if ($this->blobNum == $this->totalBlobNum) {
        $out = fopen($this->filepath . '/' . $this->fileName, 'wb'); // Use 'wb' mode to ensure binary security for ($i = 1; $i totalBlobNum; $i ) {
            $chunk = fopen($this->filepath . '/' . $this->fileName . '__' . $i, 'rb'); // Use 'rb' mode to read binary data stream_copy_to_stream($chunk, $out); // Use stream_copy_to_stream to efficiently copy fclose($chunk);
            @unlink($this->filepath . '/' . $this->fileName . '__' . $i);
        }
        fclose($out);
    }
}

Server configuration check

Even with the front-end and back-end code tweaked, the problem may still exist. The following server configurations need to be checked:

1. Apache's LimitRequestBody setting: Make sure this value is large enough to allow uploading of large files.
2. PHP upload_max_filesize and post_max_size settings: These two values ​​must be greater than the size of the uploaded file.
3. PHP's memory_limit setting: If the backend processes files in memory, this value needs to be increased.

Summary and suggestions

To solve the problem of large file slicing upload, it is necessary to comprehensively consider the front-end, back-end and server configurations. By recreating FormData objects, using streaming or temporary file merging and adjusting server configuration, the problem of uploading files above 48MB can be effectively solved, and the efficient large file upload function can be achieved.

The above is the detailed content of How to solve the problem that large file slice upload cannot process files above 48MB?. For more information, please follow other related articles on the PHP Chinese website!