User Input & Output

console.log, prompt and alert in the browser, readline in Node.js — and why JavaScript has two completely different answers.

What it is, in plain English: Output means showing information to the user or to yourself as a developer. In JavaScript, console.log() is the universal tool — it prints to the browser's developer console or to the terminal in Node.js. Input is where JavaScript splits in two: in the browser, prompt() asks the user a question in a dialog box; in Node.js, you use the readline module to read from the terminal. These two homes (browser and Node.js) have different tools — this page covers both clearly.

Where this bites you

rl.question() doesn't wait. It shows the prompt, registers your callback for later and returns immediately, so code written on the lines after it runs before the user has typed anything. A variable filled in by the callback is still undefined there.

const readline = require("readline");
const rl = readline.createInterface({ input: process.stdin, output: process.stdout });

let name;
rl.question("What is your name? ", (answer) => {
  name = answer;
  rl.close();
});

console.log(`Hello, ${name}!`);   // runs immediately -- before any answer arrives
// $ echo Asha | node greet.js
// What is your name? Hello, undefined!

Showing output and getting input in JavaScript

The first thing every programmer does is print something to the screen. In Python it's print(). In JavaScript, it's console.log().

console.log — your most-used tool

// Print a string:
console.log("Hello, world!");

// Print a number:
console.log(42);

// Print multiple things at once — they appear with spaces between:
console.log("Name:", "Alice", "| Age:", 30);  // Name: Alice | Age: 30

// Print the result of an expression:
console.log(5 + 3);    // 8
console.log(10 > 5);   // true

// Print objects and arrays — shows their structure:
console.log({ name: "Alice", age: 30 });
console.log([1, 2, 3, 4]);

// Labelling values while debugging:
let total = 0;
total += 10;
console.log("total after first add:", total);   // total after first add: 10
total += 25;
console.log("total after second add:", total);  // total after second add: 35

More console methods

// console.error — red output, for errors:
console.error("File not found");

// console.warn — yellow output, for warnings:
console.warn("This API is deprecated");

// console.table — renders arrays of objects as a table (great for data):
const students = [
  { name: "Alice", grade: "A" },
  { name: "Bob",   grade: "B" },
  { name: "Charlie", grade: "A" }
];
console.table(students);  // renders a neat table in the console

// console.group — group related logs:
console.group("User details");
console.log("Name: Alice");
console.log("Age: 30");
console.groupEnd();

// console.time — measure how long something takes:
console.time("loop");
for (let i = 0; i < 1_000_000; i++) {}
console.timeEnd("loop");  // "loop: 3.5ms"

The two homes — browser vs Node.js input

This is where JavaScript's "two homes" split matters most. Getting input from a user is completely different in a browser versus Node.js.

🌐 In the browser

Use prompt(), alert(), and confirm() — they show dialog boxes to the user.

Note: These block the page while waiting. Modern web apps use HTML form elements instead — but prompt/alert are great for quick experiments and learning.

🖥️ In Node.js

Use the readline module to read from the terminal. Node.js doesn't have prompt() or alert().

Note: The Try It editor above runs in the browser, so prompt/alert work there but readline won't.

Browser: prompt, alert, confirm

// alert — show a message box (user clicks OK)
alert("Welcome to my app!");

// prompt — ask a question, returns what the user typed (or null if cancelled)
const name = prompt("What is your name?");
console.log(`Hello, ${name}!`);

// prompt always returns a string — convert if you need a number:
const ageStr = prompt("How old are you?");
const age = Number(ageStr);
if (isNaN(age)) {
  alert("That's not a valid age!");
} else {
  alert(`You are ${age} years old.`);
}

// confirm — yes/no dialog, returns true or false
const confirmed = confirm("Are you sure you want to delete this?");
if (confirmed) {
  console.log("Deleted!");
} else {
  console.log("Cancelled.");
}

Node.js: readline

// Save this as input.js and run with: node input.js
const readline = require("readline");

const rl = readline.createInterface({
  input: process.stdin,    // read from the keyboard
  output: process.stdout   // show prompts in the terminal
});

rl.question("What is your name? ", (name) => {
  console.log(`Hello, ${name}!`);

  rl.question("How old are you? ", (ageStr) => {
    const age = Number(ageStr);
    console.log(`Next year you'll be ${age + 1}.`);
    rl.close();  // important: close when done or the program won't exit
  });
});

That's why the example above nests the second question inside the first callback: anything that needs the answer has to run inside the callback (or after an await with the promise-based version below). The fix is to move the code that uses the answer into the callback:

rl.question("What is your name? ", (answer) => {
  console.log(`Hello, ${answer}!`);   // runs once the answer exists
  rl.close();
});
// $ echo Asha | node greet.js
// What is your name? Hello, Asha!

Modern Node.js (v17+) also has a promise-based readline that works well with async/await — covered in the async reference pages.

Try It Yourself

Console formatting, stdin/stdout streams, and readline promises

Console format specifiers

// %s string, %d integer, %f float, %o object, %c CSS styles:
console.log("Hello, %s! You have %d messages.", "Alice", 5);
// "Hello, Alice! You have 5 messages."

console.log("%cImportant!", "color: red; font-weight: bold");
// Browser only — applies CSS to the log output

process.stdout and process.stderr

// In Node.js, console.log is essentially process.stdout.write + newline:
process.stdout.write("Loading");
process.stdout.write("...");
process.stdout.write(" done!\n");  // must add \n yourself

// stderr for errors (goes to a separate stream, useful in shell pipelines):
process.stderr.write("Error: something went wrong\n");

readline with Promises (Node.js v17+)

import { createInterface } from "readline/promises";
import { stdin, stdout } from "process";

const rl = createInterface({ input: stdin, output: stdout });

const name = await rl.question("Name: ");
const age  = await rl.question("Age: ");
console.log(`Hello ${name}, you are ${age} years old.`);
rl.close();

Reading from stdin as a stream (pipes)

// Read all stdin (e.g. from a pipe: echo "hello" | node script.js)
process.stdin.setEncoding("utf-8");
let input = "";
process.stdin.on("data", chunk => { input += chunk; });
process.stdin.on("end", () => {
  console.log("Received:", input.trim().toUpperCase());
});

The console spec, process streams, and TTY detection

The Console API — a living standard, not ECMAScript

The console object is specified by the Console Standard (console.spec.whatwg.org), not by ECMAScript. Different environments (browser, Node.js, Deno, Bun) implement it to varying degrees of compliance. The spec defines the "printer" operation and the "logger" operation; implementations differ in formatting, colouring, and which methods exist. console.table, console.group, console.time are all standard but may render differently across environments.

TTY detection and colour output

// Detect if stdout is a real terminal (TTY) or a pipe/file:
if (process.stdout.isTTY) {
  // Safe to use ANSI colours:
  console.log("[32mGreen text[0m");   // ANSI escape codes
} else {
  // Writing to file or pipe — don't include colour codes
  console.log("Green text");
}

// Libraries like chalk, kleur, picocolors handle this automatically

Structured clone and serialisation in console.log

Browsers show live references in console.log — if you log an object and then mutate it, the console may show the mutated version. This is because browsers log the reference, not a snapshot. Node.js serialises the value immediately. To snapshot in a browser:

const obj = { count: 0 };
console.log(JSON.parse(JSON.stringify(obj)));  // snapshot — won't update
// Or:
console.log(structuredClone(obj));  // deep clone before logging

Official Sources

The Codex links only to official documentation and the ECMAScript specification. No third-party tutorials.