Regex-based line deletion script (JS) not working

Question

I have an script that reads the file and compares the string by a pattern, if it returns false it will delete the line on the .txt file.

This is my code

const readline = require('readline');
const lineReplace = require('line-replace')
const fs = require('fs');
const inputFileName = './outputfinal.txt';

const readInterface = readline.createInterface({
    input: fs.createReadStream(inputFileName),
});

let testResults = [];
readInterface.on('line', line => {
    testResult = test(line);
    console.log(`Test result (line #${testResults.length+1}): `, testResult);
    testResults.push({ input: line, testResult } );
    if (testResult == false){
        console.log(`Line #${testResults.length} will get deleted from this list`);
        lineReplace({
          file: './outputfinal.txt',
          line: testResults.length,
          text: '',
          addNewLine: false,
          callback: onReplace   
        });

        function onReplace({file, line, text, replacedText}) {

        };
    };
});

// You can do whatever with the test results here.
//readInterface.on('close', () => {
//    console.log("Test results:", testResults);
//});

function test(str){

    let regex = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/; // email regex

    str = str.split(","); 

    // string should be of length 3 with str[1] number of length 7
    if(str && str.length === 3 && Number(str[1]) && str[1] ) {

        let temp = str[0].split("-");

        // check for 85aecb80-ac00-40e3-813c-5ad62ee93f42 separately.
        if(temp && temp.length === 5 &&  /[a-zA-Z\d]{8}/.test(temp[0]) &&  /[a-zA-Z\d]{4}/.test(temp[1]) &&  /[a-zA-Z\d]{4}/.test(temp[2]) &&  /[a-zA-Z\d]{4}/.test(temp[3]) &&  /[a-zA-Z\d]{12}/.test(temp[4])){

            // email regex
            if(regex.test(str[2])) {
                return true;
            } else {
                return false;
            }
        } else { 
            return false
        }
    } else {
        return false;
    }
}

But isn't working, returns error no such file or directory, I dont think that is the correct way to do a line remover script

Answer 1

First, if the error is "no such file or directory" is because the file doesn't exist. Please check the file exists at first in the same root of your project.

Second, don't use the library "line-replace", if you check the code this create a tmp file and rewrite all the file in a tmp with the replacement. When finish the process the tmp file is renamed to the original.

Third, if you analyze the code the "lineReplace" is async. So there will sometimes to try to open multiple times the file at the same time and consequently write it at same time again. This will create an unsuspected result.

The best recommendation is you must see how File works and Promises (async) in nodejs:

• https://nodejs.org/api/fs.html
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise
• https://itnext.io/javascript-promises-with-node-js-e8ca827e0ea3

If you see the next code, you will see the next steps:

• Create the tmp Route
• Create the tmp File
• Create a promise:
  • Create a readline interface
  • Process each line with a try catch to reject in case of error
  • When finish the process replace the tmp file to original file with a try-catch to reject in case of error
• Wait to finish the promise, in case of error delete the tmp file

const fs = require('fs');
const readline = require('readline');

async function replaceLineWithConditional(pathFile, conditional) {
    // tmpFile name
    const tmpFilePath = `${pathFile}.tmp`;

    // Create write stream
    const tmpStream = fs.createWriteStream(tmpFilePath);

    // Process it
    const processFile = new Promise((resolve, reject) => {
        const rl = readline.createInterface({
            input: fs.createReadStream(pathFile),
        });

        // Process line
        rl.on("line", (input) => {
            try {
                if (conditional(input)) {
                    tmpStream.write(input); // input
                    tmpStream.write("\n"); // linejump
                }
            } catch (err) {
                // Reject error
                reject(err);
            }
        });

        // Finish
        rl.on("close", () => {
            try {
                // Move the tmpFile
                tmpStream.close();
                fs.renameSync(tmpFilePath, pathFile);

                // Resolve it
                resolve(true);
            } catch (err) {
                // Reject error
                reject(err);
            }
        });
    });

    try {
        // Await the promise
        return await processFile;
    } catch (err) {
        // Delete the tmp file and throw the error
        tmpStream.close();
        fs.unlinkSync(tmpFilePath);
        throw err;
    }
}

So you could call the function with your conditional function process as a callback. For example, I want to keep it all the lines who have a length more than 3 and not start with "a":

// async/await:
await replaceLineWithConditional("./test.txt", (line) => {
    return line.length > 3 && /^[^a]/.test(line);
});

// then/catch:
replaceLineWithConditional("./test.txt", (line) => {
    return line.length > 3 && /^[^a]/.test(line);
}).then(...).catch(...);

input:

Hi
Hello
abcdef
a
lalalal

output:

Hello
lalalal

If you want the file don't finish with the end line. (take a note: Why should text files end with a newline?) this can be a Quiz problem to test knowledge in the fs library :)