Cheatsheets / Learn JavaScript

Functions
Arrow Functions (ES6)
Arrow function expressions were introduced in ES6. These expressions are clean and
concise. The syntax for an arrow function expression does not require the function // Arrow function with two arguments
keyword and uses a fat arrow => to separate the parameter(s) from the body. const sum = (firstParam, secondParam) => {
There are several variations of arrow functions:
return firstParam + secondParam;
● Arrow functions with a single parameter do not require () around the parameter
};
list. console.log(sum(2,5)); // Prints: 7
● Arrow functions with a single expression can use the concise function body which
returns the result of the expression without the return keyword. // Arrow function with no arguments
const printHello = () => {
console.log('hello');
};
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 perform a task or calculate a value. Functions can be passed one or // Defining the function:
more values and can return a value at the end of their execution. In order to use a function, function sum(num1, num2) {
you must de ne it somewhere in the scope where you wish to call it.
return num1 + num2;
The example code provided contains a function that takes in 2 values and returns the sum
}
of those numbers.

// Calling the function:

sum(3, 6); // 9

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

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

Function Expressions
Function expressions create functions inside an expression instead of as a function
declaration. They can be anonymous and/or assigned to a variable. const dog = function() {
return 'Woof!';
}
Function Parameters
Inputs to functions are known as parameters when a function is declared or de ned.
Parameters are used as variables inside the function body. When the function is called, // The parameter is name
these parameters will have the value of whatever is passed in as arguments. It is possible to function sayHello(name) {
de ne a function without parameters.
return `Hello, ${name}!`;
}

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

// 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 declared name. Function declarations are built from: function add(num1, num2) {
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. When a function is called, the code inside its function body runs. Arguments // Defining the function
are values passed into a function when it is called. function sum(num1, num2) {
return num1 + num2;
}

// Calling the function

sum(2, 4); // 6