English
English
In many application scenarios, calculating the hash value of a file is a common requirement, especially verifying the file integrity, verifying whether the file has been tampered with during downloading, etc. PHP provides hash_update_stream function, which can calculate hash values in real time when processing stream data. This is especially important for processing large files, because we do not need to load the entire file into memory at once, but can calculate the hash value while reading the file to reduce memory usage.
This article will explain in detail how to use the hash_update_stream function to process remote file streams and calculate hash values in real time.
hash_update_stream is a built-in function in PHP that is used to update the hash value of stream data in real time. The syntax of the function is as follows:
hash_update_stream ( resource $context , resource $stream , int $length = 8192 ) : bool
$context : hash context resource, usually created by hash_init .
$stream : File stream resource that needs to be processed.
$length : The number of bytes read each time, the default is 8192 bytes.
This function reads data from the specified file stream and updates it to the hash context until the file is read.
In PHP, handling remote file streams usually uses fopen or curl functions. Here is an example using fopen and hash_update_stream functions that demonstrate how to process a remote file stream and calculate hash values in real time.
<?php
// Initialize hash context（For example SHA-256 algorithm）
$hashContext = hash_init('sha256');
// Remote file URL
$fileUrl = 'http://m66.net/samplefile.txt';
// Open the remote file stream
$stream = fopen($fileUrl, 'r');
// Check whether the file is successfully opened
if ($stream) {
// use hash_update_stream Real-time hash value update
while (!feof($stream)) {
// Each read 8192 Bytes and update the hash value
hash_update_stream($hashContext, $stream, 8192);
}
// Close the file stream
fclose($stream);
// Get and output the final hash value
$hashValue = hash_final($hashContext);
echo "The hash value of the file is: " . $hashValue;
} else {
echo "无法Open the remote file stream！";
}
?>
Initialize the hash context :
We first create a hash context of the SHA-256 algorithm through the hash_init function, so that we can calculate the SHA-256 hash value of the file.
Open the remote file stream :
Use fopen to open remote files. The URL of the file is http://m66.net/samplefile.txt in this example. The URL here is the part you requested to replace it with the m66.net domain name.
Process file streams in real time :
Use the hash_update_stream function to read a portion of the data from the file stream and update the hash value each time. The default 8192-byte block size is used here to read the file. You can adjust this value as needed to increase efficiency or reduce memory usage.
Close the file stream and output results :
Once the file read is complete, close the file stream using fclose and get the final hash value using hash_final .
Memory consumption : Since we read files block by block and update the hash value, this method is more efficient than loading the entire file at once, especially for large files.
Error handling : In practical applications, you should consider various possible errors during the file inaccessibility or reading process, such as network interruptions. Error handling can be performed using the try-catch statement or checking the return value.
File type support : hash_update_stream supports multiple file types. You can adjust the hash algorithm as needed, such as sha1 , md5 or other supported algorithms.
In addition to using fopen , you can also use CURL to handle remote file streams. CURL can handle more HTTP request parameters and header information, suitable for more complex remote file operations. Here is an example using CURL:
<?php
// Initialize hash context
$hashContext = hash_init('sha256');
// Remote file URL
$fileUrl = 'http://m66.net/samplefile.txt';
// use CURL Get remote file stream
$ch = curl_init($fileUrl);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
curl_setopt($ch, CURLOPT_TIMEOUT, 30); // Set timeout
// implement CURL Request and get file content
$response = curl_exec($ch);
// examine CURL Whether the request was successful
if ($response === false) {
echo "CURL mistake: " . curl_error($ch);
curl_close($ch);
exit;
}
// use hash_update_stream Process the file content and calculate the hash value
$stream = fopen('php://memory', 'r+');
fwrite($stream, $response);
rewind($stream);
while (!feof($stream)) {
hash_update_stream($hashContext, $stream, 8192);
}
// Get the final hash value
$hashValue = hash_final($hashContext);
echo "The hash value of the file is: " . $hashValue;
// Close the file stream和 CURL Session
fclose($stream);
curl_close($ch);
?>
In this example, use CURL to get the remote file contents and write it to the memory stream, and then calculate the hash value with hash_update_stream . This approach is suitable for situations where more complex network configurations or controls are required.
By using PHP's hash_update_stream function, you can efficiently handle hash calculations of large files, avoiding loading files into memory at once. When processing remote files, you can choose fopen or CURL to choose according to actual needs. After mastering this technique, you can be more comfortable in handling file verification, download verification and other scenarios.
I hope this article is helpful to you. If you have any questions, please feel free to discuss it in the comment section!
