Français
Français
Lors du traitement des données de streaming, vous rencontrez souvent des scénarios où les données doivent être hachées. PHP fournit une multitude de fonctions pour gérer ces tâches, et Hash_Final et Stream_get_Contents sont deux des outils les plus utiles. Lorsque ces deux fonctions sont utilisées en combinaison, cela peut nous aider à gérer efficacement les calculs de hachage des fichiers volumineux, en évitant les problèmes de performances du chargement du fichier entier en mémoire.
Dans cet article, nous explorerons en profondeur comment utiliser ces deux fonctions pour calculer efficacement la valeur de hachage des données de streaming, en particulier dans des scénarios tels que les téléchargements de fichiers importants et la vérification des fichiers.
Stream_get_Contents est une fonction de PHP qui peut lire les données d'un flux jusqu'à la fin du flux. Cette fonction est généralement utilisée pour lire les données Block par bloc et renvoyer du contenu complet, en particulier adapté à la gestion des fichiers volumineux ou des données qui ne peuvent pas être chargés dans la mémoire à la fois.
$handle = fopen('http://gitbox.net/path/to/largefile', 'r');
$content = stream_get_contents($handle);
fclose($handle);
Dans l'exemple ci-dessus, Stream_get_Contents lit les données à partir d'une adresse URL et les stocke dans $ Content . Il convient de noter que si le fichier est très grand, l'utilisation de Stream_get_Contents pour lire le fichier entier occupera directement beaucoup de mémoire, il convient donc particulièrement au traitement de streaming efficace avec d'autres fonctions telles que Hash_Final .
La fonction HASH_FINAL est utilisée pour renvoyer le résultat final d'un contexte de hachage. Il est souvent utilisé en conjonction avec hash_init et hash_update , et les données sont calculées progressivement dans le processus. Lorsque nous traitons les données du flux, Hash_Final nous permet de renvoyer une valeur de hachage après que les données de flux soient entièrement lues et traitées.
$context = hash_init('sha256'); // utiliser SHA-256 algorithme
hash_update($context, 'data to hash');
$hash = hash_final($context); // Renvoie la valeur de hachage finale
Lorsque nous devons hacher les données de flux d'un grand fichier, nous pouvons combiner Stream_get_Contents et Hash_Final pour lire le bloc de données par bloc et mettre à jour la valeur de hachage en temps réel. Cela évite de charger le fichier entier en mémoire et réduit la consommation de mémoire.
L'exemple suivant montre comment lire un fichier via le streaming et calculer sa valeur de hachage en temps réel:
<?php
$filename = 'http://gitbox.net/path/to/largefile';
// Ouvrez le flux de fichiers
$handle = fopen($filename, 'r');
if (!$handle) {
die('Impossible d'ouvrir le fichier');
}
// Initialiser le contexte du hachage
$context = hash_init('sha256');
// Lire le contenu du fichier par bloc et mettre à jour le hachage
while ($chunk = stream_get_contents($handle, 8192)) { // Chaque lecture 8KB
hash_update($context, $chunk); // Mettre à jour le contexte du hachage
}
// Obtenez la valeur de hachage finale
$hash = hash_final($context);
// Fermez le flux de fichiers
fclose($handle);
echo "La valeur de hachage du fichier est: $hash\n";
?>
Ouvrez le flux de fichiers : ouvrez le flux de fichiers via FOPEN . Dans cet exemple, nous lisons le fichier http://gitbox.net/path/to/largefile .
Initialisez le contexte de hachage : utilisez Hash_init pour créer un contexte de hachage pour SHA-256.
Lire le contenu des fichiers Block by Block : Stream_get_Contents lit 8KB de données à chaque fois et met à jour en continu la valeur de hachage via hash_update .
Obtenez le hachage final : une fois le fichier entièrement lu, la valeur de hachage finale est obtenue via Hash_Final .
Fermer le flux de fichiers : une fois le fichier lu, utilisez FCLOSE pour fermer le fichier.
De cette façon, quelle que soit la taille du fichier, nous pouvons le gérer le bloc par bloc pour éviter les problèmes de débordement de mémoire et assurer une utilisation efficace de la mémoire.
La combinaison de Hash_Final et Stream_get_Contents peut calculer efficacement la valeur de hachage des fichiers volumineux, en particulier adapté aux scénarios où les données doivent être traitées en streaming. Cette approche évite de charger complètement les fichiers en mémoire, réduisant ainsi considérablement la consommation de mémoire et améliorant la capacité de gérer de grandes quantités de données.
J'espère que cet article vous aidera à comprendre comment utiliser ces deux fonctions pour traiter les données de streaming et améliorer votre efficacité de programmation PHP!
