How to Read from stdin in JavaScript

By the end of this page, you will understand what stdin is, how Node.js reads terminal input, and the common ways to collect and process user input in JavaScript. You will also see practical examples, common mistakes, and a small project that uses stdin in a realistic way.

Standard input, usually called stdin, is the default input stream for a program. When you run a program in a terminal and type something, that text can be sent into the program through stdin.

In JavaScript, stdin is commonly used in Node.js, not in browser JavaScript. Node exposes it through:

process.stdin

This object is a readable stream. That means input does not always arrive all at once. Instead, data may come in chunks over time.

Why this matters:

• Command-line tools use stdin to receive user input or piped data.
• Coding challenge platforms often expect solutions to read from stdin.
• Scripts and automation use stdin to accept values from other commands.

A common beginner pattern is:

1. Listen for incoming data.
2. Collect it into a string.
3. Wait until input ends.
4. Split or parse the text.

For example, if the user enters:

Alice
25

Your program can read that as raw text, then split it by lines and process each value.

The key idea is that stdin gives your program a stream of input, and your job is usually to collect that input and convert it into the format you need.

Think of stdin like a mailbox slot for your program.

• The terminal user drops messages into the slot.
• Your program checks the slot through process.stdin.
• The messages may arrive piece by piece.
• Once the mail stops coming, your program can open everything and sort it.

Another way to think about it: stdin is like a microphone connected to your program. The program listens, gathers what it hears, and then decides what to do with it.

The most common Node.js pattern for reading all input from stdin is:

let input = '';

process.stdin.setEncoding('utf8');

process.stdin.on('data', chunk => {
  input += chunk;
});

process.stdin.on('end', () => {
  console.log('You entered:');
  console.log(input);
});

What this does

• input stores everything read from stdin
• setEncoding('utf8') tells Node to treat input as text
• 'data' runs whenever a new chunk arrives
• 'end' runs when there is no more input

Example: read lines into variables

let input = '';

process..();

process..(,  {
  input += chunk;
});

process..(,  {
   lines = input.().();

   name = lines[];
   age = (lines[]);

  .();
});

Consider this program:

let input = '';

process.stdin.setEncoding('utf8');

process.stdin.on('data', chunk => {
  input += chunk;
});

process.stdin.on('end', () => {
  const words = input.trim().split(/\s+/);
  console.log(words);
});

Suppose the user provides this input:

red blue green

Step by step

1. let input = ''

   • Creates an empty string to store incoming text.

2. process.stdin.setEncoding('utf8')

   • Tells Node to read text instead of raw binary data.

3. process.stdin.on('data', chunk => { ... })

   • Registers a callback for each piece of input received.

Reading from stdin is useful in many real programs:

Command-line tools

A CLI program may ask for input or accept piped data:

echo "hello" | node app.js

Your script reads hello from stdin.

Coding challenge platforms

Sites that test algorithms often provide input through stdin. Your program reads it, parses it, and prints the answer.

Data processing scripts

You can pass text files or command output into a Node script:

cat users.txt | node process-users.js

Interactive terminal programs

Some scripts let users type values directly, such as names, menu choices, or commands.

DevOps and automation

Scripts can receive configuration or input from shell commands without hardcoding values into the program.

In real codebases, developers usually do more than just read raw text. They combine stdin with parsing, validation, and program flow patterns.

Common patterns

1. Parse once, then process

Developers often collect all input first, then parse it in one place.

let input = '';
process.stdin.setEncoding('utf8');

process.stdin.on('data', chunk => {
  input += chunk;
});

process.stdin.on('end', () => {
  const lines = input.trim().split('\n');
  run(lines);
});

function run(lines) {
  console.log(lines);
}

This keeps input handling separate from business logic.

2. Validation

Real programs check whether input is missing or invalid.

function parseAge(value) {
   age = (value);

   (.(age)) {
    .();
    process.();
  }

   age;
}

Here are common beginner mistakes when reading from stdin in Node.js.

1. Assuming browser JavaScript has process.stdin

process.stdin is a Node.js feature, not a browser feature.

Broken idea:

process.stdin.on('data', chunk => {
  console.log(chunk);
});

If you run this in a browser environment, it will not work.

2. Forgetting that input may come in chunks

Broken code:

let input = '';

process.stdin.on('data', chunk => {
  input = chunk;
});

Problem:

• This replaces previous input instead of keeping it.

Correct version:

let input = '';

process.stdin.on('data',  {
  input += chunk;
});

stdin vs command-line arguments

// Basic stdin pattern in Node.js
let input = '';

process.stdin.setEncoding('utf8');

process.stdin.on('data', chunk => {
  input += chunk;
});

process.stdin.on('end', () => {
  console.log(input);
});

Quick rules

• process.stdin is for Node.js, not the browser.
• Input is usually read as strings.
• Data may arrive in multiple chunks.
• Use input += chunk, not input = chunk.
• Wait for 'end' before final processing.
• Use trim() to remove trailing newlines.
• Use split(/\s+/) for flexible whitespace splitting.
• Use map(Number) to convert numeric input.

Common parsing patterns

How do I read input from stdin in Node.js?

Use process.stdin and listen for 'data' and 'end' events. Collect the chunks into a string, then process the full input when it ends.

What is stdin in JavaScript?

In JavaScript, stdin usually refers to standard input in Node.js. It is the input stream your program can read from when running in a terminal.

Why do I need process.stdin.on('end')?

Because input may arrive in multiple chunks. The 'end' event tells you all input has been received, so it is safe to parse.

How do I read numbers from stdin?

Read the input as text, split it, and convert values with Number.

const nums = input.trim().split(/\s+/).map(Number);

How do I read line-by-line input in Node.js?

You can split the full input using split('\n'), or use the readline module for interactive line-by-line reading.

• Node.js streams — process.stdin is a readable stream, so stream basics help explain how input arrives.
• Event-driven programming — reading from stdin uses events like 'data' and 'end'.
• Strings in JavaScript — input arrives as text and is often trimmed, split, and transformed.
• Arrays in JavaScript — parsed input is commonly stored in arrays after split().
• Type conversion — numeric input must be converted from strings to numbers.
• Regular expressions — patterns like /\s+/ are useful for splitting on whitespace.
• Node.js readline module — a related tool for interactive terminal input.
• Command-line arguments — another common way to pass input into Node.js programs.