Français
Français
Lors du traitement de gros fichiers ou de grandes quantités de données, les méthodes de hachage uniques traditionnelles sont souvent confrontées à des problèmes tels qu'une utilisation excessive de la mémoire ou une dégradation des performances. Depuis 5.4.0, PHP a introduit des fonctions telles que hash_init () , hash_update () et hash_final () , ce qui nous permet de hacher les données d'une manière en streaming (segmentée), améliorant considérablement la flexibilité et l'efficacité du traitement des mégadonnées.
Imaginez que vous devez hacher un fichier journal de 5 Go. Si vous utilisez directement la fonction hash () , vous devez lire le fichier entier en mémoire en même temps, ce qui n'est pas possible. Le hachage segmenté peut traiter le segment de données par segment comme la lecture des flux, l'épargne des ressources et le fait d'être plus sûr.
Après avoir créé un contexte de hachage à l'aide de hash_init () , nous pouvons appeler Hash_update () plusieurs fois pour "nourrir" l'algorithme de fragment de données, et enfin utiliser hash_final () pour obtenir la valeur de hachage finale.
$ctx = hash_init('sha256');
hash_update($ctx, 'first_chunk_of_data');
hash_update($ctx, 'second_chunk_of_data');
$finalHash = hash_final($ctx);
Cette méthode est entièrement équivalente à:
$finalHash = hash('sha256', 'first_chunk_of_data' . 'second_chunk_of_data');
Mais il peut traiter les données étape par étape sans le charger en une seule fois.
Le code suivant montre comment avoir un grand fichier segmenté:
$file = '/path/to/large_file.dat';
$handle = fopen($file, 'rb');
if (!$handle) {
die('Impossible d'ouvrir le fichier');
}
$ctx = hash_init('sha256');
while (!feof($handle)) {
$chunk = fread($handle, 8192); // Chaque lecture8KB
if ($chunk === false) {
fclose($handle);
die('Une erreur s'est produite lors de la lecture du fichier');
}
hash_update($ctx, $chunk);
}
fclose($handle);
$finalHash = hash_final($ctx);
echo "La valeur de hachage du fichier est: $finalHash\n";
Grâce au code ci-dessus, les programmes PHP peuvent facilement hacher les fichiers supérieurs à la taille de la mémoire, ce qui convient à la vérification du journal, à la vérification de l'intégrité des données et à d'autres scénarios.
Si les données ne sont pas un fichier local, mais proviennent d'une URL distante, elle peut également être traitée de la même manière. Exemple:
$url = 'https://gitbox.net/streaming-data-endpoint';
$context = stream_context_create([
'http' => ['method' => 'GET']
]);
$handle = fopen($url, 'rb', false, $context);
if (!$handle) {
die('Impossible d'ouvrir un flux de données distant');
}
$ctx = hash_init('sha256');
while (!feof($handle)) {
$chunk = fread($handle, 4096);
if ($chunk === false) {
fclose($handle);
die('Une erreur s'est produite lors de la lecture des données distantes');
}
hash_update($ctx, $chunk);
}
fclose($handle);
$hash = hash_final($ctx);
echo "La valeur de hachage des données distantes est: $hash\n";
Cette méthode est très efficace pour le traitement du flux de données en temps réel et convient particulièrement pour le traitement des données de diffusion en direct, des commentaires de la rétroaction API ou de l'agrégation de journaux.
Codage de cohérence : assurez-vous de vous assurer que les données transmises dans hash_update () sont codées de manière codé et évitent aux caractères de plusieurs octets de provoquer différentes valeurs de hachage.
Gestion des erreurs : gérez entièrement les exceptions pour les échecs de lecture de fichiers, les erreurs de réseau, etc.
Sélection de l'algorithme de hachage : sélectionnez les algorithmes de hachage appropriés en fonction des besoins de sécurité réels, tels que SHA256 , SHA512 , MD5 (non recommandés pour les scénarios de sécurité), etc.
Grâce à hash_final () combiné avec hash_init () et hash_update () , PHP nous fournit une manière de consommation de ressources efficace et faible pour gérer l'informatique de hachage des mégadonnées. Qu'il s'agisse de vérification du fichier ou d'analyse des données en streaming, la maîtrise de ce mécanisme peut considérablement améliorer notre capacité dans le traitement des données.
