Une brève analyse de la façon dont Nodejs lit et écrit des fichiers volumineux

L'auteur a récemment effectué un travail de lecture, d'écriture et de téléchargement fragmenté du côté node Au cours de ce processus, j'ai découvert que si le fichier lu par le nœud dépasse 2G et dépasse le Blob maximum lu, un. une exception de lecture se produira. De plus, la lecture et l'écriture de fichiers dans le nœud sont également soumises aux restrictions de RAM du serveur, etc., et doivent être lues par tranches. J'enregistrerai les problèmes rencontrés et le processus de leur résolution. [Tutoriels associés recommandés : Tutoriel vidéo Nodejs]

• Lecture et écriture de fichiers dans node
• Lecture et écriture de fichiers de nœud RAM et restrictions de taille de Blob
• Autres

1. Lecture et écriture de fichiers dans node

1.1 Lecture et écriture régulières de fichiers

Régulièrement, si l'on souhaite lire un fichier relativement petit, on peut passer directement :

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

De manière générale, la méthode de synchronisation n'est pas très recommandée, car js/nodejs est unique- threaded Oui, la méthode synchronisée bloquera le thread principal. La dernière version de node fournit directement fs.promise, qui peut être utilisé directement en combinaison avec async/await :

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 ...>

L'appel de méthode asynchrone ici ne bloquera pas le thread principal, et les IO de plusieurs lectures de fichiers peuvent également être effectuées dans parallèle.

1.2 Lecture et écriture de fichiers en flux

Pour la lecture et l'écriture de fichiers conventionnelles, nous lirons le fichier dans la mémoire en une seule fois. Cette méthode a une très faible efficacité en termes de temps et une faible efficacité en termes de temps signifie qu'elle doit l'être. effectué une fois L'exécution ultérieure ne peut être effectuée qu'une fois la lecture initiale terminée. Une faible efficacité de la mémoire signifie que le fichier doit être lu et mis en mémoire en même temps, ce qui occupe beaucoup de mémoire. Par conséquent, dans ce cas, nous utilisons généralement Stream pour lire des fichiers :

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 ...>

La lecture et l'écriture de fichiers via Steam peuvent améliorer l'efficacité de la mémoire et du temps.

• Efficacité de la mémoire : il n'est pas nécessaire de charger une grande quantité (ou la totalité) des données en mémoire avant de les traiter
• Efficacité du temps : une fois que vous avez les données, vous pouvez commencer le traitement, ce qui réduit considérablement le temps de démarrage du traitement les données sans avoir à attendre. L'intégralité des données est chargée avant traitement.

Les fichiers Stream prennent également en charge la deuxième méthode d'écriture :

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. Limitations de lecture et d'écriture des fichiers de nœuds dans la RAM et la taille du Blob

2.1 Problèmes de base

Lors de la lecture de fichiers volumineux, la taille du fichier sera lue limite, par exemple, nous lisons actuellement un fichier vidéo de 2,5 Go :

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

L'exécution du code ci-dessus signalera une erreur :

RangeError [ERR_FS_FILE_TOO_LARGE] : La taille du fichier (2246121911) est supérieure à 2 Go

Nous pourrions penser qu'en définissant l'option, NODE_OPTIONS='--max-old-space-size=5000', à ce moment 5000M>2.5G, mais l'erreur n'a toujours pas disparu, ce qui signifie que la limite de taille des fichiers de lecture du nœud ne peut pas être modifiée via Options.

La méthode ci-dessus est la manière conventionnelle de lire des fichiers volumineux. Existe-t-il une limite de taille de fichier s'il est lu via Steam ? Par exemple :

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()

Il n'y aura aucune exception lors de la lecture d'un fichier de 2,5 Go de la manière ci-dessus, mais veuillez noter qu'il y a une erreur ici :

data += chunk;
                ^

RangeError: Invalid string length

C'est parce que la longueur des données dépasse la limite maximale, par exemple 2048 Mo. , etc. Par conséquent, lors du traitement avec Steam, lors de la sauvegarde des résultats de lecture, faites attention à la taille du fichier, qui ne doit pas dépasser la valeur maximale par défaut du Buffer. Dans le cas ci-dessus, nous n'avons pas besoin de data += chunk pour sauvegarder toutes les données dans un fichier volumineux, nous pouvons les lire et les traiter en même temps.

2.2 Lecture segmentée

Pendant le processus de lecture de fichiers, createReadStream peut en fait lire par segments. Cette méthode de lecture segmentée peut également être utilisée comme alternative pour lire des fichiers volumineux. En particulier lors de lectures simultanées, il présente certains avantages et peut améliorer la vitesse de lecture et de traitement des fichiers.

CreateReadStream accepte le deuxième paramètre {start, end}. Nous pouvons obtenir la taille du fichier via fs.promises.stat, puis déterminer les fragments et lire le dernier fragment d'un coup, par exemple :

1. Obtenir la taille du fichier

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

2. Fragment selon la TAILLE spécifiée ( comme 128 Mo par fragment Film)

  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. Implémentez la fonction de lecture

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', () => {
      ...
    })
}

Il convient de noter que fs.createReadStream(filepath,{start,end}), le début et la fin sont fermés devant et derrière, comme fs.createReadSteam(filepath,{ start:0,end:1023}) lit [0,1023], un total de 1024 bits.

3. Autres

3.1 Développez la lecture et l'écriture de fichiers volumineux côté navigateur

Nous avons déjà lu des fichiers volumineux dans nodejs, y a-t-il donc des problèmes avec la lecture de fichiers volumineux côté navigateur ?

    浏览器在本地读取大文件时，之前有类似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 教程！

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!