Functions

A function is a machine

Think of a juicer. Oranges go in and juice comes out. You do not build a new juicer every morning. You build it once and use it whenever you want.

A function is a named block of code that does one job. You give it inputs. It does its work. It gives back a result.

So far you have written the same logic again and again (is it even? sum of digits? is it prime?). A function lets you write the logic once and give it a name. Then you can use it from anywhere, even from inside other functions.

Defining and calling

function greet(name) {          // define: "here is how to greet someone"  return "Hello, " + name + "!";}console.log(greet("Asha"));     // Hello, Asha!console.log(greet("Rahul"));    // Hello, Rahul!

• Defining a function (function greet(name) { … }) means writing it. This builds the machine. Nothing runs yet.
• Calling a function (greet("Asha")) means running it. The round brackets make it run.
• You can call it as many times as you like, with different inputs.

Parameters and arguments

function add(a, b) {   // a and b are PARAMETERS: names for the inputs  return a + b;}console.log(add(2, 3));   // 5    2 and 3 are ARGUMENTS: the actual valuesconsole.log(add(10, -4)); // 6console.log(add(7));      // NaN  b was not given, so it is undefined; 7 + undefined is NaN

A parameter is a name for an input. You write it in the definition, inside the round brackets. An argument is the real value you pass when you call the function. The one-line difference: a parameter is the empty box, and an argument is what you put in the box.

JavaScript matches them by position. The first argument goes to the first parameter, and so on. If you pass too few arguments, the missing parameter becomes undefined. undefined is a special value that means “there is no value here”. If you do maths with undefined, you get NaN. NaN means “Not a Number”. It is the result of a maths operation that has no valid number answer.

return vs console.log

This is the most important difference in this lesson. Mixing them up is one of the most common mistakes in interviews.

• console.log(v) is a built-in function that prints a value on the screen so a person can read it.
• return v is a statement that sends the value back to the code that called the function. It also ends the function.

An everyday comparison: console.log is like reading the answer out loud in a room. return is like handing the answer on paper to the person who asked. Only the paper can be used for the next step.

function doubleLog(n) {  console.log(n * 2);   // shows the value on screen... and that's all}function doubleReturn(n) {  return n * 2;         // hands the value BACK to whoever called it}const x = doubleLog(5);    // prints 10 — but x gets nothingconst y = doubleReturn(5); // prints nothing — y gets 10console.log(x);  // undefinedconsole.log(y);  // 10console.log(doubleReturn(5) + 1); // 11 — a returned value can be used in more maths/* Output:10undefined1011*/

Traced: jumping into a function and back

▶function square(x) {2  const result = x * x;3  return result;4}5 6const a = square(3);7const b = square(4);8console.log(a + b);

JavaScript keeps track of this “jump in, jump back” with the call stack. The call stack is a list of the function calls that are running right now. The newest call is on top. When a call finishes, it is removed and JavaScript goes back to the one below. The JavaScript series explains it in depth.

For DSA you need to know one fact now: every call gets its own fresh copy of the parameters and inner variables.

Variables inside stay inside

function makeTotal() {  let total = 100;      // exists only while makeTotal runs  return total;}console.log(makeTotal()); // 100console.log(total);       // ReferenceError: total is not defined

Scope means the part of the code where a variable can be used. A variable made inside a function exists only while that call runs. Code outside the function cannot see it.

This is useful. Your i or sum inside one function can never clash with an i or sum in another place. To get a value out, return it.

return ends the function early

return does two things. It gives a value back, and it stops the function right there, even in the middle of a loop. Any code after it in that call does not run. This makes “search until found” very clean:

function firstDivisor(n) {  for (let d = 2; d < n; d++) {    if (n % d === 0) {      return d;          // found one: leave the function (and the loop) immediately    }  }  return -1;             // reached only if the loop never returned}console.log(firstDivisor(15)); // 3console.log(firstDivisor(13)); // -1

Arrow functions

An arrow function is a shorter way to write a function. It uses => (an arrow). If the body is one expression, the value is returned automatically, so you do not write return. You will see this style a lot in modern code. For everything in this series, it works the same as a normal function:

// these three are the same functionfunction square1(n) { return n * n; }const square2 = function (n) { return n * n; };const square3 = (n) => n * n;         // arrow function: short, returns automaticallyconsole.log(square1(5), square2(5), square3(5)); // 25 25 25

Default parameter values

A default parameter value is a backup value written with = in the parameter list. JavaScript uses it when the caller does not pass that argument. This avoids the undefined and NaN problems shown above.

function greet(name = "friend") {   // "friend" is used when no name is given  return "Hello, " + name;}console.log(greet("Asha")); // Hello, Ashaconsole.log(greet());       // Hello, friend

Passing values vs passing references

What happens when a function changes a parameter? It depends on the type of value. A reference is the address of where a value is stored, like a house address written on paper. If you give a friend your address (not a copy of your house), they visit the same house.

function addOne(n) {  n = n + 1;            // changes the function's own copy only}let x = 5;addOne(x);console.log(x);         // 5  numbers are passed as a copyfunction addItem(list) {  list.push(99);        // changes the array the caller passed in}const nums = [1, 2];addItem(nums);console.log(nums);      // [ 1, 2, 99 ]  arrays and objects are shared

• Numbers, strings and booleans (true or false) are passed as a copy. Changing the parameter inside the function never changes the caller's variable.
• Arrays and objects are passed as a reference. The function gets the address of the same array, not a copy. If it changes the contents (for example with push), the caller sees the change.
• One limit: if the function gives the parameter a brand-new array (list = []), that only changes the function's own variable. The caller's array stays the same.

Why every interview answer is a function

LeetCode is a website with coding practice problems. On LeetCode and in most interviews you are given an empty function to fill in, like this:

/** * @param {number[]} nums * @return {number} */var maxValue = function (nums) {  // your code here — RETURN the answer, don't print it};

The judge is the program that checks your answer. It calls your function with test inputs. Then it compares what you return with the expected answer. So from now on, every practice answer in this series is a function that returns its result. After it come a few console.log calls to test it. This is how you would check your own work before you submit.

Practice questions

function square(n) {  return n * n;}console.log(square(5));  // 25console.log(square(-3)); // 9

const square = (n) => n * n;console.log(square(5)); // 25

const square = (n) => n ** 2;console.log(square(5));     // 25console.log(Math.pow(5, 2)); // 25

function isEven(n) {  return n % 2 === 0;}console.log(isEven(4)); // trueconsole.log(isEven(7)); // false

function isEven(n) {  if (n % 2 === 0) {    return true;  } else {    return false;  }}console.log(isEven(4)); // true

function max2(a, b) {  return a > b ? a : b;   // "? :" means: if a > b then a, else b}function max3(a, b, c) {  return max2(max2(a, b), c);}console.log(max2(4, 9));    // 9console.log(max3(4, 9, 2)); // 9console.log(max3(7, 7, 3)); // 7

const max3 = (a, b, c) => Math.max(a, b, c);console.log(max3(4, 9, 2)); // 9

function toFahrenheit(c) {  return (c * 9) / 5 + 32;}console.log(toFahrenheit(100)); // 212console.log(toFahrenheit(0));   // 32console.log(toFahrenheit(-40)); // -40

const toFahrenheit = (c) => (c * 9) / 5 + 32;const toCelsius = (f) => ((f - 32) * 5) / 9;console.log(toFahrenheit(100));          // 212console.log(toCelsius(212));             // 100console.log(toCelsius(toFahrenheit(37))); // 37

function isPrime(n) {  if (n < 2) return false;  for (let d = 2; d * d <= n; d++) {    if (n % d === 0) return false;   // early return  }  return true;}function countPrimes(N) {  let count = 0;  for (let i = 2; i <= N; i++) {    if (isPrime(i)) count++;  }  return count;}console.log(countPrimes(10)); // 4console.log(countPrimes(20)); // 8

function countPrimes(N) {  const isPrime = new Array(N + 1).fill(true);  isPrime[0] = isPrime[1] = false;  for (let p = 2; p * p <= N; p++) {    if (!isPrime[p]) continue;    for (let m = p * p; m <= N; m += p) {      isPrime[m] = false;              // m is a multiple of p    }  }  let count = 0;  for (let i = 2; i <= N; i++) if (isPrime[i]) count++;  return count;}console.log(countPrimes(10)); // 4console.log(countPrimes(20)); // 8

function power(base, exp) {  let result = 1;  for (let i = 1; i <= exp; i++) {    result *= base;  }  return result;}console.log(power(2, 10)); // 1024console.log(power(5, 0));  // 1

function power(base, exp) {  let result = 1;  while (exp > 0) {    if (exp % 2 === 1) result *= base;   // odd: use one factor now    base *= base;                        // square the base    exp = Math.floor(exp / 2);           // halve the exponent  }  return result;}console.log(power(2, 10)); // 1024console.log(power(3, 5));  // 243

function gcd(a, b) {  while (b !== 0) {    const r = a % b;    a = b;    b = r;  }  return a;}function lcm(a, b) {  return (a / gcd(a, b)) * b;   // divide first to keep numbers small}console.log(lcm(4, 6)); // 12console.log(lcm(5, 7)); // 35

function lcm(a, b) {  const big = Math.max(a, b), small = Math.min(a, b);  let m = big;  while (m % small !== 0) {    m += big;  }  return m;}console.log(lcm(4, 6)); // 12console.log(lcm(5, 7)); // 35

function addAndShow(a, b) {  console.log(a + b);}const result = addAndShow(3, 5);console.log(result);

8
undefined

function addAndShow(a, b) {  console.log(a + b);}const result = addAndShow(3, 5);console.log(result);/* Output:8undefined*/

function add(a, b) {  return a + b;}const result = add(3, 5);console.log(result); // 8

function sumDigits(n) {  let sum = 0;  while (n > 0) {    sum += n % 10;    n = Math.floor(n / 10);  }  return sum;}function digitalRoot(n) {  while (n >= 10) {    n = sumDigits(n);  }  return n;}console.log(digitalRoot(9875)); // 2console.log(digitalRoot(7));    // 7

function digitalRoot(n) {  if (n === 0) return 0;  return 1 + ((n - 1) % 9);}console.log(digitalRoot(9875)); // 2console.log(digitalRoot(9));    // 9

function isPowerOfTwo(n) {  if (n <= 0) return false;  while (n % 2 === 0) {    n = n / 2;  }  return n === 1;}console.log(isPowerOfTwo(16)); // trueconsole.log(isPowerOfTwo(12)); // falseconsole.log(isPowerOfTwo(1));  // true

function isPowerOfTwo(n) {  let p = 1;  while (p < n) {    p *= 2;  }  return p === n;}console.log(isPowerOfTwo(16)); // trueconsole.log(isPowerOfTwo(12)); // false

function isPowerOfTwo(n) {  return n > 0 && (n & (n - 1)) === 0;}console.log(isPowerOfTwo(16)); // trueconsole.log(isPowerOfTwo(12)); // false

Make it stick

Next lesson: arrays (one variable that stores many values) and the first real interview questions.