Scribd
Upload
7 views

Learn JavaScript - Functions Cheatsheet - Codecademy

Uploaded by

Malathi N
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
7 views

Learn JavaScript - Functions Cheatsheet - Codecademy

Uploaded by

Malathi N
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 4

Cheatsheets / Learn JavaScript

Functions

Arrow Functions (ES6)

Arrow function expressions were introduced in ES6. // Arrow function with two parameters
These expressions are clean and concise. The syntax for
const sum = (firstParam, secondParam) => {
an arrow function expression does not require the
function keyword and uses a fat arrow => to return firstParam + secondParam;
separate the parameter(s) from the body. };
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 functions with a single expression can use // Arrow function with no parameters
the concise function body which returns the
const printHello = () => {
result of the expression without the return
keyword. console.log('hello');
};
printHello(); // Prints: hello

// Arrow functions with a single parameter


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 // Defining the function:
JavaScript. A function is a reusable set of statements to
function sum(num1, num2) {
perform a task or calculate a value. Functions can be
passed one or more values and can return a value at the return num1 + num2;
end of their execution. In order to use a function, you }
must define it somewhere in the scope where you wish to
call it.
The example code provided contains a function that // Calling the function:
takes in 2 values and returns the sum of those numbers. sum(3, 6); // 9

Anonymous Functions

Anonymous functions in JavaScript do not have a name // Named function


property. They can be defined using the function
function rocketToMars() {
keyword, or as an arrow function. See the code example
for the difference between a named function and an return 'BOOM!';
anonymous function. }

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

Function Expressions

Function expressions create functions inside an const dog = function() {


expression instead of as a function declaration. They can
return 'Woof!';
be anonymous and/or assigned to a variable.
}

Function Parameters

Inputs to functions are known as parameters when a // The parameter is name


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

Functions return (pass back) values using the return // With return
keyword. return ends function execution and returns
function sum(num1, num2) {
the specified value to the location where it was called. 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 function add(num1, num2) {


functions. These functions can be called using their
return num1 + num2;
declared name. Function declarations are built from:
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 // Defining the function


using parentheses following the function name. When a
function sum(num1, num2) {
function is called, the code inside its function body runs.
Arguments are values passed into a function when it is return num1 + num2;
called. }

// Calling the function


sum(2, 4); // 6
Print Share

You might also like