Introduction to Functions in JavaScript

Breaking Programs into Smaller, Reusable Parts

What Are Functions?

Functions (also called procedures) are blocks of code that perform a specific task.

They allow us to reuse logic, organize our programs, and simplify complex tasks.

Built-in Functions

You've already been using functions in your JavaScript programs.

1
console.log("Hello world!");

You may not know exactly how console.log() works behind the scenes, but that's okay. Functions are designed so you can use functionality without needing to understand every detail.

This is known as abstraction.

Key Benefits of Using Functions

• Reusability: Write code once and use it multiple times.
• Modularity: Break down complex problems into smaller, manageable parts.
• Readability: Make code easier to understand and maintain.
• Debugging: Find and fix errors in isolated sections.

Parts of a Function

1
function greeting() {
2
  console.log("Hey buddy!");
3
  console.log("How are you?");
4
}

First line (definition): Declares the function using the function keyword, its name, and parentheses for parameters.

Parts of a Function

1
function greeting() {
2
  console.log("Hey buddy!");
3
  console.log("How are you?");
4
}

Definition line: Includes the function keyword, the function name, and parameters (if any).

Body: Contains the instructions that run when the function is called.

Function Definition Line

1
function greeting() {
2
  console.log("Hey buddy!");
3
  console.log("How are you?");
4
}

In this example:

• function - keyword that starts a function definition.
• greeting - the function name.
• () - parentheses (empty for now, later used for parameters).

Defining a Function ≠ Calling a Function

Defining a function describes what it does, but it doesn't run until you call or invoke it.

1
function greeting() {
2
  console.log("Hey buddy!");
3
  console.log("How are you?");
4
}
5

6
greeting();  // Function call
7
greeting();  // Call it again

Each time greeting() is called, the same code runs again — a simple example of code reuse.

Variable Scope

Variables declared inside a function exist only within that function.

1
function randomNumber() {
2
  let randomNumber = Math.floor(Math.random() * 10);
3
}
4

5
function revealAnswer() {
6
  ❌console.log("The secret number was " + randomNumber);
7
}

Local Variables: Declared inside a function — only accessible there.

Once a function finishes running, its local variables are removed from memory.

Functions in Practice

• Keep your overall program logic short and easy to read.
• Group related behavior into its own function.

Next Lesson Preview

Parameters and Return Values

So far, our functions don't take any input or return any output.

In the next lesson, you'll learn how to make your functions more flexible by:

• Passing arguments into a function.
• Returning values back to the caller.

Key Terms

Function

A named block of code that performs a specific task. Functions make programs modular, reusable, and easier to read.

Function Definition

The line that starts a function and the code block that follows it. It specifies the function name and its parameters (if any).

Function Body

The code block inside curly braces that contains the instructions the function will execute.

Key Terms

Return Value

The value a function sends back to the part of the program that called it. (In this lesson, our functions do not return values.)

Function Call (Invocation)

The statement that executes a function by using its name followed by parentheses. i.e. "Using the function".

Local Variable

A variable declared inside a function. It can only be accessed within that function and is removed from memory once the function finishes.

Key Terms

Scope

The region of a program where a variable can be accessed. Local variables have function-level scope.

Abstraction

The concept of using functions or other structures without knowing the full details of how they work internally.

Modularity

Dividing a program into independent sections or modules, such as functions, to simplify design and debugging.

Key Terms

Code Reuse

The practice of writing a function once and using it multiple times instead of duplicating code.