Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd
Upload
78 views

Learn JavaScript - Functions Cheatsheet - Codecademy

Arrow functions were introduced in ES6 as a concise syntax for writing anonymous functions. Arrow functions do not require the function keyword and use a fat arrow => to separate parameters from the function body. Functions are reusable blocks of code that perform tasks and can accept parameters and return values. Functions are defined using the function keyword followed by the function name, parameters in parentheses, and function body in curly braces. Functions are called by name followed by parentheses and arguments.

Uploaded by

IliasAhmed
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
78 views

Learn JavaScript - Functions Cheatsheet - Codecademy

Arrow functions were introduced in ES6 as a concise syntax for writing anonymous functions. Arrow functions do not require the function keyword and use a fat arrow => to separate parameters from the function body. Functions are reusable blocks of code that perform tasks and can accept parameters and return values. Functions are defined using the function keyword followed by the function name, parameters in parentheses, and function body in curly braces. Functions are called by name followed by parentheses and arguments.

Uploaded by

IliasAhmed
Copyright
© © All Rights Reserved
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 de ne 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 de ned using the function // Named function
keyword, or as an arrow function. See the code example function rocketToMars() {
for the di erence 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 de ned. 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 de ne a function }
without parameters.

return Keyword
Functions return (pass back) values using the return
keyword. return ends function execution and returns // With return
the speci ed 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