Analisis ringkas tentang cara Nodejs membaca dan menulis fail besar

Pengarang baru-baru ini sedang melakukan beberapa kerja membaca, menulis dan memuat naik berpecah-belah di bahagian nod Semasa proses ini, saya mendapati bahawa jika fail dibaca oleh nod melebihi 2G, ia akan melebihi 2G Untuk membaca nilai maksimum Blob, pengecualian baca akan berlaku Selain itu, membaca dan menulis fail dalam nod juga dihadkan oleh RAM pelayan dalam kepingan saya akan merekodkan masalah yang dihadapi dan cara menyelesaikannya. [Cadangan tutorial berkaitan: tutorial video nodejs]

• Membaca dan menulis fail dalam nod
• Membaca dan menulis fail nod RAM dan sekatan saiz Blob
• Lain-lain

1. Membaca dan menulis fail dalam nod

1.1 Membaca dan menulis fail umum

Biasanya, jika kita ingin membaca fail yang agak kecil, kita boleh terus menghantar:

const fs = require('fs')
let data = fs.readFileSync("./test.png")
console.log(data,123)
//输出data = <Buffer 89 50 4e ...>

Secara umumnya, kaedah penyegerakan tidak disyorkan kerana js/nodejs adalah satu-benang. Ya, kaedah yang disegerakkan akan menyekat utas utama. Versi terbaharu nod secara langsung menyediakan fs.promise, yang boleh digunakan secara langsung dalam kombinasi dengan async/wait:

const fs = require('fs')
const readFileSync = async () => {
    let data = await fs.promises.readFile("./test.png")
    console.log(data,123)
}
readFileSync()
//输出data = <Buffer 89 50 4e ...>

Panggilan kaedah tak segerak di sini tidak akan menyekat urutan utama dan IO berbilang fail bacaan juga boleh selari.

1.2 Strim membaca dan menulis fail

Untuk membaca dan menulis fail konvensional, kami akan membaca fail ke dalam ingatan pada satu-satu masa . Oleh itu, dalam kes ini, kami biasanya menggunakan Strim untuk membaca fail:

const fs = require('fs')
const readFileTest = () => {
    var data = ''
    var rs = fs.createReadStream('./test.png');
    rs.on('data', function(chunk) {
        data += chunk;
        console.log(chunk)
     });
    rs.on('end',function(){
        console.log(data);
    });
    rs.on('error', function(err){
        console.log(err.stack);
     });
}
readFileTest()
// data = <Buffer 89 50 64 ...>

Membaca dan menulis fail melalui Steam boleh meningkatkan kecekapan memori dan kecekapan masa.

• Kecekapan ingatan: Tidak perlu memuatkan sejumlah besar (atau keseluruhan data) dalam ingatan sebelum memproses data
• Kecekapan masa: Sebaik sahaja anda mempunyai data, anda boleh mula pemprosesan, yang sangat Mengurangkan masa yang diperlukan untuk mula memproses data dan bukannya perlu menunggu sehingga keseluruhan data dimuatkan.

Fail strim juga menyokong kaedah penulisan kedua:

const fs = require('fs')
const readFileTest = () => {
    var data = ''
    var chunk;
    var rs = fs.createReadStream('./test.png');
    rs.on('readable', function() {
    while ((chunk=rs.read()) != null) {
        data += chunk;
    }});
    rs.on('end', function() {
        console.log(data)
    });
};
readFileTest()

2. Fail nod baca dan tulis RAM dan sekatan saiz Blob

2.1 Isu Asas

Apabila membaca fail besar, akan ada had pada saiz fail yang dibaca Sebagai contoh, kami sedang membaca fail video 2.5G:

const fs = require('fs')
const readFileTest = async () => {
    let data = await fs.promises.readFile("./video.mp4")
    console.log(data)
}
readFileTest()

Melaksanakan kod di atas akan melaporkan ralat:

RangeError [ERR_FS_FILE_TOO_LARGE]: Saiz fail (2246121911) lebih besar daripada 2 GB

Kami mungkin berfikir bahawa dengan menetapkan pilihan, NODE_OPTIONS= '--max-old-space-size=5000', pada masa ini 5000M>2.5G, tetapi ralat masih tidak hilang, yang bermaksud bahawa had saiz fail yang dibaca oleh nod tidak boleh diubah melalui Pilihan.

Di atas adalah cara konvensional untuk membaca fail besar Adakah terdapat had saiz fail jika ia dibaca melalui Steam? Contohnya:

const fs = require('fs')
const readFileTest = () => {
    var data = ''
    var rs = fs.createReadStream('./video.mp4');
    rs.on('data', function(chunk) {
        data += chunk;
     });
    rs.on('end',function(){
        console.log(data);
    });
    rs.on('error', function(err){
        console.log(err.stack);
     });
}
readFileTest()

Tidak akan terkecuali apabila membaca fail 2.5G dengan cara di atas, tetapi perlu diingat bahawa terdapat ralat di sini:

data += chunk;
                ^

RangeError: Invalid string length

Di kali ini, ia adalah kerana data Panjang melebihi had maksimum, seperti 2048M, dsb. Oleh itu, apabila memproses dengan Steam, apabila menyimpan hasil bacaan, perhatikan saiz fail, yang tidak boleh melebihi nilai maksimum lalai Penampan. Dalam kes di atas, kita tidak memerlukan data = chunk untuk menyimpan semua data dalam data yang besar Kita boleh membaca dan memprosesnya pada masa yang sama.

2.2 Bacaan Bersegmen

Semasa proses membaca fail, createReadStream sebenarnya boleh membacanya dalam segmen Kaedah membaca bersegmen ini juga boleh digunakan Sebagai alternatif kepada membaca fail besar. Lebih-lebih lagi apabila membaca secara serentak, ia mempunyai kelebihan tertentu dan boleh meningkatkan kelajuan pembacaan dan pemprosesan fail.

createReadStream menerima parameter kedua {start, end}. Kita boleh mendapatkan saiz fail melalui fs.promises.stat, kemudian tentukan serpihan dan baca serpihan terakhir sekali, sebagai contoh:

Dapatkan saiz fail

const info = await fs.promises.stat(filepath)
   const size = info.size

Serpihan mengikut saiz yang ditentukan (seperti 128m per shard)

  const SIZE = 128 * 1024 * 1024
  let sizeLen = Math.floor(size/SIZE)
    let total = sizeLen +1 ;
    for(let i=0;i<=sizeLen;i++){
      if(sizeLen ===i){
        console.log(i*SIZE,size,total,123)
        readStremfunc(i*SIZE,size,total)
      }else{
        console.log(i*SIZE,(i+1)*SIZE,total,456)
        readStremfunc(i*SIZE,(i+1)*SIZE-1,total)
      }
    }
  //分片后【0,128M】,【128M, 256M】...

3. perlu diperhatikan bahawa fs .createReadStream(filepath,{start,end}), start dan end ditutup sebelum dan selepas Contohnya, fs.createReadSteam(filepath,{start:0,end:1023}) berbunyi [0,1023] , sejumlah 1024 bit.

const readStremfunc = () => {
    const readStream =  fs.createReadStream(filepath,{start:start,end:end})
    readStream.setEncoding('binary')
    let data = ''
    readStream.on('data', chunk => {
        data = data + chunk
    })
    readStream.end('data', () => {
      ...
    })
}

3. Lain-lain

3.1 Kembangkan bacaan dan penulisan fail besar di sebelah penyemak imbas

Fail besar itu adalah disimpan dalam nodejs lebih awal Jadi adakah terdapat sebarang masalah dengan membaca fail besar di sebelah penyemak imbas?

    浏览器在本地读取大文件时，之前有类似FileSaver、StreamSaver等方案，不过在浏览器本身添加了File的规范，使得浏览器本身就默认和优化了Stream的读取。我们不需要做额外的工作，相关的工作：github.com/whatwg/fs。不过不同的版本会有兼容性的问题，我们还是可以通过FileSaver等进行兼容。

3.2 请求静态资源大文件

    如果是在浏览器中获取静态资源大文件，一般情况下只需要通过range分配请求即可，一般的CDN加速域名，不管是阿里云还是腾讯云，对于分片请求都支持的很好，我们可以将资源通过cdn加速，然后在浏览器端直接请求cdn加速有的资源。

    分片获取cdn静态资源大文件的步骤为，首先通过head请求获取文件大小：

const getHeaderInfo = async (url: string) => {
  const res: any = await axios.head(url + `?${Math.random()}`);
  return res?.headers;
};
const header = getHeaderInfo(source_url)
const size = header['content-length']

我们可以从header中的content-length属性中，获取文件的大小。然后进行分片和分段，最后发起range请求：

const getRangeInfo = async (url: string, start: number, end: number) => {
    const data = await axios({
      method: 'get',
      url,
      headers: {
        range: `bytes=${start}-${end}`,
      },
      responseType: 'blob',
    });
    return data?.data;
  };

在headers中指定 range: bytes=${start}-${end},就可以发起分片请求去获取分段资源，这里的start和end也是前闭后闭的。

更多node相关知识，请访问：nodejs 教程！

Atas ialah kandungan terperinci Analisis ringkas tentang cara Nodejs membaca dan menulis fail besar. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!