Functions: Parameters, Return Values, and Local Scope

A function stores instructions for later

A function is a named, reusable block of code. Defining a function tells JavaScript what the function should do; it does not run that code immediately. To run it, you must call (or invoke) the function.

Consider a repeated status message:

console.log("Checking connection...");
console.log("Checking connection...");

If the message or the action becomes more complicated, duplication creates risk: you might update one copy and forget another. Instead, place the action in one function:

function checkConnection() {
  console.log("Checking connection...");
}

At this point, Node.js produces no output. The function exists, but it has not run. Call it with its name followed by parentheses:

checkConnection();

Now the output is:

Checking connection...

You can call the same function again:

checkConnection();
checkConnection();

The body runs once per call.

A common function declaration has this shape:

function functionName(parameterOne, parameterTwo) {
  // function body
  return result;
}

Not every function needs parameters, and not every function needs to return a value. But the parts have distinct jobs:

• function tells JavaScript you are defining a function.
• functionName is the reusable name you choose.
• Parameters are named input variables inside the parentheses.
• The function body is the code in curly braces.
• return sends a result back to wherever the function was called.

Use descriptive action-oriented names. For example, calculateTotalCost, checkBalance, and formatTransactionMessage reveal intent much better than names such as doThing or process.

Parameters receive inputs; arguments supply them

A function without parameters always performs the same action. Parameters make it adaptable.

function greetUser(name) {
  console.log("Hello, " + name);
}

greetUser("Asha");
greetUser("Rahul");

Output:

Hello, Asha
Hello, Rahul

The distinction in terminology is worth learning precisely:

With multiple inputs, their positions matter:

function calculateTotalCost(value, fee) {
  return value + fee;
}

const firstTotal = calculateTotalCost(150, 3);
const secondTotal = calculateTotalCost(220, 5);

console.log(firstTotal);
console.log(secondTotal);

Output:

153
225

When JavaScript evaluates this call:

calculateTotalCost(150, 3)

it temporarily gives the function these local values:

value = 150
fee = 3

Then it evaluates value + fee, returns 153, and the call itself behaves like that result. In other words:

const firstTotal = calculateTotalCost(150, 3);

ends with the same value as:

const firstTotal = 153;

Parameters let one well-tested calculation work with many different values. Later, programs that interact with a blockchain will use the same pattern: functions take inputs such as an address, amount, or contract setting, then calculate, validate, or format a result.

Missing arguments become undefined

JavaScript does not automatically stop you from calling a function with too few arguments:

function calculateTotalCost(value, fee) {
  return value + fee;
}

const incompleteTotal = calculateTotalCost(150);

console.log(incompleteTotal);

The parameter fee receives undefined. Adding a number to undefined produces NaN, meaning “Not a Number”:

NaN

For the functions you write at this stage, call them with every required argument. In a later lesson, you will learn stronger ways to validate inputs and handle failures.

Sometimes a sensible default exists:

function formatNetworkName(network = "testnet") {
  return "Network: " + network;
}

console.log(formatNetworkName("mainnet"));
console.log(formatNetworkName());

Output:

Network: mainnet
Network: testnet

The second call omits its argument, so network uses the default "testnet". Defaults are useful when there is a genuinely safe, expected fallback—not merely to hide a missing value.

return produces a value; console.log displays one

This distinction causes many beginner bugs, so make it explicit.

console.log() is for displaying a value in the terminal:

function showTotal(value, fee) {
  console.log(value + fee);
}

showTotal(150, 3);

This prints:

153

But it does not give the caller a usable calculation result:

const total = showTotal(150, 3);

console.log(total);

Output:

153
undefined

Why? showTotal() logs 153, but it has no return statement. A function without a return value evaluates to undefined.

Use return when the caller needs the result for another calculation, a condition, or a message:

function calculateTotalCost(value, fee) {
  return value + fee;
}

const total = calculateTotalCost(150, 3);

console.log("Total cost:", total);

if (total <= 200) {
  console.log("Within the simulated budget.");
} else {
  console.log("Above the simulated budget.");
}

Here, the function handles one focused job—calculating the total. The calling code decides what to do with that total.

A return statement has a second effect: it immediately ends the function.

function checkAmount(amount) {
  if (amount <= 0) {
    return "Amount must be positive.";
  }

  return "Amount accepted.";
}

For checkAmount(0), the first return runs and the second is skipped. This makes return useful for ending a function as soon as it has a result.

A helpful mental model is:

arguments -> parameters -> function body -> return value

The return value goes back to the precise spot where you wrote the function call.

Local scope: variables belong to their function

A scope is the part of a program where a variable name is available.

Variables declared inside a function with const or let are local variables. They exist only inside that function body. Function parameters are local too.

function createStatusMessage(network, blockHeight) {
  const message = "Connected to " + network + " at block " + blockHeight;

  return message;
}

const status = createStatusMessage("testnet", 22000002);

console.log(status);

This runs correctly because message is used inside createStatusMessage, where it was declared.

This does not work:

function createStatusMessage(network, blockHeight) {
  const message = "Connected to " + network + " at block " + blockHeight;

  return message;
}

console.log(message);

Node.js reports an error similar to:

ReferenceError: message is not defined

The variable message is unavailable outside the function. It is created during the function call, used to form the return value, and then cannot be referenced from top-level code.

This boundary is valuable. Imagine that several functions all use a variable named result. If each function’s result stays local, the functions do not overwrite one another’s working values.

Variables declared outside a function are in an outer scope. In a basic Node.js file, functions in that same file can read them:

const activeNetwork = "testnet";

function showNetwork() {
  console.log("Current network:", activeNetwork);
}

showNetwork();

That is legal, but for most calculations, prefer a function that receives needed values as parameters and returns a result. Compare these approaches:

// Less clear: the function silently depends on outside state
let currentFee = 3;

function calculateCostUsingOuterValue(value) {
  return value + currentFee;
}

// Clearer: the required input is visible at the call
function calculateCost(value, fee) {
  return value + fee;
}

The second version is easier to test and reuse because its behavior is determined by its arguments. This discipline becomes particularly important in smart-contract development, where hidden dependencies and unexpected state changes can lead to expensive bugs.

Build a small transaction-decision script

Create a file named functions-transfer.js in your Node.js practice folder. The values here are simple simulated units, not a real transaction or Ether calculation.

function calculateTotalCost(value, fee) {
  const totalCost = value + fee;

  return totalCost;
}

function hasEnoughBalance(balance, totalCost) {
  return balance >= totalCost;
}

function createTransferSummary(balance, value, fee) {
  const totalCost = calculateTotalCost(value, fee);
  const canSubmit = hasEnoughBalance(balance, totalCost);

  return (
    "Balance: " + balance +
    " | Total cost: " + totalCost +
    " | Can submit: " + canSubmit
  );
}

const walletBalance = 200;
const transferValue = 150;
const networkFee = 3;

const summary = createTransferSummary(
  walletBalance,
  transferValue,
  networkFee
);

console.log(summary);

Run it:

node functions-transfer.js

Expected output:

Balance: 200 | Total cost: 153 | Can submit: true

Trace the program in order:

1. Node.js reads and defines the three functions. Their bodies do not run yet.
2. It stores the three top-level values: walletBalance, transferValue, and networkFee.
3. It calls createTransferSummary(...).
4. Inside that function, calculateTotalCost(...) returns 153.
5. hasEnoughBalance(...) compares 200 >= 153 and returns true.
6. createTransferSummary(...) constructs and returns one string.
7. The top-level console.log(summary) displays that returned string.

Notice the scopes:

• walletBalance, transferValue, networkFee, and summary are available in the outer file scope.
• totalCost and canSubmit inside createTransferSummary are local to that function.
• Each function’s parameters are local to that function.

Make these controlled changes:

• Change transferValue to 198. The total becomes 201, so the summary should end in false.
• Change walletBalance to 250. The same transfer should now be allowed.
• Add console.log(totalCost); inside createTransferSummary; it works there. Move that line below console.log(summary); at the top level and run the file again. You should get a scope-related ReferenceError. Remove or comment out the failing line afterward.
• Change calculateTotalCost so that it only logs the total instead of returning it. Observe how this breaks the later comparison, then restore return totalCost.

This is a useful pattern to carry forward: one function calculates, another checks a condition, and another creates a human-readable output. Each has one clear responsibility.

Wrap-up

You can now organize JavaScript logic into reusable functions:

• A function declaration defines a named block of instructions; a function call runs it.
• Parameters are local input variables listed in a function definition; arguments are the values provided during a call.
• return sends a value back to the calling code and stops the current function immediately.
• console.log() displays a value, while return makes a value available for later code.
• Variables declared with let or const inside a function, including its parameters, are local to that function’s scope.
• Functions that accept explicit inputs and return outputs are easier to test, reuse, and reason about than functions that quietly rely on outer variables.

Next, you will apply functions to arrays: processing lists of values with iteration, map, filter, and reduce. Functions will become even more useful there, because they let you describe exactly what should happen to each item in a collection.