to separate parameters from the function body. Functions are reusable blocks of code that can accept parameters and return values. Functions are defined using the function keyword and called by name elsewhere in code. Parameters act as variables that represent the values passed into a function on call. Functions return values using the return keyword."> to separate parameters from the function body. Functions are reusable blocks of code that can accept parameters and return values. Functions are defined using the function keyword and called by name elsewhere in code. Parameters act as variables that represent the values passed into a function on call. Functions return values using the return keyword.">
[go: up one dir, main page]
Scribd
Upload
15 views3 pages

Learn JavaScript - Functions Cheatsheet - Codecademy

Arrow functions were introduced in ES6 as a concise way to write anonymous functions. Arrow functions use a fat arrow => to separate parameters from the function body. Functions are reusable blocks of code that can accept parameters and return values. Functions are defined using the function keyword and called by name elsewhere in code. Parameters act as variables that represent the values passed into a function on call. Functions return values using the return keyword.

Uploaded by

Maryam Ahmed
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
15 views3 pages

Learn JavaScript - Functions Cheatsheet - Codecademy

Arrow functions were introduced in ES6 as a concise way to write anonymous functions. Arrow functions use a fat arrow => to separate parameters from the function body. Functions are reusable blocks of code that can accept parameters and return values. Functions are defined using the function keyword and called by name elsewhere in code. Parameters act as variables that represent the values passed into a function on call. Functions return values using the return keyword.

Uploaded by

Maryam Ahmed
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 3

Cheatsheets / Learn JavaScript

Functions
Arrow Functions (ES6)
Arrow function expressions were introduced in ES6.
These expressions are clean and concise. The syntax for // Arrow function with two arguments
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:
};
Arrow functions with a single parameter do not console.log(sum(2,5)); // Prints: 7
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 result
of the expression without the return keyword. 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 // 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 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.
// 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 example function rocketToMars() {
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
expression instead of as a function declaration. They can const dog = function() {
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 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
keyword. return ends function execution and returns // With return
the specified value to the location where it was called. A function sum(num1, num2) {
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. When a // Defining the function
function is called, the code inside its function body runs. function sum(num1, num2) {
Arguments are values passed into a function when it is return num1 + num2;
called.
}

// Calling the function


sum(2, 4); // 6

You might also like