将生成的进程中的数据保存到 Javascript 中的变量中

Question

I am having issues saving the results from a spawned python process. After converting data into json, I push the data to an array defined within the function before the spawn process is called, but the array keeps returning undefined. I can console.log and show the data correctly, but the array that is returned from the function is undefined. Any input would be greatly appreciated. Thanks in advance.

function sonar_projects(){
    const projects = [];
    let obj;
    let str = '';
    const projects_py = spawn('python', ['sonar.py', 'projects']);
    let test = projects_py.stdout.on('data', function(data){
        let projects = [];
        let json = Buffer.from(data).toString()
        str += json
        let json2 = json.replace(/'/g, '"')
        obj = JSON.parse(json2)
        console.log(json2)
        for(var dat in obj){
            var project = new all_sonar_projects(obj[dat].key, obj[dat].name, obj[dat].qualifier, obj[dat].visibility, obj[dat].lastAnalysisDate);
            projects.push(project); 
        }   
        for (var i= 0; i < projects.length; i++){
             console.log(projects[i].key + ' ' + projects[i].name + '  ' + projects[i].qualifier + '  ' + projects[i].visibility + '  ' + projects[i].lastAnalysisDate)
        }
        console.log(projects)
        return projects;
    });  
}

Answer 1

First of all, going through the NodeJS documentation, we have

1. Child Process
2. [child_process.spawn(command , args][, options])
3. Child Process Class
4. Stream
5. Stream Readable Event "data"

Even though projects_py.stdout.on(event_name, callback) accepts an callback, it returns either the EventEmitter -like object, where the events are registered (in this case, stdout that had it's method on called), or the parent element (the ChildProcess named projects_py ).

It's because the callback function will be called every time the "data" event occurs. So, if the assign of the event returned the same as the callback function, it'd return only one single time, and then every next happening of the "data" event would be processed by the function, but not would be done.

In this kind of situation, we need a way to collect and compile the data of the projects_py.stdout.on("data", callback) event after it's done. You already have the collecting part. Now see the other:

Right before you create the on "data" event, we create a promise to encapsulate the process:

    // A promise says "we promise" to have something in the future,
    //  but it can end not happening
    var promise = new Promise((resolve, reject) => {
        // First of all, we collect only the string data
        //  as things can come in parts
        projects_py.stdout.on('data', function(data){
            let json = Buffer.from(data).toString()
            str += json
        });
        
        // When the stream data is all read,
        //  we say we get what "we promised", and give it to "be resolved"
        projects_py.stdout.on("end", () => resolve(str));
        
        // When something bad occurs,
        //  we say what went wrong
        projects_py.stdout.on("error", e => reject(e));
        
    // With every data collected,
    //  we parse it (it's most your code now)
    }).then(str => {
        let json2 = str.replace(/'/g, '"')
        // I changed obj to arr 'cause it seems to be an array
        let arr = JSON.parse(json2)
        //console.log(json2)
        
        const projects = []
        // With for-of, it's easier to get elements of
        //  an object / an array / any iterable
        for(var dat of arr){
            var project = new all_sonar_projects(
                dat.key, dat.name, dat.qualifier,
                dat.visibility, dat.lastAnalysisDate
            );
            projects.push(project); 
        }
        
        // Template strings `a${variable or expression}-/b`
        //  are easier to compile things into a big string, yet still fast
        for(var i = 0; i < projects.length; i++)
            console.log(
                `${projects[i].key} ${projects[i].name} ` +
                `${projects[i].qualifier}  ${projects[i].visibility} ` +
                projects[i].lastAnalysisDate
            )
        console.log(projects)
        
        // Your projects array, now full of data
        return projects;
    // Finally, we catch any error that might have happened,
    //  and show it on the console
    }).catch(e => console.error(e));
}

Now, if you want to do anything with your array of projects, there are two main options:

Promise (then / catch) way

// Your function
function sonar_projects(){
    // The new promise
    var promise = ...
    
    // As the working to get the projects array
    //  is already all set up, you just use it, but in an inner scope
    promise.then(projects => {
        ...
    });
}

Also, you can just return the promise variable and do the promise-things with it out of sonar_projects (with then / catch and callbacks).

async / await way

// First of all, you need to convert your function into an async one:
async function sonar_projects(){
    // As before, we get the promise
    var promise = ...
    
    // We tell the function to 'wait' for it's data
    var projects = await promise;
    
    // Do whatever you would do with the projects array
    ...
}