Utilizing stdout, stdin, and stderr in Node.js

stdout, stdin, and stderr are commonplace streams, which interconnect enter and output communication channels between a program and its surroundings when this system executes.

Streams typically imply the move of knowledge. You may consider streams as a conveyor belt in a manufacturing facility related to completely different machines (packages in our case). Totally different machines may be organized, directed, and related with a belt (pipe) in a method to produce a specific consequence.

Simply as we are able to have bodily I/O gadgets related (enter by way of mouse, output by way of monitor), commonplace streams summary this, giving us the facility of composability in our code.

Similar to the way in which we are able to compose highly effective Linux instructions from small instructions, we are able to make use of Node.js commonplace streams to attain the identical in Node.js.

Node.js stdin, stdout, and stdin

Once we run a Node.js program, a course of is began for that program execution.

The GNU documentation defines a course of as “the primitive items for allocation of system assets. Every course of has its personal deal with house and (normally) one thread of management. A course of executes a program; you possibly can have a number of processes executing the identical program, however every course of has its personal copy of this system inside its personal deal with house and executes it independently of the opposite copies.”

Each course of is initialized with three open file descriptors referred to as stdin, stdout, and stderr.

These three file descriptors are collectively referred to as the usual streams.

A set of the three commonplace streams is began for a course of and we are able to entry them by way of the course of object in Node.js.

The requirements streams are handled as if there are information. A straightforward method to entry any file is through the use of the distinctive file descriptor related to it. Within the case of those requirements streams, there are distinctive values assigned to every of them.

• course of.stdin(0): The usual enter stream, which is a supply of enter for this system
• course of.stdout(1): The commonplace output stream, which is a supply of output from this system
• course of.stderr(2): The commonplace error stream, which is used for error messages and diagnostics issued by this system

Easy use of stdin and stdout

Let’s write a easy utility that receives knowledge by way of the terminal and prints a processed output into the terminal.

We’d create a JavaScript file (index.js) and write the code under:

 // index.js
course of.stdin.on("knowledge", knowledge => {
    knowledge = knowledge.toString().toUpperCase()
    course of.stdout.write(knowledge + "n")
})

Working the above program creates an occasion listener to pay attention for knowledge enter, processes the enter, and prints the output to the terminal.

We are able to cease the operating course of in our terminal by urgent ctrl + c.

Making use of readline to create interactive terminal scripts

readline is a Node.js module that gives an interface for studying knowledge from a Readable stream (akin to course of.stdin) one line at a time.

First, we’d create a brand new JavaScript file referred to as index.js, import the readline module into our program, then create a perform, ask, that receives a string as an argument and creates a immediate with the string in our terminal:

// index.js
const readline = require("readline")

perform ask(query) {
    // asks a query and anticipate a solution
}

Then we’ll create an interface utilizing readline that connects stdin to stdout:

// index.js
const readline = require("readline")

const rl = readline.createInterface({
    enter: course of.stdin, 
    output: course of.stdout,
})

perform ask(query) {
    // asks a query and expectings a solution
}

We’ll full the ask perform to anticipate solutions and repeat the entire course of recursively:

 // index.js
const readline = require("readline")

const rl = readline.createInterface({
    enter: course of.stdin, 
    output: course of.stdout,
})

perform ask(query) {
    rl.query(query, (reply) => {
        rl.write(`The reply acquired:  ${reply}n`)

        ask(query)
    })
}

ask("What's your identify: ")

Working the above program would create a terminal interface that retains looping till we finish the Node.js course of by urgent ctrl + c within the terminal.

The ctrl + c sends a sign to our operating Node.js program referred to as SIGKILL, which tells Node.js to cease our program execution. We are able to additionally, programmatically, inform Node.js to cease executing our utility by calling course of.exit(exitCode).

So we’ll replace our ask perform to verify if the reply from enter “q.” If the enter is “q” then it ought to exit the appliance:

// index.js
const readline = require("readline")

const rl = readline.createInterface({
    enter: course of.stdin, 
    output: course of.stdout,
})

perform ask(query) {
    rl.query(query, (reply) => {
        if(reply === "q") {
            course of.exit(1)
        }
        rl.write(`The reply acquired:  ${reply}n`)

        ask(query)
    })
}

ask("What's your identify: ") 

What’s stderr?

Once we write functions or packages, errors could happen attributable to so many causes. stderr is the default file descriptor the place a course of can write error messages.

// index.js
course of.stderr.write("error! some error occurredn")

const logObject = [
    {
        type: "normal",
        message: "SUCCESS: 2 + 2 is 4"
    },
    {
        type: "normal",
        message: "SUCCESS 5 + 5 is 10"
    },
    {
        type: "error",
        message: "ERROR! 3 + 3 is not 4"
    },
    {
        type: "normal",
        message: "SUCESS 10 - 4 is 6"
    }
]

perform logger() {
    logObject.forEach(log => {
        setTimeout(() => {
            if (log.sort === "regular") course of.stdout.write(log.message)
            else course of.stderr.write(log.message + 'n')
        }, 500)
    })
}

logger()

const fs = require("fs")

fs.open("./logs.txt", "w", (err, fd) => {
    if (err) throw Error(err.message)
    course of.stdin.on("knowledge", knowledge => {
        fs.write(fd, knowledge.toString() + "n", (err) => {
            if (err) throw Error(err.message)
        })
    })
})

$ node logger.js | node printer.js

// logs.txt
SUCCESS: 2 + 2 is 4
SUCCESS 5 + 5 is 10
SUCcESS 10 - 4 is 6