Functions & Expressions

function square(number) {
  return number * number;
}

console.log(square(4)); // 16

function addTen(num) {
  num = num + 10;
  return num;
}

let value = 5;
console.log(addTen(value)); // 15
console.log(value);         // 5 — unchanged

function myFunc(theObject) {
  theObject.make = 'Toyota';          // changes the shared object
}

const mycar = { make: 'Honda', model: 'Accord', year: 1998 };
const x = mycar.make;                 // "Honda"
myFunc(mycar);
const y = mycar.make;                 // "Toyota" — changed by the function
console.log(x, y);                    // "Honda" "Toyota"

function replace(theObject) {
  theObject = { make: 'Ford' };       // points the local parameter to a new object
}
replace(mycar);
console.log(mycar.make);              // "Toyota" — the caller's object is unchanged

const square = function (number) {
  return number * number;
};

console.log(square(4)); // 16

const calculator = {
  square(n) { return n * n; }
};
console.log(calculator.square(5)); // 25

a(); // "a called"
b(); // TypeError: b is not a function

// Function declaration (function statement)
function a() {
  console.log("a called");
}

// Function expression
var b = function () {
  console.log("b called");
};

c(); // ReferenceError: Cannot access 'c' before initialization
const c = function () {};

function () {
}
// SyntaxError: Function statements require a function name

const greet = function () { return 'hi'; };        // assigned to a variable
setTimeout(function () { console.log('done'); }, 0); // passed as an argument
[1, 2, 3].map(function (n) { return n * 2; });       // callback
(function () { console.log('IIFE runs immediately'); })(); // IIFE

var b = function xyz() {
  console.log("b called");
};

var b = function xyz() {
  console.log("xyz called");
  console.log(typeof xyz); // "function" — xyz is visible inside
};

b();   // "xyz called", "function"
xyz(); // ReferenceError: xyz is not defined

function add(a, b) {   // a, b → parameters
  return a + b;
}
add(2, 3);             // 2, 3 → arguments

function show(a, b) {
  console.log(a, b);
}
show(1);        // 1 undefined — missing arguments are undefined
show(1, 2, 3);  // 1 2 — extra arguments are ignored (but available in `arguments`)
console.log(add.length); // 2 — number of declared parameters

var foo = function bar() {
  // statements go here
};

function factorial(n) {
  if (n <= 1) return 1;          // base case — stops the recursion
  return n * factorial(n - 1);   // calls itself by name
}

console.log(factorial(5)); // 120 → 5 * 4 * 3 * 2 * 1

const foo = function bar(n) {
  if (n <= 0) return 'done';
  return bar(n - 1);             // works — bar is visible inside
};

console.log(foo(3)); // "done"
// console.log(bar(3)); // ReferenceError: bar is not defined — not visible outside

const countdown = function (n) {
  if (n < 0) return;
  console.log(n);
  arguments.callee(n - 1);       // calls the current function
};

countdown(2); // 2, 1, 0

'use strict';
const fn = function () { return arguments.callee; };
// fn(); // TypeError: 'caller', 'callee', and 'arguments' properties may not be accessed in strict mode

const sum = function (arr) {
  if (arr.length === 0) return 0;
  return arr[0] + sum(arr.slice(1)); // calls itself through the variable "sum"
};

console.log(sum([1, 2, 3, 4])); // 10

let fact = function (n) {
  return n <= 1 ? 1 : n * fact(n - 1);   // depends on the variable "fact"
};
const saved = fact;
fact = null;
// saved(5); // TypeError: fact is not a function

let fact2 = function inner(n) {
  return n <= 1 ? 1 : n * inner(n - 1);  // depends on its own name
};
const saved2 = fact2;
fact2 = null;
console.log(saved2(5)); // 120 — still works

function foo(i) {
  if (i < 0) return;
  console.log('begin: ' + i);
  foo(i - 1);
  console.log('end: ' + i);
}

foo(3);

// Output:
// begin: 3
// begin: 2
// begin: 1
// begin: 0
// end: 0
// end: 1
// end: 2
// end: 3

function addSquares(a, b) {
  function square(x) {
    return x * x;
  }
  return square(a) + square(b);
}

console.log(addSquares(2, 3)); // 13
console.log(addSquares(3, 4)); // 25
// square(2);                  // ReferenceError: square is not defined — private to addSquares

function outside(x) {
  function inside(y) {
    return x + y;
  }
  return inside;
}

const addThree = outside(3); // a function that adds 3 to whatever you give it
console.log(addThree(5));    // 8
console.log(outside(3)(5));  // 8 — same thing in one line

const addTwo = outside(2);
const addTen = outside(10);

console.log(addTwo(1)); // 3  — its own x = 2
console.log(addTen(1)); // 11 — its own x = 10

function A(x) {
  function B(y) {
    function C(z) {
      console.log(x + y + z);
    }
    C(3);
  }
  B(2);
}

A(1); // 6 (1 + 2 + 3)

function outside() {
  const x = 5;
  function inside(x) {  // parameter x shadows the outer x
    return x * 2;
  }
  return inside;
}

console.log(outside()(10)); // 20 — uses the inner x (10), not 5

const pet = function (name) {       // outer function has a "name" variable
  const getName = function () {
    return name;                    // inner function can read it
  };
  return getName;                   // expose only the inner function
};

const myPet = pet('Vivie');
console.log(myPet());   // "Vivie"
console.log(myPet.name);// "getName" — the function's own name, not the pet's name

const createPet = function (name) {
  let sex;

  return {
    setName(newName) {
      name = newName;
    },
    getName() {
      return name;
    },
    getSex() {
      return sex;
    },
    setSex(newSex) {
      if (typeof newSex === 'string' &&
          (newSex.toLowerCase() === 'male' || newSex.toLowerCase() === 'female')) {
        sex = newSex;
      }
    }
  };
};

const pet1 = createPet('Vivie');
console.log(pet1.getName()); // "Vivie"

pet1.setName('Oliver');
pet1.setSex('male');
pet1.setSex('robot');        // ignored — fails validation
console.log(pet1.getSex());  // "male"
console.log(pet1.getName()); // "Oliver"
console.log(pet1.name);      // undefined — no direct access to the private variable

const getCode = (function () {
  const apiCode = '0]Eal(eh&2'; // cannot be changed from outside
  return function () {
    return apiCode;
  };
})();

console.log(getCode()); // "0]Eal(eh&2"

const createPet2 = function (name) {   // outer "name"
  return {
    setName(name) {                    // parameter also called "name"
      name = name;                     // assigns the parameter to itself — outer name never changes
    },
    getName() {
      return name;
    }
  };
};

const p = createPet2('Vivie');
p.setName('Oliver');
console.log(p.getName()); // "Vivie" — not updated!

// Fix: use a different parameter name, e.g. setName(newName) { name = newName; }

function myConcat(separator) {
  let result = '';
  for (let i = 1; i < arguments.length; i++) { // start at 1 to skip separator
    result += arguments[i] + separator;
  }
  return result;
}

console.log(myConcat(', ', 'red', 'orange', 'blue'));
// "red, orange, blue, "
console.log(myConcat('; ', 'elephant', 'giraffe', 'lion', 'cheetah'));
// "elephant; giraffe; lion; cheetah; "
console.log(myConcat('. ', 'sage', 'basil', 'oregano', 'pepper', 'parsley'));
// "sage. basil. oregano. pepper. parsley. "

function test() {
  console.log(arguments.length);          // 3
  console.log(Array.isArray(arguments));  // false
  // arguments.map(x => x);               // TypeError: arguments.map is not a function
  console.log(Array.from(arguments));     // [1, 2, 3] — convert to a real array
}
test(1, 2, 3);

const arrow = () => {
  // console.log(arguments); // ReferenceError in modules — arrow functions have no own `arguments`
};

function multiply(a, b) {
  b = typeof b !== 'undefined' ? b : 1;
  return a * b;
}

console.log(multiply(5)); // 5

function multiply(a, b = 1) {
  return a * b;
}

console.log(multiply(5));            // 5 — b uses the default 1
console.log(multiply(5, 2));         // 10
console.log(multiply(5, undefined)); // 5 — undefined triggers the default
console.log(multiply(5, null));      // 0 — null does NOT trigger the default (5 * null → 0)

function greet(name, message = `Hello ${name}`) {
  return message;
}
console.log(greet('Sam')); // "Hello Sam"

function addItem(item, list = []) {
  list.push(item);
  return list;
}
console.log(addItem('a')); // ["a"]
console.log(addItem('b')); // ["b"] — a new [] is created on each call

function multiply(multiplier, ...theArgs) {
  return theArgs.map(x => multiplier * x);
}

console.log(multiply(2, 1, 2, 3)); // [2, 4, 6]

function sum(...nums) {
  return nums.reduce((total, n) => total + n, 0);
}
console.log(sum());        // 0
console.log(sum(1, 2, 3)); // 6

// function wrong(...a, b) {} // SyntaxError: Rest parameter must be last formal parameter

function max(...nums) {          // rest: collects arguments into an array
  return Math.max(...nums);      // spread: expands an array into arguments
}
console.log(max(3, 9, 4)); // 9

// 1. Assign to a variable
const sayHi = function () { return 'Hi'; };

// 2. Pass as an argument
function run(fn) {
  return fn();
}
console.log(run(sayHi)); // "Hi"

// 3. Return from a function
function makeMultiplier(factor) {
  return function (n) {
    return n * factor;
  };
}
const double = makeMultiplier(2);
console.log(double(5)); // 10

// 4. Store in a data structure
const actions = { greet: sayHi };
console.log(actions.greet()); // "Hi"

function greeting(name) {
  console.log('Hello ' + name);
}

function processUserInput(callback) {
  const name = 'Rishabh'; // e.g. from a form or prompt()
  callback(name);
}

processUserInput(greeting); // "Hello Rishabh"

setTimeout(() => {
  console.log("timer");
}, 5000);

function x(y) {
  console.log("x");
  y();
}

x(function y() {
  console.log("y");
});

// Output:
// x
// y
// timer   (after about 5 seconds)

setTimeout(() => console.log('timer'), 0);
const start = Date.now();
while (Date.now() - start < 2000) {} // blocks the thread for 2 seconds
console.log('loop done');
// Output:
// loop done
// timer — even with 0 ms, it had to wait for the blocking loop

const elements = ['Hydrogen', 'Helium', 'Lithium', 'Beryllium'];

const a2 = elements.map(function (s) { return s.length; });
console.log(a2); // [8, 6, 7, 9]

const a3 = elements.map(s => s.length);
console.log(a3); // [8, 6, 7, 9]

const noParams = () => 'hi';
const oneParam = x => x * 2;           // parentheses optional for one parameter
const twoParams = (a, b) => a + b;
const withBody = (a, b) => {           // braces need an explicit return
  const sum = a + b;
  return sum;
};
const returnObject = () => ({ id: 1 }); // wrap an object in ()

console.log(noParams(), oneParam(4), twoParams(1, 2), withBody(2, 3), returnObject());
// "hi" 8 3 5 { id: 1 }

const forgotReturn = (a, b) => { a + b };
console.log(forgotReturn(1, 2)); // undefined — braces without return

function Person() {
  this.age = 0;   // `this` is the new Person object

  setInterval(function growUp() {
    // A plain function call: `this` is the global object (or undefined in strict mode),
    // NOT the Person instance
    this.age++;   // NaN on window.age, or TypeError in strict mode
  }, 1000);
}

const p = new Person();

function Person() {
  const self = this; // some use `that` instead of `self`
  self.age = 0;

  setInterval(function growUp() {
    self.age++;      // refers to the Person instance
  }, 1000);
}

function Person() {
  this.age = 0;
  setInterval(function growUp() {
    this.age++;
  }.bind(this), 1000); // lock `this` to the Person instance
}

function Person() {
  this.age = 0;
  setInterval(() => {
    this.age++;      // `this` is the Person instance
  }, 1000);
}

const counter = {
  count: 0,
  incArrow: () => { this.count++; },   // `this` is NOT counter
  incNormal() { this.count++; }        // `this` is counter
};

counter.incNormal();
counter.incArrow();
console.log(counter.count); // 1 — only incNormal worked

const Car = () => {};
// new Car(); // TypeError: Car is not a constructor

console.log(isNaN('abc'), Number.isNaN('abc')); // true false
console.log(isFinite('12'), Number.isFinite('12')); // true false — Number.* does not convert

const query = 'rock & roll';
console.log(`/search?q=${encodeURI(query)}`);          // "/search?q=rock%20&%20roll" — & breaks the query
console.log(`/search?q=${encodeURIComponent(query)}`); // "/search?q=rock%20%26%20roll" — correct

const foo = ['one', 'two', 'three'];

// without destructuring
const one1 = foo[0];
const two1 = foo[1];

// with destructuring
const [one, two, three] = foo;
console.log(one, two, three); // "one" "two" "three"

// skip items, rest, defaults
const [first, , third] = foo;          // "one", "three"
const [head, ...tail] = foo;           // "one", ["two", "three"]
const [x = 10, y = 20] = [1];          // x = 1, y = 20

// swap without a temp variable
let m = 1, n = 2;
[m, n] = [n, m];
console.log(m, n); // 2 1

const user = { id: 7, name: 'Asha', address: { city: 'Pune' } };

const { name, id } = user;                     // "Asha", 7
const { name: userName } = user;               // rename → userName = "Asha"
const { role = 'guest' } = user;               // default → "guest"
const { address: { city } } = user;            // nested → "Pune"
const { id: _, ...rest } = user;               // rest → { name, address }

function printUser({ name, age = 18 }) {       // destructuring in parameters
  console.log(name, age);
}
printUser(user); // "Asha" 18

// const { a } = null; // TypeError: Cannot destructure property 'a' of 'null'

for (let i = 0, j = 5; i < j; i++, j--) {
  console.log(i, j);
}
// 0 5
// 1 4
// 2 3

const result = (1, 2, 3);
console.log(result); // 3

delete object.property;
delete object[propertyKey];

const myobj = { h: 4 };
console.log(delete myobj.h);   // true — own, configurable property
console.log(myobj.h);          // undefined

console.log(delete Math.PI);   // false — non-configurable property

var y = 43;
console.log(delete y);         // false — variables declared with var/let/const cannot be deleted

const trees = ['redwood', 'bay', 'cedar'];
delete trees[1];
console.log(trees);        // ["redwood", empty, "cedar"]
console.log(trees.length); // 3

const trees2 = ['redwood', 'bay', 'cedar'];
trees2.splice(1, 1);
console.log(trees2);       // ["redwood", "cedar"]
console.log(trees2.length);// 2

const myFun = new Function('5 + 2');
const shape = 'round';
const size = 1;
const foo2 = ['Apple', 'Mango', 'Orange'];
const today = new Date();

console.log(typeof myFun);       // "function"
console.log(typeof shape);       // "string"
console.log(typeof size);        // "number"
console.log(typeof foo2);        // "object"
console.log(typeof today);       // "object"
console.log(typeof doesntExist); // "undefined" — no ReferenceError

console.log(void 0);          // undefined
console.log(void (2 + 2));    // undefined — expression runs, result discarded

// Historical use in links: <a href="javascript:void(0)">Click</a>

const logOnly = () => void console.log('side effect'); // arrow that never returns a value
console.log(logOnly());       // "side effect", then undefined

propNameOrNumber in objectName

// Arrays — checks indexes, not values
const trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
console.log(0 in trees);        // true
console.log(3 in trees);        // true
console.log(6 in trees);        // false
console.log('bay' in trees);    // false — use trees.includes('bay')
console.log('length' in trees); // true — length is an array property

// Built-in objects
console.log('PI' in Math);      // true
const myString = new String('coral');
console.log('length' in myString); // true
// console.log('length' in 'coral'); // TypeError — right side must be an object

// Custom objects
const mycar = { make: 'Honda', model: 'Accord', year: 1998 };
console.log('make' in mycar);     // true
console.log('toString' in mycar); // true — inherited
console.log(Object.hasOwn(mycar, 'toString')); // false — only own properties

const theDay = new Date(1995, 11, 17); // months are 0-based: 11 = December
if (theDay instanceof Date) {
  console.log('It is a Date'); // runs
}

console.log([] instanceof Array);  // true
console.log([] instanceof Object); // true
console.log('text' instanceof String); // false — primitive, not an object

console.log(1 + 2 * 3);         // 7
console.log(typeof 1 + 2);      // "number2" — typeof runs first: "number" + 2
console.log(typeof (1 + 2));    // "number"
console.log(!true === false);   // true — ! runs before ===

this.propertyName
this['propertyName']

const user = {
  name: 'Asha',
  hello() {
    return `Hi, ${this.name}`;
  }
};
console.log(user.hello()); // "Hi, Asha" — this = user

const hello = user.hello;
console.log(hello());      // "Hi, undefined" (or TypeError in strict mode) — this is lost

const a = 1, b = 2, c = 3;

console.log(a + b * c);   // 7 — multiplication first
console.log((a + b) * c); // 9 — addition first because of ()

const objectName = new ObjectType(param1, param2 /* , ..., paramN */);

function Car(make) {
  this.make = make;
}
const car = new Car('Honda');
console.log(car.make);             // "Honda"
console.log(car instanceof Car);   // true

const date = new Date(2026, 0, 1);
console.log(date.getFullYear());   // 2026

super(arguments);             // call the parent constructor
super.functionOnParent(args); // call a parent method

class Animal {
  constructor(name) {
    this.name = name;
  }
  speak() {
    return `${this.name} makes a sound`;
  }
}

class Dog extends Animal {
  constructor(name) {
    super(name);              // must be called before using `this`
  }
  speak() {
    return `${super.speak()} — woof`;
  }
}

console.log(new Dog('Rex').speak()); // "Rex makes a sound — woof"