JavaScript Functions Tutorial: From Basics to Advanced In 2024

Telegram Group Join Now
WhatsApp Group Join Now

Hello everyone! I can’t wait to discuss one of my favourite subjects with you: JavaScript functions! As a JavaScript developer, I am aware that functions can initially appear to be a little unclear. But believe me, once you know how they operate, you’ll see why they’re so very helpful.

What are JavaScript Functions?

A code block that takes out a particular task is called a function. Basically, logic is encapsulated in JavaScript methods to make the code more reusable and comprehensible.

In JavaScript, defining a function has a very straightforward syntax. Parameters can be used as input for functions, which can then return a value or output.

Functions assist you in structuring and organising your code. They also facilitate the reuse of code and ease the comprehension and upkeep of sizable codebases.

Why Use JavaScript Functions?

There are a few key reasons why functions are integral to JavaScript:

  • Organization – Functions allow us to break our code into smaller, logical chunks. This makes it more organized and easier to understand.
  • Reusability – We can call the same function repeatedly whenever we want to execute the code inside it. This saves time and reduces duplication.
  • Abstraction – Functions allow an element of code to hide its execution details. A function’s internal workings don’t have to care about when we utilise it.
  • Encapsulation – Functions bundle code into discrete units or blocks. This prevents unintended interactions between different parts of a program.

Put simply, functions make our lives as programmers MUCH easier! Now let’s dive into how they actually work.

Defining and Calling Functions

The syntax for defining a function in JavaScript is:

function functionName() {
  <em>// function body</em>

To call or execute the function, we simply type the function name followed by parentheses:



function greet() {
  console.log("Hello World!");

greet(); <em>// Hello World!</em>

Here we have:

  • greet – the name of the function
  • () – parentheses after the name to indicate this is a function
  • {} – curly braces to mark the body of the function
  • console.log() – the code inside the function body
  • greet() – calling the function to execute the code inside

Once we’ve defined a JavaScript function, we can call it as many times as we want.

Learn JavaScript Programming Basics For Beginners In 2024

JavaScript Function Parameters

When parameters are passed into a function, it becomes even more helpful. We can increase a function’s dynamic and reusable features by using parameters.

We define parameters by listing variable names inside the parentheses when declaring a function:

function greet(name) {
  console.log("Hello " + name);

greet("tech comp reviews"); <em>// tech comp reviews</em>

Now our greet function accepts a name parameter, which allows us to customize the output each time we call it. We can pass different arguments to greet and it will greet whoever we want.

We can add multiple parameters separated by commas:

function multiply(num1, num2) {
  return num1 * num2; 

multiply(3, 5); <em>// 15</em>

Being able to pass parameters makes functions a lot more flexible and reusable.

Return Values

Along with parameters, we need a way for our functions to return results back to us. We do this with the return keyword:

function multiply(num1, num2) {
  return num1 * num2;

let result = multiply(3, 5); 
console.log(result); <em>// 15</em>

Whatever comes after return is what gets sent back to the caller. Return values allow our functions to produce customized results that we can then use in other parts of our code. Pretty handy.

JavaScript Variable Scope

Now this part can trip some people up.

Each function has its own scope. This means variables defined inside a function are only accessible within that JavaScript function.

Check out this example:

function greeting() {
  let message = "Hello!";
  <em>// We can use message here  </em>

<em>// But message is not defined here</em>
console.log(message); <em>// ReferenceError</em>

message only exists within the greeting function. Trying to use it outside causes an error. This prevents variables meant to be private to a function from accidentally interfering with the rest of the code.

Understanding scope helps avoid common mistakes when working with JavaScript functions.

JavaScript Function Declarations vs Expressions

Now that you have the basics down, it’s time to level up our knowledge.

In JavaScript functions can be defined in two main ways:

JavaScript Function Declarations

This is the standard function syntax we’ve been using so far:

<em>// Function declaration</em>
function add(x, y) {
  return x + y;

JavaScript Function Expressions

Here, the function is assigned to a variable:

<em>// Function expression </em>
const subtract = function(x, y) {
  return x - y;

The key difference is function declarations get hoisted, meaning they can be called before they are defined. Function expressions are not hoisted.

But why does this matter? Hoisting can cause confusing bugs if you’re not careful. My advice is to always use function expressions and avoid hoisting issues entirely.

Arrow Functions

One last game-changing feature you should know about is arrow functions. Check out this slick new syntax:

<em>// Arrow function</em>
const multiply = (x, y) => {
  return x * y;

Instead of function, we use the arrow => syntax. We don’t need the function keyword, return, or even {} around a single expression. This creates shorter, simpler functions:

const greet = name => console.log(`Hello ${name}!`);

greet('Jake'); <em>// Hello Jake!</em>

The use of arrow functions has altered my JavaScript writing style. You won’t want to go back once you’ve developed out of them.

JavaScript Functions


We just covered a ton of ground on JavaScript functions. Here are some key takeaways:

  • Functions encapsulate reusable code into logical blocks
  • Declare functions, then call them whenever you need to execute the code inside
  • Use parameters and return values to create more flexible functions
  • Understand function scope and the difference between declarations and expressions
  • Take advantage of arrow functions to write shorter, more concise functions

I hope this overview gave you a great introduction to using functions in JavaScript. They may take some practice, but mastering functions will take your programming skills to the next level.

Kindly message me with any more inquiries! I always enjoy assisting other programmers in their activities.

Leave a comment