Function Parameters and Return in JavaScript

Introduction

Parameters define what a function expects; return sends a result back to the caller. JavaScript is flexible—extra arguments are ignored, missing ones become undefined, and you can return any type including objects and functions. This chapter covers arity, early returns, and multiple return paths.

Prerequisites

Positional Parameters

javascript
// Order matters
function buildUrl(host, path, secure) {
  const scheme = secure ? "https" : "http";
  return `${scheme}://${host}${path}`;
}
 
console.log(buildUrl("example.com", "/api", true));

Arguments vs Parameters

Parameters are names in the definition; arguments are values at call time:

javascript
// More arguments than parameters — extras ignored
function add(a, b) {
  return a + b;
}
 
console.log(add(1, 2, 99));

Default Parameters (Preview)

javascript
// Default when undefined
function greet(name = "Guest") {
  return `Hello, ${name}`;
}
 
console.log(greet());
console.log(greet("Lin"));

Full coverage: default and rest.

return Ends the Function

javascript
// Early exit on invalid input
function parseAge(input) {
  const n = Number(input);
  if (Number.isNaN(n)) return null;
  if (n < 0 || n > 150) return null;
  return n;
}
 
console.log(parseAge("25"));
console.log(parseAge("abc"));

Returning Objects

Wrap object literals in parentheses:

javascript
// Return object literal
function createPoint(x, y) {
  return { x, y };
}
 
console.log(createPoint(3, 4));

Returning Functions (Higher-Order)

javascript
// Factory returns specialized function
function multiplier(factor) {
  return (value) => value * factor;
}
 
const triple = multiplier(3);
console.log(triple(7));

No Return Value

javascript
// Implicit undefined
function logOnly(msg) {
  console.log(msg);
}
 
const result = logOnly("done");
console.log(result);

Mini Example: Clamp Number

javascript
// Keep value within min/max
function clamp(value, min, max) {
  if (value < min) return min;
  if (value > max) return max;
  return value;
}
 
console.log(clamp(150, 0, 100));
console.log(clamp(-5, 0, 100));
console.log(clamp(42, 0, 100));

FAQ

Are parameters pass-by-reference?

Primitives are copied; object references are copied—mutating the object inside the function affects the caller.

Can I use arguments object?

Legacy style—in modern code prefer rest parameters ...args.

How many parameters is too many?

Beyond 3–4, consider an options object: createUser({ name, email, role }).

What comes next?

Default and rest parameters.