Imagine your kid is writing a program that says "Happy Birthday" to five different friends. Without functions, they'd copy and paste the same lines of code five times. Change one word? Now they're fixing it in five places. This is the exact moment functions click for most kids and the excitement on their face is fun to watch.
A function in JavaScript is a named block of code that performs one specific task. You write the code once, then run it whenever you need by calling its name. The official MDN Web Docs call functions one of the fundamental building blocks in JavaScript. Once kids grasp them, the rest of their coding projects start to feel more manageable.
Think of Functions Like Recipes
A recipe lists the steps to make cookies or sandwiches. You don't rewrite those steps every single time you cook. You just follow the same instructions again.
Functions work exactly like that. You write the steps once inside the function, give it a name, and then call that name to run the steps. Here's a simple example:
// This is the function (the recipe)
function sayHello() {
console.log("Hello there!");
}
// Now we run it (calling the function)
sayHello();
sayHello();
sayHello();
That prints "Hello there!" three times. The message was written once but used three times. That's the main point, write once, run many times.
If your child is new to JavaScript, start with the basics first. Our guide on what JavaScript is and how it works gives a friendly overview before jumping into functions.
How Parameters Make Functions More Useful
Basic functions are helpful, but parameters take them to the next level. Parameters act like fill-in-the-blanks that let you send different information to the same function each time.
Let's go back to the birthday example. Here's how a kid might write it with a parameter:
function singBirthday(name) {
console.log("Happy Birthday, " + name + "!");
console.log("Hope your day is awesome!");
}
singBirthday("Mia");
singBirthday("Jake");
singBirthday("Grandma");
One function, three different messages. The word name inside the parentheses is the parameter. When you call singBirthday("Mia"), JavaScript replaces name with "Mia" inside the function. Kids catch on quickly, especially when they test it with their friends' names.
Functions can take more than one parameter. If your child is making a math game, they might write a function that multiplies two numbers:
function multiply(a, b) {
return a * b;
}
console.log(multiply(5, 3)); // prints 15
console.log(multiply(7, 4)); // prints 28
The return statement sends a value back from the function so you can use it later. Think of it like a calculator showing the answer after you press equals. For more on how coding and math work together, check out how coding turns math into a fun adventure for kids.
Why Functions Help Kids Build Better Projects
After teaching coding for years, I've seen that kids who learn functions early create stronger projects and run into fewer roadblocks.
They stop repeating code. Copying and pasting is one of the fastest ways for beginners to create bugs. A function gives you one place to update the code.
They learn to break big tasks into smaller steps. Turning a game into separate functions for movement, scoring, and enemies teaches problem decomposition. This skill helps with schoolwork and other projects too. We explore this idea more in how coding helps kids break down big problems into steps.
Their code becomes easier to read. Well-named functions like movePlayer(), checkCollision(), and updateScore() make a program read almost like plain English.
A Quick Project: Build a Greeting Machine
The fastest way to understand functions is to write them. Try this short project that uses function declarations, parameters, return values, and function calls:
function createGreeting(name, timeOfDay) {
return "Good " + timeOfDay + ", " + name + "!";
}
function shout(message) {
return message.toUpperCase() + "!!!";
}
// Combine them!
const greeting = createGreeting("Alex", "morning");
console.log(shout(greeting));
// prints: GOOD MORNING, ALEX!!!!
See how shout takes the output from createGreeting and changes it? That's how real programs work, small functions that each handle one job and connect together like building blocks.
Once this feels comfortable, kids are ready for bigger projects. A quiz game works well next because it needs functions to check answers, track scores, and load questions.
What About Arrow Functions?
You may come across arrow functions in other code examples. They look like this:
const square = (number) => number * number;
They do the same job as regular functions but use shorter syntax. For beginners, stick with the regular function keyword first. Arrow functions have some tricky details (especially around this) that can confuse new coders. After kids have written plenty of normal functions, arrow functions become easy to learn.
Let Them Experiment
Reading about functions only teaches part of the lesson. The real learning happens when kids write their own, make mistakes with parentheses or return statements, and fix them. That trial-and-error process builds lasting understanding.
Learnspace's interactive JavaScript lessons guide kids through writing functions with a built-in code editor. They can experiment right away without any extra setup. Start learning functions in Learnspace and watch what your child can create once their code becomes reusable.