Cheatsheets / Learn JavaScript

Functions
Arrow Functions (ES6)
Arrow function expressions were introduced in ES6.
These expressions are clean and concise. The syntax // Arrow function with two arguments

for an arrow function expression does not require the const sum = (firstParam, secondParam) =>
function keyword and uses a fat arrow => to { 
separate the parameter(s) from the body.

  return firstParam + secondParam;

There are several variations of arrow functions:

};

console.log(sum(2,5)); // Prints: 7 
Arrow functions with a single parameter do not

require () around the parameter list.

// Arrow function with no arguments

Arrow functions with a single expression can use

const printHello = () => { 

the concise function body which returns the

  console.log('hello');
result of the expression without the return

keyword. };

printHello(); // Prints: hello

// Arrow functions with a single argument

const checkWeight = weight => { 

  console.log(`Baggage weight : ${weight}

kilograms.`);

};

checkWeight(25); // Prints: Baggage

weight : 25 kilograms.

// Concise arrow functions

const multiply = (a, b) => a * b;

console.log(multiply(2, 30)); // Prints:

60

Functions
Functions are one of the fundamental building blocks in
JavaScript. A function is a reusable set of statements to // Defining the function:

perform a task or calculate a value. Functions can be function sum(num1, num2) {

passed one or more values and can return a value at

  return num1 + num2;

the end of their execution. In order to use a function,

}
you must define it somewhere in the scope where you

wish to call it.

// Calling the function:

The example code provided contains a function that

sum(3, 6); // 9
takes in 2 values and returns the sum of those numbers.

Anonymous Functions
Anonymous functions in JavaScript do not have a name
property. They can be defined using the function // Named function
keyword, or as an arrow function. See the code function rocketToMars() {
example for the difference between a named function   return 'BOOM!';
and an anonymous function. }

// Anonymous function
const rocketToMars = function() {
  return 'BOOM!';
}

Function Expressions
Function expressions create functions inside an
expression instead of as a function declaration. They const dog = function() {
can be anonymous and/or assigned to a variable.   return 'Woof!';
}

Function Parameters
Inputs to functions are known as parameters when a
function is declared or defined. Parameters are used as // The parameter is name
variables inside the function body. When the function is function sayHello(name) {
called, these parameters will have the value of whatever   return `Hello, ${name}!`;
is passed in as arguments. It is possible to define a }
function without parameters.

return Keyword
Functions return (pass back) values using the return
keyword. return ends function execution and returns // With return
the specified value to the location where it was called. function sum(num1, num2) {
A common mistake is to forget the return keyword, in   return num1 + num2;
which case the function will return undefined by }
default.

// Without return, so the function

doesn't output the sum
function sum(num1, num2) {
  num1 + num2;
}
Function Declaration
Function declarations are used to create named
functions. These functions can be called using their function add(num1, num2) {
declared name. Function declarations are built from:   return num1 + num2;
}
The function keyword.

The function name.

An optional list of parameters separated by

commas enclosed by a set of parentheses () .

A function body enclosed in a set of curly braces

{} .

Calling Functions
Functions can be called, or executed, elsewhere in
code using parentheses following the function name. // Defining the function

When a function is called, the code inside its function function sum(num1, num2) {
body runs. Arguments are values passed into a function

  return num1 + num2;

when it is called.

// Calling the function

sum(2, 4); // 6