Как проанализировать несколько больших XML-файлов с хорошей производительностью и балансом использования памяти?

Попробуйте выполнить сценарий PS

using assembly System.Xml.Linq

$xmlFilename = 'c:\temp\test.xml'
$reader = [System.Xml.XmlReader]::Create($xmlFilename)
$table = [System.Collections.ArrayList]::new()

While(-not $reader.EOF)
{
    if ($reader.Name -ne 'Offerte')
    {
        $reader.ReadToFollowing('Offerte') | out-null;
    }
    if (-not $reader.EOF)
    {
        $offerte = [System.Xml.Linq.XElement][System.Xml.Linq.XElement]::ReadFrom($reader);
        $codice = $offerte.Element('codice').Value
        $nome = $offerte.Element('nome').Value
        $stato = $offerte.Element('stato').Value

       $newRow = [pscustomobject]@{
           codice = $codice
           nome = $nome
           stato = $stato
       }
       $table.Add($newRow) | out-null  
    }
}
$table

Мне удалось решить свою проблему, следуя тому, что предложил jdweng с помощью его ps-скрипта, а затем я вернулся к своему первому решению синтаксического анализа, которое похоже на его.

Сначала я решил получить файлы из папки прямо из node.js, а не переносить их с фронтенда на бэкенд, потому что упаковывать и отправлять их будет очень долго.

Затем я попытался прочитать файлы целиком, но те файлы были слишком большими, и моя память терпела сбой, поэтому я реализовал логику чтения по частям.

Итак, для тех, кто борется с чем-то похожим на мой случай, я сделал это:

Достаём файлы из папки и начинаем читать их по одному:

async function getExcelRows(filterNome, filterStato){
        let result = [];
    
        const fileNames = await readFolder();
    
        for(let fileName of fileNames){
            const response = await readAndParseFile(folderPath+fileName, filterNome, filterStato);
    
            result.push(...response);
        }
        return JSON.stringify(result);
    }

Реализация для чтения папки:

async function readFolder(){
    const files = await fsp.readdir(folderPath);
    return files.filter(file => file.endsWith('.xml'));
}

Реализация чтения файлов частями:

async function readAndParseFile(filePath, filterNome, filterStato){

    return new Promise((resolve, reject) => {
        let keeper = {};
        let isToErase = true;
        let result = [];

        const re = new RegExp("<"+objTag+">", 'g');

        const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });

        stream.on('data', async (chunk) => {
            
            if (isToErase){
                keeper = {};
                keeper.remain = chunk;
            }
            else{
                if (keeper.remain.indexOf("<"+objTag+">") != -1)
                    testFileOfferteNumber--;
                keeper.remain +=chunk;
            }

            testFileOfferteNumber += keeper.remain.match(re).length;

            if (keeper.remain.indexOf("<"+objTag+">") !== -1){
                keeper = await parseFile(keeper.remain, filterNome, filterStato);
                if (keeper?.result.length > 0){
                    result.push(...keeper.result);
                    keeper.result = [];
                }
                if (keeper?.remain != "")
                    isToErase = false;
                else
                    isToErase = true;
            }
        });

        stream.on('end', () => {
            resolve(result);
        });

        stream.on('error', (error) => {
            reject(error);
        });
    });
}

Переменная testFileOfferteNumber должна была проверять, действительно ли я обрабатывал все теги без ошибок, не более того.

Итак, здесь мы читаем файл частями, и если после анализа у меня все еще остается неполный контент, я возвращаю его обратно в эту функцию и устанавливаю для isToErase значение false, если это так, чтобы следующий фрагмент был добавлен к моему текущему оставшемуся фрагменту. содержание. В противном случае я просто беру новый фрагмент и обрабатываю его.

Реализация логики синтаксического анализа:

// objTag = "Offerte"
// filterNome = ["andrea"]
// filterStato = "italia"
function parseFile(source, filterNome, filterStato){
    return new Promise((resolve, reject)=>{
        try{
            const endTagLen = ("</"+objTag+">").length;
            let result = [];
            while(source.indexOf("<"+objTag+">") !== -1){

                if (source.indexOf("</"+objTag+">") === -1)
                    return resolve({result: result, remain: source});

                testResultOfferteNumber++;

                if (
                    !checkNomeFilter(filterNome, checkField(source, 'nome') ? getField(source, "nome") : "") ||
                    !checkStato(filterStato, checkField(source, 'stato') ? getField(source, "stato") : "")
                ){
                    source = source.slice(source.indexOf("</"+objTag+">")+endTagLen);
                    continue;
                }
                
                const obj = {
                    codice: checkField(source, 'codice') ? getField(source, "codice") : "",
                    nome: checkField(source, 'nome') ? getField(source, "nome") : "",
                    stato: checkField(source, 'stato') ? getField(source, "stato") : "",
                }

                source = source.slice(source.indexOf("</"+objTag+">")+endTagLen);

                result.push(obj);
            }
            resolve({result: result, remain: source});
        }
        catch(e){
            reject(e);
        }
    });
}

testResultOfferteNumber — это переменная, которую нужно сравнить с предыдущей, чтобы проверить, правильно ли обработаны все теги.

Итак, здесь я перебираю все теги «Offerte», пока они есть, и в этом «пока» я проверяю, есть ли закрывающий тег, если нет, я возвращаю все, что осталось, в функцию чтения, которая добавит следующий фрагмент текста к этому тексту, при этом он сможет впоследствии проверить это содержимое.

После этого я применяю свои фильтры, чтобы избежать анализа данных, которые не принимаются до их анализа, а затем, поскольку я знаю структуру xml, я просто извлекаю все 3 тега, которые мне нужны, одновременно.

После этого анализа я отсекаю уже разобранную часть файла и перезапускаю цикл с новым содержимым в <Offerte>...</Offerte>.

Я оставил размер фрагмента по умолчанию, который у меня отлично работал: 3000 файлов были обработаны примерно за 20-30 минут без сбоев.

В моем случае мне нужно было вернуть результат в виде строки, чтобы я мог создать файл Excel.

Я надеюсь, что это решение поможет кому-то, как я, спасибо всем, кто помог мне с этой проблемой, особенно jdweng.