Forking tasks workflow in Javascript

What you have to understand in nodejs is it's asynchronious nature, the code is not really executed in order as you have written it! (atleast, a lot of times..)

The childProcess is a process handle which will be returned immediatly. But the forked process itself may take some time to start. What you do, is to add a callback which will be executed every time, a message event is received. Check this code:

parent.js

let childProcess = fork('function.js');

// this line is executed immedatly after the handle is created.
// You pass a newly created function to the ".on()" function which will be 
// called everytime, the child process sends a "message" event.
// you want to understand, that you just declare an anonymious `function`
// and pass it as argument. So the executed function has actually to decide
// when to call it!.
childProcess.on('message', (m) => {
    console.log('message received in parent:', m)
    console.log('closing the process')
    childProcess.kill('SIGINT')
});


childProcess.on('exit', () => {
    console.log('child is done!')
})

childProcess.send('I will come back!')

console.log('last line reached. Program still running.')

function.js

process.on('message', (msg) => {

    // wait a few seconds, and return the message!
    setTimeout(() => {
        process.send(msg)
        // wait 2000ms
    }, 2000)
}

output

last line reached. Program still running.
message received in parent: I will come back!
closing the process
child is done!

execution order

• Fork a process and get it's handle. Code execution goes on!
• Register callback listeners which will be called on given events like message OR exit. These are actually asynchronious. You don't know when they kick in.
• log that all lines have been executed
• Some time later, the message listener and after it, the exit listener kick in.

your code

You code basically executes till the end (only adding handlers to a process handle) and will log data from numArrayDef which is not currently added to it. So if no element is present at numArrayDef[5], it will log undefined per default.

callbacks

Since nodejs is single threaded per default, it's common to xecute an asynchronious function and pass it a callback (just another function) which will be executed when your called function is done!

The fixed code

parent.js

const fs = require('fs');
const { fork } = require('child_process');
const { EOL } = require('os')

const readString = fs.readFileSync('file.txt', 'utf8');
const readArray = readString.split(EOL);

var numArrayDef = [];

for (let i = 0; i < readArray.length - 2; i++) {

    // msg building. Done instantly.
    let msg = {
        i,
        readArray
    };


    // forking a childprocess. The handle is retunred immediatly
    // but starting the process may be taking some time, and 
    // the code won't wait for it!.
    let childProcess = fork('function.js');

    // this line is executed immedatly after the handle is created.
    // You add a so 
    childProcess.on('message', (m) => {
        console.log('message recevied', m)
        numArrayDef.push(m);

        // log if all numbers are done.
        if(numArrayDef.length === readArray.length -2) {
            console.log('Done. Here\'s the array:', numArrayDef)
        }

    });

    childProcess.send(msg);
}

function.js

process.on('message', (msg) => {
    let num = 0;

    if ((msg.i + 2) < msg.readArray.length) {
        num += parseInt(msg.readArray[msg.i]);
        num += parseInt(msg.readArray[msg.i + 1]);
        num += parseInt(msg.readArray[msg.i + 2]);

        process.send(num);
    }

    process.exit();
});

This should give you an idea. I recommend, going for some tutorials in the beginning to understand the nature of the language.

What you should learn about nodejs

• Learn what a callback is
• Basic understanding of async/await and Promises is a must
• You should learn, what operations are sync and which ones are async
• Eventemitter class is also used very often
• Learning how to handle childprocess or fork and other similar stuff, is not really required to get the base understanding of nodejs

Function declaration

Just an addon to the syntax. These are almost exactly the same. Except that with the arrow function style the this context will be correctly applied to newly created function:

// variant1
function abc(fn) {
    // eexcute the argument which is a function. But only after
    // a timeout!. 
    setTimeout(fn, 2000)
} 

// variant2
const abc = function(fn) {
    // eexcute the argument which is a function. But only after
    // a timeout!. 
    setTimeout(fn, 2000)
}

// variant3
const abc = (fn) => {
    // eexcute the argument which is a function. But only after
    // a timeout!. 
    setTimeout(fn, 2000)
}

// call it like so:
abc(function() { 
   console.log('I was passed!!.')
})

console.log('The abc function was called. Let\'s wait for it to call the passed function!\')