Terminate a JavaScript Script Early: return, throw, and process.exit()

You will learn that JavaScript has different ways to stop work depending on context: return exits a function, throw stops execution with an error, and process.exit() ends a Node.js process. You will also learn when each option is appropriate and why immediate process termination should be used carefully.

JavaScript does not have a direct built-in equivalent named die(). Instead, the right way to stop execution depends on what you need to stop.

• return stops the current function and optionally sends a value back to its caller.
• throw stops normal execution by raising an error. Unless code catches it with try...catch, it ends the current program flow.
• process.exit() terminates the entire Node.js process with an exit status code.

This distinction matters because most application code should not shut down the entire program. A reusable function usually reports a problem with throw or returns a result; the program entry point decides whether the process should exit.

In a browser, JavaScript cannot generally close the current tab or terminate the entire browser program. Instead, stop the current function with return, or report a failure with throw.

Think of a program as a building with rooms:

• return means: leave this room. The rest of the building can continue operating.
• throw means: pull a fire alarm. Normal work stops until someone handles the emergency with catch.
• process.exit() means: close the entire building. Every room stops immediately.

Use the smallest action that solves the problem. Leaving one room is usually safer than closing the entire building.

return exits a function:

function divide(a, b) {
  if (b === 0) {
    return null;
  }

  return a / b;
}

console.log(divide(10, 2)); // 5
console.log(divide(10, 0)); // null

When b is 0, the function returns immediately. The division line is not reached.

throw signals an invalid situation:

function divide(a, b) {
  if (b === 0) {
    throw new Error("Cannot divide by zero.");
  }

  return a / b;
}

console.log(divide(10, 2)); // 5
console.log(divide(10, 0)); // Error: Cannot divide by zero.

In a Node.js command-line script, process.exit() ends the whole process:

if (!process.env.API_KEY) {
  console.error("API_KEY is required.");
  process.exit(1);
}

console.log("Starting the application...");

An exit code of 0 conventionally means success. A non-zero code, such as 1, conventionally means failure.

Consider this Node.js script:

function startServer(port) {
  if (!Number.isInteger(port) || port < 1 || port > 65535) {
    console.error("Invalid port number.");
    return false;
  }

  console.log(`Server would start on port ${port}.`);
  return true;
}

const started = startServer(-1);

if (!started) {
  process.exitCode = 1;
} else {
  console.log("Application is ready.");
}

Execution with -1 happens as follows:

1. startServer(-1) is called.
2. The condition detects that -1 is not a valid port.
3. console.error prints an error message.
4. return false exits only startServer; the server-start message is skipped.
5. started receives false.
6. The outer if sets process.exitCode to 1.
7. Node.js finishes any remaining pending work, then exits with failure status.

Using process.exitCode is often safer than calling process.exit(1) immediately because it lets Node.js finish buffered output and pending cleanup work.

• Command-line tools: Stop when a required file path, environment variable, or command argument is missing.
• Form validation: Return early when a field is empty or has invalid content.
• API handlers: Return an HTTP error response immediately when a user is not authenticated.
• Data import scripts: Throw an error when a CSV row has an unexpected format.
• Configuration loading: Stop application startup when required credentials are unavailable.
• Batch jobs: Set a non-zero exit code so a scheduler or CI system knows the job failed.

Developers commonly use guard clauses: checks near the top of a function that return early for invalid or unneeded cases.

function formatUserName(user) {
  if (!user) return "Guest";
  if (!user.name) return "Guest";

  return user.name.trim();
}

Guard clauses reduce nested if statements and keep the successful path easy to read.

For errors that callers should handle, throw an Error:

function getRequiredSetting(settings, name) {
  const value = settings[name];

  if (!value) {
    throw new Error(`Missing required setting: ${name}`);
  }

  return value;
}

At an application boundary—such as a Node.js CLI entry file—catch errors, display a useful message, and set an exit code:

try {
  runImport();
} catch (error) {
  console.error(error.message);
  process.exitCode = 1;
}

This pattern keeps lower-level functions testable and lets one central place decide how the program ends.

Using return outside a function

This is invalid in ordinary JavaScript script code:

// SyntaxError in a normal script
if (!configured) {
  return;
}

Put the script logic in a function, or use Node.js process-level handling:

function main() {
  if (!configured) return;
}

main();

Calling process.exit() in browser code

process.exit() is a Node.js API, not a browser API. In browser code, return from the event handler or throw an error when appropriate.

Calling process.exit() deep inside reusable code

function readConfig() {
  if (!process.env.API_KEY) {
    process.exit(1);
  }
}

This makes the function difficult to test and reuse. Prefer throwing an error, then let the entry point choose the exit code.

function readConfig() {
  if (!process.env.API_KEY) {
    throw new Error("API_KEY is required.");
  }
}

Using process.exit() too quickly

Immediate termination can prevent asynchronous logs, file writes, or network responses from completing. Prefer setting process.exitCode when normal completion is possible.

Throwing a string instead of an Error

Avoid:

throw "Bad input";

Prefer:

throw new Error("Bad input");

Error objects provide a message and useful stack trace information.

// Exit the current function
return;
return value;

// Stop normal flow with an error
throw new Error("Something went wrong");

// Handle a thrown error
try {
  doWork();
} catch (error) {
  console.error(error.message);
}

// Node.js: report failure when the process naturally finishes
process.exitCode = 1;

// Node.js: terminate immediately
process.exit(1);

• Use return for expected early outcomes inside functions.
• Use throw for errors that should propagate to a caller.
• Use process.exitCode in Node.js command-line entry points.
• Exit code 0 means success; non-zero generally means failure.
• break exits a loop, not a function or script.
• process is not normally available in browser JavaScript.

What is the JavaScript equivalent of PHP die()?

For a Node.js script, process.exit(1) is the closest direct equivalent. In most functions, use return or throw new Error() instead.

How do I stop a JavaScript function early?

Use return:

if (!isValid) return;

Does return stop the whole JavaScript script?

No. It stops only the current function. Code outside that function can continue.

How do I exit a Node.js script with an error?

Set process.exitCode = 1 for a safe shutdown, or use process.exit(1) when immediate termination is truly needed.

What exit code should I use for success?

Use 0, which is also Node.js's normal exit status when no error occurs.

Can I use process.exit() in the browser?

No. It is a Node.js-specific API. Browser code should return from functions, show an error, or throw an exception.

Should I throw an error or return false?

Return a value when failure is expected and the caller can easily handle it. Throw an error when the operation cannot continue normally or when invalid usage must be reported.

• Functions and return values — return is the primary way to leave a function early.
• Conditional statements — if conditions decide when an early exit is needed.
• Error handling with try...catch — catches and handles errors created with throw.
• Guard clauses — a code style built around early returns for invalid cases.
• Node.js process object — provides process.exit() and process.exitCode for command-line programs.
• Exit codes — communicate success or failure to shells, CI systems, and task runners.
• Loops: break and continue — stop a loop or skip an iteration without ending a function.