Parlons de la façon d'utiliser PHP pour lire des fichiers volumineux (partage de tutoriel)

Comment lire des fichiers volumineux en PHP ? L'article suivant vous présentera comment utiliser PHP pour lire des fichiers volumineux. J'espère qu'il vous sera utile !

En tant que développeurs PHP, nous n'avons pas à nous soucier de la gestion de la mémoire. Le moteur PHP fait un excellent travail de nettoyage dans notre dos, et le modèle de serveur Web de contextes d'exécution éphémères signifie que même le code le plus bâclé n'a aucun impact durable.

En de rares occasions, nous devrons peut-être sortir des limites du confort — par exemple, lorsque nous essayons d'exécuter Composer pour un projet de grande envergure sur le plus petit VPS que nous pouvons créer, ou lorsque nous devons lire des fichiers volumineux sur un serveur tout aussi petit. .

C'est une question dont nous discuterons dans ce tutoriel.

Le code de ce tutoriel peut être trouvé ici GitHub.

Mesurer le succès

La seule façon de confirmer que les améliorations que nous avons apportées à notre code fonctionnent est de mesurer une mauvaise situation et de la comparer à la façon dont nous mesurons après avoir appliqué les améliorations. En d’autres termes, nous ne savons pas si une « solution » est une solution à moins de savoir dans quelle mesure (voire pas du tout) elle nous aidera.

Nous pouvons nous concentrer sur deux indicateurs. Le premier est l’utilisation du processeur. À quelle vitesse ou à quelle vitesse le processus auquel nous sommes confrontés s'exécute-t-il ? Deuxièmement, l'utilisation de la mémoire. Quelle quantité de mémoire le script prend-il pour s'exécuter ? Celles-ci sont généralement inversement proportionnelles, ce qui signifie que nous pouvons réduire l'utilisation de la mémoire au détriment de l'utilisation du processeur, et vice versa.

Dans un modèle de traitement asynchrone (tel qu'une application PHP multi-processus ou multi-thread), l'utilisation du processeur et de la mémoire sont des considérations importantes. Dans une architecture PHP traditionnelle, cela devient généralement un problème chaque fois que les contraintes du serveur sont atteintes.

Mesurer l'utilisation du processeur dans PHP est difficile à réaliser. Si cela vous intéresse vraiment, envisagez d'utiliser une commande comme top 的命令。对于Windows，则可用考虑使用Linux子系统，这样你就能够在Ubuntu中使用 top dans Ubuntu ou macOS.

Dans ce tutoriel, nous mesurerons l'utilisation de la mémoire. Nous examinerons la quantité de mémoire qu'un script "traditionnel" utilisera. Nous mettrons également en œuvre certaines stratégies d’optimisation et les mesurerons. Enfin, j'espère que vous pourrez faire un choix raisonnable.

Voici les méthodes que nous utilisons pour visualiser l'utilisation de la mémoire :

// formatBytes 方法取材于 php.net 文档

memory_get_peak_usage();

function formatBytes($bytes, $precision = 2) {
    $units = array("b", "kb", "mb", "gb", "tb");

    $bytes = max($bytes, 0);
    $pow = floor(($bytes ? log($bytes) : 0) / log(1024));
    $pow = min($pow, count($units) - 1);

    $bytes /= (1 << (10 * $pow));

    return round($bytes, $precision) . " " . $units[$pow];
}

Nous utiliserons ces méthodes à la fin du script afin de pouvoir comprendre quel script utilise le plus de mémoire à la fois.

Quelles options avons-nous ?

Nous disposons de nombreuses façons de lire des fichiers efficacement. Ils sont utilisés dans les deux scénarios suivants. Nous pouvons vouloir lire et traiter toutes les données en même temps, afficher les données traitées ou effectuer d'autres opérations. Nous pouvons également souhaiter transformer le flux de données sans accéder aux données.

Imaginez ce qui suit, pour le premier cas, si nous voulons lire le fichier et transmettre toutes les 10 000 lignes de données à une file d'attente distincte pour traitement. Nous aurions besoin de charger au moins 10 000 lignes de données en mémoire et de les transmettre au gestionnaire de files d'attente (quel que soit celui utilisé).

Pour le deuxième cas, supposons que nous souhaitions compresser le contenu d'une réponse API particulièrement volumineuse. Même si nous ne nous soucions pas de son contenu ici, nous devons nous assurer qu'il est sauvegardé dans un format compressé.

Dans les deux cas, nous devons lire des fichiers volumineux. La différence est que dans le premier cas, nous avons besoin de savoir quelles sont les données, tandis que dans le second cas, nous ne nous soucions pas de ce que sont les données. Ensuite, discutons en profondeur de ces deux approches...

Lire les fichiers ligne par ligne

PHP a de nombreuses fonctions pour traiter les fichiers, combinons certaines d'entre elles pour implémenter un simple lecteur de fichiers

// from memory.php

function formatBytes($bytes, $precision = 2) {
    $units = array("b", "kb", "mb", "gb", "tb");

    $bytes = max($bytes, 0);
    $pow = floor(($bytes ? log($bytes) : 0) / log(1024));
    $pow = min($pow, count($units) - 1);

    $bytes /= (1 << (10 * $pow));

    return round($bytes, $precision) . " " . $units[$pow];
}

print formatBytes(memory_get_peak_usage());

// from reading-files-line-by-line-1.php
function readTheFile($path) {
    $lines = [];
    $handle = fopen($path, "r");

    while(!feof($handle)) {
        $lines[] = trim(fgets($handle));
    }

    fclose($handle);
    return $lines;
}

readTheFile("shakespeare.txt");

require "memory.php";

Nous lisons un texte dossier contenant l'intégralité des œuvres de Shakespeare. La taille du fichier est d'environ 5,5 Mo. L'utilisation de la mémoire a culminé à 12,8 Mo. Maintenant, utilisons le générateur pour lire chaque ligne :

// from reading-files-line-by-line-2.php

function readTheFile($path) {
    $handle = fopen($path, "r");

    while(!feof($handle)) {
        yield trim(fgets($handle));
    }

    fclose($handle);
}

readTheFile("shakespeare.txt");

require "memory.php";

La taille du fichier est la même, mais l'utilisation de la mémoire culmine à 393 Ko. Ces données ne sont pas très significatives, car il faut ajouter le traitement des données des fichiers. Par exemple, divisez le document en morceaux lorsque deux lignes vides apparaissent :

// from reading-files-line-by-line-3.php

$iterator = readTheFile("shakespeare.txt");

$buffer = "";

foreach ($iterator as $iteration) {
    preg_match("/\n{3}/", $buffer, $matches);

    if (count($matches)) {
        print ".";
        $buffer = "";
    } else {
        $buffer .= $iteration . PHP_EOL;
    }
}

require "memory.php";

Quelqu'un a-t-il une idée de la quantité de mémoire utilisée cette fois-ci ? Même si nous divisons le document texte en 126 morceaux, nous n'utilisons toujours que 459 Ko de mémoire. Compte tenu de la nature du générateur, la mémoire maximale que nous utiliserons est la mémoire nécessaire pour stocker le plus gros morceau de texte au cours de l'itération. Dans ce cas, le plus grand bloc contient 101 985 caractères.

J'ai déjà écrit sur Utilisation de générateurs pour améliorer les performances et Pack d'extension de générateur Si vous êtes intéressé, vous pouvez consulter plus de contenu connexe.

Le générateur a d'autres utilisations, mais il fonctionne évidemment bien pour lire des fichiers volumineux. Si nous devons traiter des données, les générateurs sont probablement la meilleure solution.

文件之间的管道

在不需要处理数据的情况下，我们可以将文件数据从一个文件传递到另一个文件。这通常称为管道 (大概是因为除了两端之外，我们看不到管道内的任何东西，当然，只要它是不透明的)。我们可以通过流(stream)来实现，首先，我们编写一个脚本实现一个文件到另一个文件的传输，以便我们可以测量内存使用情况：

// from piping-files-1.php

file_put_contents(
    "piping-files-1.txt", file_get_contents("shakespeare.txt")
);

require "memory.php";

结果并没有让人感到意外。该脚本比其复制的文本文件使用更多的内存来运行。这是因为脚本必须在内存中读取整个文件直到将其写入另外一个文件。对于小的文件而言，这种操作是 OK 的。但是将其用于大文件时，就不是那么回事了。

让我们尝试从一个文件流式传输(或管道传输)到另一个文件：

// from piping-files-2.php

$handle1 = fopen("shakespeare.txt", "r");
$handle2 = fopen("piping-files-2.txt", "w");

stream_copy_to_stream($handle1, $handle2);

fclose($handle1);
fclose($handle2);

require "memory.php";

这段代码有点奇怪。我们打开两个文件的句柄，第一个处于读取模式，第二个处于写入模式。然后，我们从第一个复制到第二个。我们通过再次关闭两个文件来完成。当你知道内存使用为 393 KB 时，可能会感到惊讶。

这个数字看起来很熟悉，这不就是利用生成器保存逐行读取内容时所使用的内存吗。这是因为 fgets 的第二个参数定义了每行要读取的字节数(默认为 -1 或到达新行之前的长度)。

stream_copy_to_stream 的第三个参数是相同的（默认值完全相同）。stream_copy_to_stream 一次从一个流读取一行，并将其写入另一流。由于我们不需要处理该值，因此它会跳过生成器产生值的部分

单单传输文字还不够实用，所以考虑下其他例子。假设我们想从 CDN 输出图像，可以用以下代码来描述

// from piping-files-3.php

file_put_contents(
    "piping-files-3.jpeg", file_get_contents(
        "https://github.com/assertchris/uploads/raw/master/rick.jpg"
    )
);

// ...or write this straight to stdout, if we don't need the memory info

require "memory.php";

想象一下应用程度执行到该步骤。这次我们不是要从本地文件系统中获取图像，而是从 CDN 获取。我们用 file_get_contents 代替更优雅的处理方式(例如Guzzle)，它们的实际效果是一样的。

内存使用情况为 581KB，现在，我们如何尝试进行流传输呢？

// from piping-files-4.php

$handle1 = fopen(
    "https://github.com/assertchris/uploads/raw/master/rick.jpg", "r"
);

$handle2 = fopen(
    "piping-files-4.jpeg", "w"
);

// ...or write this straight to stdout, if we don't need the memory info

stream_copy_to_stream($handle1, $handle2);

fclose($handle1);
fclose($handle2);

require "memory.php";

内存使用比刚才略少(400 KB)，但是结果是相同的。如果我们不需要内存信息，也可以打印至标准输出。PHP 提供了一种简单的方法来执行此操作：

$handle1 = fopen(
    "https://github.com/assertchris/uploads/raw/master/rick.jpg", "r"
);

$handle2 = fopen(
    "php://stdout", "w"
);

stream_copy_to_stream($handle1, $handle2);

fclose($handle1);
fclose($handle2);

// require "memory.php";

其他流

还存在一些流可以通过管道来读写。

• php://stdin 只读
• php://stderr 只写，与 php://stdout 相似
• php://input 只读，使我们可以访问原始请求内容
• php://output 只写，可让我们写入输出缓冲区
• php://memory 与 php://temp (可读写) 是临时存储数据的地方。区别在于数据足够大时 php:/// temp 就会将数据存储在文件系统中，而php:/// memory将继续存储在内存中直到耗尽。

过滤器

我们可以对流使用另一个技巧，称为过滤器。它介于两者之间，对数据进行了适当的控制使其不暴露给外接。假设我们要压缩 shakespeare.txt 文件。我们可以使用 Zip 扩展

// from filters-1.php

$zip = new ZipArchive();
$filename = "filters-1.zip";

$zip->open($filename, ZipArchive::CREATE);
$zip->addFromString("shakespeare.txt", file_get_contents("shakespeare.txt"));
$zip->close();

require "memory.php";

这段代码虽然整洁，但是总共使用了大概 10.75 MB 的内存。我们可以使用过滤器来进行优化

// from filters-2.php

$handle1 = fopen(
    "php://filter/zlib.deflate/resource=shakespeare.txt", "r"
);

$handle2 = fopen(
    "filters-2.deflated", "w"
);

stream_copy_to_stream($handle1, $handle2);

fclose($handle1);
fclose($handle2);

require "memory.php";

在这里，我们可以看到 php:///filter/zlib.deflate 过滤器，该过滤器读取和压缩资源的内容。然后我们可以将该压缩数据通过管道传输到另一个文件中。这仅使用了 896KB 内存。

虽然格式不同，或者说使用 zip 压缩文件有其他诸多好处。但是，你不得不考虑：如果选择其他格式你可以节省 12 倍的内存，你会不会心动？

要对数据进行解压，只需要通过另外一个 zlib 过滤器:

// from filters-2.php

file_get_contents(
    "php://filter/zlib.inflate/resource=filters-2.deflated"
);

关于流，在 Understanding Streams in PHP 和 Using PHP Streams Effectively 文章中已经进行了广泛的讨论，如果你想要换个角度思考，可以查看以上这两篇文章。

自定义流

fopen 和 file_get_contents 具有它们自己的默认选项集，但是它们是完全可定制的。要定义它们，我们需要创建一个新的流上下文

// from creating-contexts-1.php

$data = join("&", [
    "twitter=assertchris",
]);

$headers = join("\r\n", [
    "Content-type: application/x-www-form-urlencoded",
    "Content-length: " . strlen($data),
]);

$options = [
    "http" => [
        "method" => "POST",
        "header"=> $headers,
        "content" => $data,
    ],
];

$context = stream_content_create($options);

$handle = fopen("https://example.com/register", "r", false, $context);
$response = stream_get_contents($handle);

fclose($handle);

本例中，我们尝试发送一个 POST 请求给 API。API 端点是安全的，不过我们仍然使用了 http 上下文属性（可用于 http 或者 https)。我们设置了一些头部，并打开了 API 的文件句柄。我们可以将句柄以只读方式打开，上下文负责编写。

自定义的内容很多，如果你想了解更多信息，可查看对应 文档。

创建自定义协议和过滤器

在总结之前，我们先谈谈创建自定义协议。如果你查看 文档，可以找到一个示例类：

Protocol {
    public resource $context;
    public __construct ( void )
    public __destruct ( void )
    public bool dir_closedir ( void )
    public bool dir_opendir ( string $path , int $options )
    public string dir_readdir ( void )
    public bool dir_rewinddir ( void )
    public bool mkdir ( string $path , int $mode , int $options )
    public bool rename ( string $path_from , string $path_to )
    public bool rmdir ( string $path , int $options )
    public resource stream_cast ( int $cast_as )
    public void stream_close ( void )
    public bool stream_eof ( void )
    public bool stream_flush ( void )
    public bool stream_lock ( int $operation )
    public bool stream_metadata ( string $path , int $option , mixed $value )
    public bool stream_open ( string $path , string $mode , int $options ,
        string &$opened_path )
    public string stream_read ( int $count )
    public bool stream_seek ( int $offset , int $whence = SEEK_SET )
    public bool stream_set_option ( int $option , int $arg1 , int $arg2 )
    public array stream_stat ( void )
    public int stream_tell ( void )
    public bool stream_truncate ( int $new_size )
    public int stream_write ( string $data )
    public bool unlink ( string $path )
    public array url_stat ( string $path , int $flags )
}

我们并不打算实现其中一个，因为我认为它值得拥有自己的教程。有很多工作要做。但是一旦完成工作，我们就可以很容易地注册流包装器：

if (in_array("highlight-names", stream_get_wrappers())) {
    stream_wrapper_unregister("highlight-names");
}

stream_wrapper_register("highlight-names", "HighlightNamesProtocol");

$highlighted = file_get_contents("highlight-names://story.txt");

同样，也可以创建自定义流过滤器。 文档 有一个示例过滤器类：

Filter {
    public $filtername;
    public $params
    public int filter ( resource $in , resource $out , int &$consumed ,
        bool $closing )
    public void onClose ( void )
    public bool onCreate ( void )
}

可被轻松注册

$handle = fopen("story.txt", "w+");
stream_filter_append($handle, "highlight-names", STREAM_FILTER_READ);

highlight-names 需要与新过滤器类的 filtername 属性匹配。还可以在 php:///filter/highligh-names/resource=story.txt 字符串中使用自定义过滤器。定义过滤器比定义协议要容易得多。原因之一是协议需要处理目录操作，而过滤器仅需要处理每个数据块。

如果您愿意，我强烈建议您尝试创建自定义协议和过滤器。如果您可以将过滤器应用于stream_copy_to_stream操作，则即使处理令人讨厌的大文件，您的应用程序也将几乎不使用任何内存。想象一下编写调整大小图像过滤器或加密应用程序过滤器。

如果你愿意，我强烈建议你尝试创建自定义协议和过滤器。如果你可以将过滤器应用于 stream_copy_to_stream 操作，即使处理烦人的大文件，你的应用程序也几乎不使用任何内存。想象下编写 resize-image 过滤器和  encrypt-for-application 过滤器吧。

总结

虽然这不是我们经常遇到的问题，但是在处理大文件时的确很容易搞砸。在异步应用中，如果我们不注意内存的使用情况，很容易导致服务器的崩溃。

本教程希望能带给你一些新的想法（或者更新你的对这方面的固有记忆），以便你能够更多的考虑如何有效地读取和写入大文件。当我们开始熟悉和使用流和生成器并停止使用诸如 file_get_contents 这样的函数时，这方面的错误将全部从应用程序中消失，这不失为一件好事。

英文原文地址：https://www.sitepoint.com/performant-reading-big-files-php/

译文地址：https://learnku.com/php/t/39751

推荐学习：《PHP视频教程》

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!