Mari bercakap tentang cara menggunakan PHP untuk membaca fail besar (perkongsian tutorial)

Bagaimana untuk membaca fail besar dalam PHP? Artikel berikut akan memperkenalkan kepada anda cara menggunakan PHP untuk membaca fail besar saya harap ia akan membantu anda!

Sebagai pembangun PHP, kami tidak perlu risau tentang pengurusan memori. Enjin PHP melakukan kerja yang sangat baik untuk membersihkan di belakang kami, dan model pelayan web konteks pelaksanaan sementara bermakna walaupun kod yang paling ceroboh tidak mempunyai kesan yang berkekalan.

Pada masa yang jarang berlaku, kita mungkin perlu melangkah keluar dari sempadan keselesaan — contohnya, apabila kita cuba menjalankan Komposer untuk projek besar pada VPS terkecil yang boleh kita buat, atau apabila kita perlu membaca fail besar pada masa fail pelayan yang sama kecil.

Ini ialah soalan yang akan kita bincangkan dalam tutorial ini.

Kod untuk tutorial ini boleh didapati di sini GitHub.

Mengukur kejayaan

Satu-satunya cara untuk mengesahkan bahawa penambahbaikan yang kami buat pada kod kami adalah berkesan adalah dengan mengukur situasi yang buruk dan kemudian membandingkannya dengan tempat kami telah menggunakan penambahbaikan pengukuran seterusnya. Dalam erti kata lain, kita tidak tahu sama ada "penyelesaian" adalah penyelesaian melainkan kita tahu berapa banyak (jika ada) ia akan membantu kita.

Kita boleh fokus pada dua penunjuk. Yang pertama ialah penggunaan CPU. Seberapa cepat atau lambat proses yang kita hadapi berjalan? Kedua ialah penggunaan memori. Berapa banyak memori yang diperlukan oleh skrip untuk dilaksanakan? Ini biasanya berkadar songsang - bermakna kita boleh mengurangkan penggunaan memori dengan mengorbankan penggunaan CPU, dan sebaliknya.

Dalam model pemprosesan tak segerak (seperti aplikasi PHP berbilang proses atau berbilang benang), kedua-dua penggunaan CPU dan memori adalah pertimbangan penting. Dalam seni bina PHP tradisional, ini biasanya menjadi masalah apabila kekangan pelayan dicapai.

Mengukur penggunaan CPU dalam PHP sukar dicapai. Jika anda benar-benar mengambil berat tentang perkara ini, pertimbangkan untuk menggunakan arahan seperti top dalam Ubuntu atau macOS. Untuk Windows, pertimbangkan untuk menggunakan subsistem Linux supaya anda boleh menggunakan perintah top dalam Ubuntu.

Dalam tutorial ini kita akan mengukur penggunaan memori. Kami akan melihat berapa banyak memori yang akan digunakan oleh skrip "tradisional". Kami juga akan melaksanakan beberapa strategi pengoptimuman dan mengukurnya. Akhir sekali, saya harap anda boleh membuat pilihan yang munasabah.

Berikut ialah kaedah yang akan kami gunakan untuk melihat penggunaan memori:

// 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];
}

Kami akan menggunakan kaedah ini pada penghujung skrip supaya kami dapat melihat skrip mana yang menggunakan paling banyak memori pada satu masa.

Apakah pilihan kami?

Kami mempunyai banyak cara untuk membaca fail dengan cekap. Ia digunakan dalam dua senario berikut. Kami mungkin mahu membaca dan memproses semua data pada masa yang sama, mengeluarkan data yang diproses atau melakukan operasi lain. Kami juga mungkin ingin mengubah aliran data tanpa mengakses data.

Bayangkan perkara berikut, untuk kes pertama, jika kita mahu membaca fail dan menyerahkan setiap 10,000 baris data ke baris gilir yang berasingan untuk diproses. Kami perlu memuatkan sekurang-kurangnya 10,000 baris data ke dalam memori dan menyerahkannya kepada pengurus baris gilir (yang mana satu digunakan).

Untuk kes kedua, katakan kita mahu memampatkan kandungan respons API yang sangat besar. Walaupun kami tidak peduli apa kandungannya di sini, kami perlu memastikan ia disandarkan dalam format termampat.

Dalam kedua-dua kes, kita perlu membaca fail yang besar. Perbezaannya ialah dalam kes pertama kita perlu tahu apa itu data, manakala dalam kes kedua kita tidak kisah apa itu data. Seterusnya, mari kita bincangkan kedua-dua pendekatan ini secara mendalam...

Baca fail baris demi baris

PHP mempunyai banyak fungsi untuk memproses fail, mari kita senaraikan beberapa fungsi digabungkan untuk melaksanakan pembaca fail ringkas

// 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";

Kami sedang membaca fail teks yang mengandungi keseluruhan karya Shakespeare. Saiz fail adalah lebih kurang 5.5 MB. Penggunaan memori memuncak pada 12.8 MB. Sekarang, mari gunakan penjana untuk membaca setiap baris:

// 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";

Saiz fail adalah sama, tetapi penggunaan memori memuncak pada 393 KB. Data ini tidak begitu bermakna, kerana kita perlu menambah pemprosesan data fail. Sebagai contoh, apabila dua baris kosong muncul, bahagikan dokumen kepada beberapa bahagian:

// 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";

Sesiapa sahaja meneka berapa banyak memori yang digunakan kali ini? Walaupun kita membahagikan dokumen teks kepada 126 bahagian, kita masih hanya menggunakan 459 KB memori. Memandangkan sifat penjana, memori maksimum yang akan kami gunakan ialah memori yang diperlukan untuk menyimpan sebahagian besar teks semasa lelaran. Dalam kes ini, blok terbesar ialah 101985 aksara.

Saya telah pun menulis Menggunakan penjana untuk meningkatkan prestasi dan Pakej sambungan penjana Jika anda berminat, anda boleh menyemak lebih banyak kandungan yang berkaitan.

Penjana mempunyai kegunaan lain, tetapi jelas ia berfungsi dengan baik untuk membaca fail besar. Jika kita perlu memproses data, penjana mungkin merupakan cara terbaik untuk digunakan.

文件之间的管道

在不需要处理数据的情况下，我们可以将文件数据从一个文件传递到另一个文件。这通常称为管道 (大概是因为除了两端之外，我们看不到管道内的任何东西，当然，只要它是不透明的)。我们可以通过流(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视频教程》

Atas ialah kandungan terperinci Mari bercakap tentang cara menggunakan PHP untuk membaca fail besar (perkongsian tutorial). Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!