JavaScript Functions Flashcards For Beginners

Function.call() is a method in JavaScript that allows you to call a function with a given this value and arguments as an array. Here is an example code for using Function.call():

/* Function.call() */
function myFunction(param1, param2) {
  return param1 + param2 + this.myNumber;
}
let myObject = { myNumber: 42 };
console.log(myFunction.call(myObject, 1, 2)); // 45

A recursive function is a function that calls itself, either directly or indirectly. Here is an example code for using recursive function:

/* Recursive Function */
function myFunction(param) {
  if (param <= 0) {
    return 0;
  } else {
    return param + myFunction(param - 1);
  }
}
console.log(myFunction(5)); // 15

Default parameters are a way to define default values for function parameters in JavaScript. Here is an example code for using default parameters:

/* Default Parameters */
function myFunction(param1, param2 = 0) {
  return param1 + param2;
}
console.log(myFunction(1)); // 1
console.log(myFunction(1, 2)); // 3

A function expression is a way to define a function as a value of a variable. Here is an example code for using function expression:

/* Function Expression */
let myFunction = function(param1, param2) {
  return param1 + param2;
}
console.log(myFunction(1, 2)); // 3

Function.bind() is a method in JavaScript that returns a new function with a given this value and partially applied arguments. Here is an example code for using Function.bind():

/* Function.bind() */
function myFunction(param1, param2) {
  return param1 + param2 + this.myNumber;
}
let myObject = { myNumber: 42 };

let myNewFunction = myFunction.bind(myObject, 1, 2);
console.log(myNewFunction()); // 45

The spread operator (...) is a way to spread the elements of an array as arguments to a function in JavaScript. Here is an example code for using the spread operator:

/* Spread Operator */
function myFunction(param1, param2, param3) {
  return param1 + param2 + param3;
}
let myArray = [1, 2, 3];
console.log(myFunction(...myArray)); // 6

Function.apply() is a method in JavaScript that allows you to call a function with a given this value and arguments as an array. Here is an example code for using Function.apply():

/* Function.apply() */
function myFunction(param1, param2) {
  return param1 + param2 + this.myNumber;
}
let myObject = { myNumber: 42 };
console.log(myFunction.apply(myObject, [1, 2])); // 45

Rest parameters are a way to pass an arbitrary number of arguments to a function in JavaScript. Here is an example code for using rest parameters:

/* Rest Parameters */
function myFunction(...args) {
  return args.reduce((a, b) => a + b);
}
console.log(myFunction(1, 2, 3)); // 6

An immediately invoked function expression (IIFE) is a way to execute a function immediately after it is defined. Here is an example code for using IIFE:

/* IIFE */
(function() {
  console.log("Hello, world!");
})();

An anonymous function is a function without a name. Here is an example code for using anonymous function:

/* Anonymous Function */
let myFunction = function(param1, param2) {
  return param1 + param2;
}
console.log(myFunction(1, 2)); // 3

An arrow function is a concise way to define a function in JavaScript. Here is an example code for using arrow function:

/* Arrow Function */
let myFunction = (param1, param2) => param1 + param2;
console.log(myFunction(1, 2)); // 3

Currying is a technique where a function that takes multiple arguments is transformed into a series of functions that each take a single argument. Here is an example code for using currying:

/* Currying */
function myFunction(param1, param2) {
  return param1 + param2;
}
let myCurriedFunction = param1 => param2 => myFunction(param1, param2);
console.log(myCurriedFunction(1)(2)); // 

A function declaration is a way to define a named function in JavaScript. Here is an example code for using function declaration:

/* Function Declaration */
function myFunction(param1, param2) {
  return param1 + param2;
}
console.log(myFunction(1, 2)); // 3

A pure function is a function that always returns the same output for a given input, and does not have any side effects. Here is an example code for using pure function:

/* Pure Function */
function myFunction(param) {
  return param * 2;
}
console.log(myFunction(2)); // 4

A callback function is a function that is passed as an argument to another function and is called when a specific event occurs. Here is an example code for using callback function:

/* Callback Function */
function myFunction(callback) {
  setTimeout(callback, 1000);
}
function myCallback() {
  console.log("Hello, world!");
}
myFunction(myCallback); // "Hello, world!" after 1 second