Parameters, arguments and defaults

The greet function from lesson one always says the same thing. It is a recipe with no blanks: useful exactly once, and useless the moment you want to greet somebody by name. To be worth keeping, a function usually needs the caller to hand it something to work with.

That is what the round brackets in the declaration are for. They looked like decoration in lesson one because they were empty. Put a name inside them and you have made a slot: a value the caller must supply, which the body can then use.

A parameter is the name you write inside the brackets of the declaration. It is a placeholder — a variable that exists only inside the function body, and that has no value at all until somebody calls the function.

An argument is the actual value you write inside the brackets of a call. It is real: a number, a string, a boolean, something that exists right now.

They pair up by position. The first argument fills the first parameter, the second fills the second, and so on. The names do not have to match and usually will not — the caller's variable might be called customerName while the parameter is just name, and that is fine, because the function only ever sees the value.

People use the two words loosely in conversation and you will survive either way, but the distinction is worth keeping in your head, because parameter and argument are exactly the two moments this whole module is built on: writing the recipe, and running it.

A parameter is a blank line on a printed form. The form says Dear ______, and the blank is part of the design; it is not a name, it is a place where a name goes.

An argument is the ink. Somebody writes Ada in the blank, and for that one filled-in copy the letter reads Dear Ada. Fill in a fresh copy with Grace and the original form is untouched. Every call gets its own copy of the form.

JavaScript does not complain when the number of arguments does not match the number of parameters. This surprises people coming from other languages, and it is worth meeting deliberately rather than discovering at three in the morning.

If the caller supplies fewer arguments than there are parameters, the leftover parameters are undefined. The function still runs, and the value undefined then flows through your arithmetic or your text and produces something strange rather than an error.

If the caller supplies more arguments than there are parameters, the extra ones are simply ignored. There is no warning about that either.

You can give a parameter a default by writing an equals sign and a value after its name, like name = "friend". If the call supplies a value, that value is used. If it does not, the default is used instead, and the body never has to think about the missing case.

The rule for when a default kicks in is precise and worth memorising exactly, because a fuzzy version of it will bite you: the default is used when the argument is undefined. That covers the argument being left out entirely, and it also covers the caller passing undefined on purpose.

It does NOT cover null. It does not cover 0, or an empty string, or false. Those are all real values that somebody deliberately supplied, so JavaScript hands them straight to the body. If a caller passes null, the body gets null, defaults and all.

Defaults are worked out at the moment of the call, not once when the file loads, and a default may refer to a parameter written before it — so height = width is legal and means what it looks like it means.

Putting the optional parameter first. Arguments pair up by position, so if the first parameter has a default and the second does not, a caller who wants to supply only the second one has to pass undefined explicitly to skip the first. Put the parameters the caller always supplies at the front.

Assuming null means missing. Data that came from somewhere else — a form, a file, another programmer — often uses null for empty. A default will not catch it, and you will see the word null appear in the middle of your output. Lesson four of module seven deals with checking input properly; for now, just know that null arrives intact.

Silently accepting the wrong number of arguments. Because JavaScript never complains, a typo like greet("Ada", "Hello") on a function declared as greet(greeting, name) produces confident nonsense rather than an error. Read the declaration before you call it.

When you pass a number, a string or a boolean, the function receives a copy of the value. Assigning to the parameter inside the body changes only the function's own copy; the caller's variable is untouched. The final worked example below shows this happening.

This is the sort of fact that sounds like trivia until it saves you an hour. A function cannot reach back through its own brackets and edit the caller's variables, so the only way a function can tell its caller anything is by handing a value back — which is lesson three.

The picture is slightly different for arrays and objects, which module four introduces. Do not worry about that yet; for the values you have met so far, a copy is exactly what arrives.

Parameters are the named blanks in a declaration; arguments are the values written into them at the call, matched up by position. A missing argument leaves its parameter undefined and extra arguments are ignored — neither is an error. A default fills in for an argument that is undefined, and only for undefined: null, 0, false and the empty string all arrive as themselves.