Wie lese ich große Dateien in PHP? Der folgende Artikel stellt Ihnen vor, wie Sie PHP zum Lesen großer Dateien verwenden. Ich hoffe, er wird Ihnen hilfreich sein!
Als PHP-Entwickler müssen wir uns keine Gedanken über die Speicherverwaltung machen. Die PHP-Engine leistet hervorragende Arbeit beim Aufräumen hinter unserem Rücken, und das Webservermodell mit kurzlebigen Ausführungskontexten sorgt dafür, dass selbst der schlampigste Code keine bleibenden Auswirkungen hat.
In seltenen Fällen müssen wir möglicherweise die Grenzen des Komforts überschreiten – zum Beispiel, wenn wir versuchen, Composer für ein großes Projekt auf dem kleinsten VPS auszuführen, das wir erstellen können, oder wenn wir große Dateien auf einem ebenso kleinen Server lesen müssen .
Diese Frage werden wir in diesem Tutorial besprechen.
Den Code für dieses Tutorial finden Sie hier GitHub.
Erfolg messen
Die einzige Möglichkeit, sicher zu wissen, ob die Verbesserungen, die wir an unserem Code vorgenommen haben, funktionieren, besteht darin, eine schlechte Situation zu messen und sie mit der Messung zu vergleichen, nachdem wir die Verbesserungen angewendet haben. Mit anderen Worten: Wir wissen nicht, ob eine „Lösung“ eine Lösung ist, es sei denn, wir wissen, wie sehr sie uns (wenn überhaupt) helfen wird.
Wir können uns auf zwei Indikatoren konzentrieren. Der erste ist die CPU-Auslastung. Wie schnell oder langsam läuft der Prozess ab, mit dem wir es zu tun haben? Zweitens ist die Speichernutzung. Wie viel Speicher benötigt das Skript zur Ausführung? Diese sind normalerweise umgekehrt proportional – das heißt, wir können die Speichernutzung auf Kosten der CPU-Auslastung reduzieren und umgekehrt.
In einem asynchronen Verarbeitungsmodell (z. B. einer PHP-Anwendung mit mehreren Prozessen oder mehreren Threads) sind sowohl die CPU- als auch die Speichernutzung wichtige Überlegungen. In einer herkömmlichen PHP-Architektur wird dies normalerweise immer dann zu einem Problem, wenn Serverbeschränkungen erreicht werden.
Die Messung der CPU-Auslastung in PHP ist schwierig zu erreichen. Wenn Ihnen das wirklich wichtig ist, sollten Sie einen Befehl wie top 的命令。对于Windows，则可用考虑使用Linux子系统，这样你就能够在Ubuntu中使用 top in Ubuntu oder macOS verwenden.
In diesem Tutorial messen wir die Speichernutzung. Wir werfen einen Blick darauf, wie viel Speicher ein „herkömmliches“ Skript benötigt. Wir werden auch einige Optimierungsstrategien implementieren und diese messen. Abschließend hoffe ich, dass Sie eine vernünftige Wahl treffen können.
Hier sind die Methoden, die wir verwenden, um die Speichernutzung anzuzeigen:
// 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];
}Nach dem Login kopieren
Wir werden diese Methoden am Ende des Skripts verwenden, damit wir verstehen können, welches Skript gleichzeitig den meisten Speicher verbraucht.
Welche Möglichkeiten haben wir?
Wir haben viele Möglichkeiten, Dateien effizient zu lesen. Sie werden in den folgenden zwei Szenarien verwendet. Möglicherweise möchten wir alle Daten gleichzeitig lesen und verarbeiten, die verarbeiteten Daten ausgeben oder andere Vorgänge ausführen. Möglicherweise möchten wir den Datenstrom auch transformieren, ohne auf die Daten zuzugreifen.
Stellen Sie sich Folgendes für den ersten Fall vor, wenn wir die Datei lesen und alle 10.000 Datenzeilen zur Verarbeitung an eine separate Warteschlange übergeben möchten. Wir müssten mindestens 10.000 Datenzeilen in den Speicher laden und sie an den Warteschlangenmanager übergeben (je nachdem, welcher verwendet wird).
Angenommen, wir möchten im zweiten Fall den Inhalt einer besonders großen API-Antwort komprimieren. Obwohl uns der Inhalt hier egal ist, müssen wir sicherstellen, dass er in einem komprimierten Format gesichert wird.
In beiden Fällen müssen wir große Dateien lesen. Der Unterschied besteht darin, dass wir im ersten Fall wissen müssen, um welche Daten es sich handelt, während es uns im zweiten Fall egal ist, um welche Daten es sich handelt. Lassen Sie uns als nächstes diese beiden Ansätze ausführlich besprechen ...
Dateien Zeile für Zeile lesen
PHP verfügt über viele Funktionen zum Verarbeiten von Dateien. Lassen Sie uns einige davon kombinieren, um einen einfachen Dateileser zu implementieren
// 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());Nach dem Login kopieren
// 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";Nach dem Login kopieren
Wir lesen einen Text Datei mit allen Werken Shakespeares. Die Dateigröße beträgt ca. 5,5 MB. Die Speicherauslastung erreichte ihren Höhepunkt bei 12,8 MB. Lassen Sie uns nun den Generator verwenden, um jede Zeile zu lesen:
// 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";Nach dem Login kopieren
Die Dateigröße ist gleich, aber die Speicherauslastung erreicht ihren Höhepunkt bei 393 KB. Diese Daten sind nicht sehr aussagekräftig, da wir die Verarbeitung von Dateidaten hinzufügen müssen. Teilen Sie das Dokument beispielsweise in Abschnitte auf, wenn zwei Leerzeilen erscheinen:
// 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";Nach dem Login kopieren
Hat jemand eine Vermutung, wie viel Speicher dieses Mal verwendet wird? Selbst wenn wir das Textdokument in 126 Teile aufteilen, verbrauchen wir immer noch nur 459 KB Speicher. Aufgrund der Art des Generators verwenden wir maximal den Speicher, der zum Speichern des größten Textblocks während der Iteration benötigt wird. In diesem Fall beträgt der größte Block 101985 Zeichen.
Ich habe bereits über Verwendung von Generatoren zur Leistungsverbesserung und Generator-Erweiterungspaket geschrieben. Wenn Sie interessiert sind, können Sie sich weitere verwandte Inhalte ansehen.
Der Generator hat andere Verwendungsmöglichkeiten, eignet sich aber offensichtlich hervorragend zum Lesen großer Dateien. Wenn wir Daten verarbeiten müssen, sind Generatoren wahrscheinlich die beste Lösung.
文件之间的管道
在不需要处理数据的情况下，我们可以将文件数据从一个文件传递到另一个文件。这通常称为管道 (大概是因为除了两端之外，我们看不到管道内的任何东西，当然，只要它是不透明的)。我们可以通过流(stream)来实现，首先，我们编写一个脚本实现一个文件到另一个文件的传输，以便我们可以测量内存使用情况：
// from piping-files-1.php
file_put_contents(
"piping-files-1.txt", file_get_contents("shakespeare.txt")
);
require "memory.php";Nach dem Login kopieren
结果并没有让人感到意外。该脚本比其复制的文本文件使用更多的内存来运行。这是因为脚本必须在内存中读取整个文件直到将其写入另外一个文件。对于小的文件而言，这种操作是 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";Nach dem Login kopieren
这段代码有点奇怪。我们打开两个文件的句柄，第一个处于读取模式，第二个处于写入模式。然后，我们从第一个复制到第二个。我们通过再次关闭两个文件来完成。当你知道内存使用为 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";Nach dem Login kopieren
想象一下应用程度执行到该步骤。这次我们不是要从本地文件系统中获取图像，而是从 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";Nach dem Login kopieren
内存使用比刚才略少(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";Nach dem Login kopieren
其他流
还存在一些流可以通过管道来读写。
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";Nach dem Login kopieren
这段代码虽然整洁，但是总共使用了大概 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";
Nach dem Login kopieren
在这里，我们可以看到 php:///filter/zlib.deflate 过滤器，该过滤器读取和压缩资源的内容。然后我们可以将该压缩数据通过管道传输到另一个文件中。这仅使用了 896KB 内存。
虽然格式不同，或者说使用 zip 压缩文件有其他诸多好处。但是，你不得不考虑：如果选择其他格式你可以节省 12 倍的内存，你会不会心动？
要对数据进行解压，只需要通过另外一个 zlib 过滤器:
// from filters-2.php
file_get_contents(
"php://filter/zlib.inflate/resource=filters-2.deflated"
);
Nach dem Login kopieren
关于流，在 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);Nach dem Login kopieren
本例中，我们尝试发送一个 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 )
}Nach dem Login kopieren
我们并不打算实现其中一个，因为我认为它值得拥有自己的教程。有很多工作要做。但是一旦完成工作，我们就可以很容易地注册流包装器：
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");Nach dem Login kopieren
同样，也可以创建自定义流过滤器。 文档 有一个示例过滤器类：
Filter {
public $filtername;
public $params
public int filter ( resource $in , resource $out , int &$consumed ,
bool $closing )
public void onClose ( void )
public bool onCreate ( void )
}Nach dem Login kopieren
可被轻松注册
$handle = fopen("story.txt", "w+");
stream_filter_append($handle, "highlight-names", STREAM_FILTER_READ);Nach dem Login kopieren
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视频教程》
Das obige ist der detaillierte Inhalt vonLassen Sie uns darüber sprechen, wie Sie PHP zum Lesen großer Dateien verwenden (Tutorial-Sharing).. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
