When you use readline.createInterface(), it sets up a stream internally. By default, streams are paused but start flowing when a data event listener is added.
Within readline.createInterface(), a data event handler is included to initiate the flow of the stream. This leads to the emission of data events that are parsed by the readline code into line events.
Node.js and streams operate on an event-driven model with single-threaded execution, meaning no events occur until setup code completes. Even if node.js begins reading a file asynchronously before setup finishes, it won't process these events until setup is done and control is returned to the event loop.
Once the data event callback is triggered, the data from that event is parsed by the readline code. If a complete line is found in the data, a line event is generated.
There doesn't seem to be anything triggering the reader to start.
By adding a data event handler to the readStream internally within the readline code, the stream is prompted to start flowing.
It seems to work flawlessly without any explicit instructions to begin. How does it know when to commence?
The same mechanism as mentioned above initiates the reading process.
How can it ensure it captures every line in the file when those events don't exist yet?
The raw data from the file is received by the readline code through its data event handler. It then parses this data into lines, emitting a line event for each one found. When crossing a line boundary during file reading, incomplete lines are buffered until the rest of the line arrives in the next data event.
After recognizing that there are no more bytes to read, the linereader code processes the last line (if incomplete) and triggers the close event to signal completion.
If I introduce CPU-intensive code after creating the linereader but before attaching events, it still functions efficiently. How does it wait until the heavy tasks finish before starting to read?
This behavior stems from node.js being event-driven. The initial data event from the stream, internal to the readline code, follows the completion of an fs.readFile() function, notifying completion through the event queue. Processing in the event queue waits until the current JavaScript section concludes before moving onto the next event pending in the queue, ensuring orderly event handling regardless of preceding heavy processing.
Node.js' single-threaded, event-driven design ensures that event listeners are installed before their respective events can trigger, eliminating missed event opportunities.
Even without attaching a line event, the program carries on and fires the close event. It doesn't seem to depend on having the line event present.
Indeed, the data event handler is embedded within createInterface() in the readline code, initiating the stream flow and file reading whether or not a line event listener is attached.
To uncover answers to similar questions, examine the underlying node.js code yourself. That's precisely what was done here. You can visit this link detailing the createInterface() function for further insight.
Additionally, consult the stream documentation here, outlining three ways streams commence, including attachment of a data event listener.