Français
Français
Lors de la lecture d'un fichier à l'aide de la fonction file_get_contents en PHP, si le fichier est trop grand, il peut y avoir une mémoire insuffisante. Cet article analysera en détail ce qui cause ce problème et fournira des solutions efficaces.
File_get_Contents est une fonction très couramment utilisée en PHP pour lire le contenu du fichier. Il est très simple à utiliser, passez simplement dans le chemin du fichier, par exemple:
$content = file_get_contents('path/to/large/file.txt');
Cependant, lorsque le fichier est très grand, File_get_Contents chargera le contenu de l'ensemble du fichier en mémoire en même temps. Si la taille du fichier dépasse la limite de mémoire PHP ( Memory_limit ), une erreur hors mémoire sera lancée.
Par défaut, PHP limitera la mémoire maximale que les scripts peuvent utiliser (via l'élément de configuration Memory_limit ). Lorsque vous utilisez File_get_Contents pour lire un grand fichier, PHP chargera le contenu de l'ensemble du fichier en mémoire. Si la taille du fichier dépasse cette limite de mémoire, le script se bloquera et une erreur "hors mémoire" se produira.
Par exemple, si vous lisez un fichier de centaines de MB ou GB, File_get_Contents essaiera de charger le fichier entier en mémoire, et une erreur sera signalée si la limite de mémoire de PHP est dépassée.
Le moyen le plus direct consiste à augmenter la limite de mémoire de PHP, qui peut être réalisée en modifiant Memory_limit dans le fichier php.ini :
memory_limit = 512M
Ou vous pouvez définir des limites de mémoire dynamiquement dans les scripts PHP:
ini_set('memory_limit', '512M');
Cependant, cette approche ne fonctionne pas nécessairement, car pour les fichiers extrêmement volumineux, le débordement de la mémoire peut ne pas être évité même si des limites de mémoire sont ajoutées.
Afin d'éviter de charger le fichier entier en mémoire en même temps, vous pouvez utiliser la lecture segmentée pour lire le contenu du fichier Block par bloc à l'aide de Fonctions FOPEN et FREAD :
$handle = fopen('path/to/large/file.txt', 'r');
if ($handle) {
while (($chunk = fread($handle, 8192)) !== false) {
// Traiter les données pour chaque bloc
echo $chunk; // Vous pouvez sortir directement le contenu ou effectuer un autre traitement
}
fclose($handle);
} else {
echo "Impossible d'ouvrir le fichier";
}
L'avantage de cela est que seule une partie du contenu du fichier sera lue à la fois et ne prendra pas trop de mémoire.
Vous pouvez également utiliser Stream_Context_Create pour créer un contexte de flux et une lecture de flux en combinaison avec file_get_contents . Cela empêchera l'ensemble du fichier d'être chargé en mémoire à la fois. Les exemples sont les suivants:
$options = [
'http' => [
'method' => 'GET',
'header' => "Content-Type: text/plain\r\n"
]
];
$context = stream_context_create($options);
$content = file_get_contents('http://gitbox.net/path/to/large/file.txt', false, $context);
Bien que cette approche soit plus adaptée à la gestion des demandes HTTP, elle peut également être utilisée dans d'autres scénarios de streaming.
SPLFileObject est une classe intégrée en PHP, spécifiquement utilisée pour traiter les fichiers. Utilisez-le pour lire le fichier ligne par ligne, en évitant de charger le fichier entier en mémoire à la fois. Les exemples sont les suivants:
$file = new SplFileObject('path/to/large/file.txt');
while (!$file->eof()) {
$line = $file->fgets();
echo $line; // Traiter le contenu du fichier ligne par ligne
}
Cette méthode convient au traitement des fichiers texte, en lisant une seule ligne à la fois, et l'utilisation de la mémoire est très petite.
Dans certains cas, si les limites de mémoire de PHP et la vitesse de lecture ne répondent toujours pas aux besoins, vous pouvez envisager d'utiliser certains outils de ligne de commande au niveau du système pour gérer les fichiers volumineux, tels que CAT , AWK ou SED , puis appeler ces outils via la fonction EXEC de PHP:
$output = shell_exec('cat /path/to/large/file.txt');
echo $output;
Cette méthode convient à la lecture rapide lors du traitement des fichiers volumineux, mais veillez à assurer la sécurité et les autorisations des outils système.
Si vous avez besoin d'obtenir des fichiers volumineux à partir d'un serveur distant, vous pouvez utiliser Curl pour télécharger les fichiers en morceaux. Curl prend en charge les téléchargements HTTP, ce qui peut éviter de charger le fichier entier en mémoire en même temps. L'exemple est le suivant:
$ch = curl_init('http://gitbox.net/path/to/large/file.txt');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_BUFFERSIZE, 128);
$content = curl_exec($ch);
curl_close($ch);
Cette méthode est particulièrement adaptée à la lecture en streaming lors de la gestion des fichiers volumineux distants.
Le problème de mémoire insuffisant de File_get_Contents lors de la gestion des fichiers volumineux est généralement causé par le chargement des fichiers PHP en mémoire en même temps. Afin d'éviter les erreurs de mémoire insuffisantes, nous pouvons choisir une variété de méthodes, telles que l'augmentation des limites de mémoire, la lecture de fichiers en morceaux, en utilisant des méthodes de lecture en streaming, etc.
Différentes solutions peuvent être choisies pour différentes situations, mais l'objectif fondamental est de réduire l'utilisation de la mémoire et d'éviter de charger trop de données à la fois. Espérons que les solutions fournies dans cet article peuvent vous aider à résoudre le problème de la mémoire insuffisante lorsque vous traitez avec de grands fichiers.
Étiquettes associées:
file_get_contents
