Functions and parameters

Why this matters

Yesterday you wrote your first function because the lab needed one. Today you learn what they actually are, and it is the most important idea in the week: a function is a named piece of work you can run again with different inputs.

Without functions, calculating the parallel resistance of three different pairs means writing the formula three times — and mistyping it once. With functions you write it once, name it, and call it. By the end of the hour you will have three calculation functions you can trust and reuse for the rest of this course.

Declaring and calling

function seriesResistance(r1, r2) {
  return r1 + r2;
}

console.log(seriesResistance(220, 330));

550

Piece by piece:

• function — the keyword that declares a function. Declaring defines it; it does not run it.
• seriesResistance — the name. Name functions for what they produce or do.
• (r1, r2) — the parameters: placeholder names for values supplied later.
• { ... } — the body, the code that runs on each call.
• return r1 + r2 — sends a value back out and ends the function immediately.

seriesResistance(220, 330) is the call (or invocation). The values 220 and 330 are the arguments. Parameters are the names in the declaration; arguments are the real values at the call. Inside the body r1 is 220 and r2 is 330, and the call becomes 550 wherever it appears.

Returning versus logging

This is where most beginners lose a day, so read it slowly.

console.log shows a value to a human. return hands a value back to the code that made the call. They are unrelated.

function logSeries(r1, r2) {
  console.log(r1 + r2);
}

const shown = logSeries(220, 330);
console.log(shown);

550
undefined

The 550 was printed by the function, but shown is undefined, because logSeries never returned anything. A function with no return returns undefined. That value is useless to the rest of the program — you cannot double it, compare it, or put it in a report.

Now the returning version:

const doubled = seriesResistance(220, 330) * 2;
console.log(doubled);

1100

The call produced a real number, so arithmetic worked on it. Return a value so callers can use the result. Logging is for you; returning is for the program.

Parameters make one function serve many cases

Change the arguments and the same function answers a different question:

function parallelResistance(r1, r2) {
  return (r1 * r2) / (r1 + r2);
}

console.log(parallelResistance(220, 330));
console.log(parallelResistance(1000, 1000));

132
500

Sanity-check both: two equal resistors in parallel give half of one, so 1000 and 1000 giving 500 is right. That is the Day 16 habit — verify the formula by hand once, then trust the function.

The parentheses in (r1 * r2) / (r1 + r2) are not optional. Without them, precedence would divide r2 by r1 first and give a wrong answer.

Pure functions

A pure function has two properties:

1. Given the same arguments it always returns the same result.
2. It changes nothing outside itself — no printing, no editing variables declared elsewhere.

seriesResistance and parallelResistance are pure. logSeries is not: printing is a change to the outside world, called a side effect.

Pure functions are worth aiming for because they are trivially testable. You call it with known inputs, compare the returned value with the answer you worked out by hand, and you are done — no setup, no state, no reading the terminal.

The practical rule for today: keep calculation separate from input and output. Calculation functions return numbers. A separate part of the program prints them.

function wattage(volts, amps) {
  return volts * amps;
}

console.log(`Power: ${wattage(9, 0.02)} W`);

Power: 0.18 W

wattage knows nothing about printing. Later, when the same number must go into a web page instead of a terminal, the function does not change at all.

Arrow functions

There is a shorter syntax you will see constantly:

const parallel = (r1, r2) => (r1 * r2) / (r1 + r2);
console.log(parallel(220, 330));

132

An arrow function is written as parameters, then =>, then the body. When the body is a single expression with no braces, its value is returned automatically — there is no return keyword. It is stored in a variable like any other value, and called the same way.

Both forms are correct. Use function while you are learning, because the explicit return is visible; recognise arrows because everyone else's code is full of them.

Walkthrough

Create resistors.js with all three functions and no printing inside any of them.

function seriesResistance(r1, r2) {
  return r1 + r2;
}

function parallelResistance(r1, r2) {
  return (r1 * r2) / (r1 + r2);
}

function wattage(volts, amps) {
  return volts * amps;
}

console.log("Series 220+330:  ", seriesResistance(220, 330));
console.log("Parallel 220|330:", parallelResistance(220, 330).toFixed(2));
console.log("Parallel 1k|1k:  ", parallelResistance(1000, 1000));
console.log("Wattage 9V 20mA: ", wattage(9, 0.02));

Run node resistors.js:

Series 220+330:   550
Parallel 220|330: 132.00
Parallel 1k|1k:   500
Wattage 9V 20mA:  0.18

Every console.log is outside the functions. The functions compute; the script reports.

Your turn

Deliverable: three tested calculation functions with explicit returns.

1. In js-basics/, create resistors.js and write seriesResistance, parallelResistance, and wattage yourself. Every one ends in return. No console.log inside any of them.
2. Work out four expected answers on paper first: series of 100 and 100; parallel of 100 and 100; parallel of 220 and 330; wattage at 12 V and 0.5 A.
3. Call each function and log the result next to the answer you predicted, like console.log("expected 200, got", seriesResistance(100, 100));.
4. Any mismatch is a bug in the code or in your arithmetic. Find out which before moving on.
5. Add a report(label, value) function that only prints, using a template literal. Use it for all your output. Calculation and printing are now in different functions.
6. Prove the separation: call parallelResistance inside a seriesResistance call — for example seriesResistance(470, parallelResistance(220, 330)) — and log the result. Nothing prints from inside; values simply flow.
7. Convert one function to an arrow function. Confirm the output is identical.

Common pitfalls

• Logging instead of returning. The number appears on screen and the caller gets undefined. If you want to use a result, return it.
• Declaring but never calling. A declaration alone runs nothing. You need the parentheses.
• Wrong argument order. wattage(0.02, 9) gives the same answer here, but divide(volts, ohms) called backwards does not. Order is part of the contract.
• Printing inside a calculation function. It works today and blocks reuse tomorrow. Keep calculation pure.

Verify it yourself

Open today's reference, MDN's Dynamic scripting with JavaScript, and find its pages on functions and on return values.

1. MDN describes default parameters — a parameter with a fallback value. Find the syntax and write down when it would help in wattage.
2. Does MDN agree that a function with no return statement evaluates to undefined? Find the sentence.

Write both answers as comments at the bottom of resistors.js.