- 01Setting Up (What You'll Need)
- 02Creating Variables
- 03Conditionals (if Statements)
- 04Loops (for Statements)
- 05Creating Functions
- 06Working with Arrays
- 07Working with Objects
- 08Loops (while Statements)
- 09Working with Strings
- 10Using Classes (Object-Oriented Programming)
- 11Error Handling (try...catch)
- 12Destructuring and the Spread Syntax
- 13Async Code (Promise / async & await)
- 14Advanced Array Methods (filter and reduce)
- 15The switch Statement
- 16The Ternary Operator
- 17Inheritance (Extending Classes)
- 18How to Write Comments
- 19Logical Operators (AND, OR, NOT)
- 20Constants (Making Read-Only Values with const)
- 21Splitting and Joining Strings (split and join)
- 22Null-Safe Syntax (?? and ?.)
- 23Searching Arrays and Collections (includes and find)
- 24Transforming Arrays with map
- 25Two-Dimensional Arrays (Table-Shaped Data)
- 26Building a Custom Error Class
- 27Default Arguments (Setting Initial Values for Parameters)
- 28Using Set (Collections)
- 29Verifying Correctness with assert (Your First Step Into Testing)
- 30Higher-Order Functions (Passing a Function as an Argument)
- 31Stacks and Queues (Basic Data Structures)
- 32The Basics of Type Conversion (Casting)
- 33Introduction to Regular Expressions (Pattern Matching)
- 34The Binary Search Algorithm
- 35Building a Caesar Cipher (a Letter-Shifting Cipher)
- 36Understanding How Bubble Sort Works
- 37Building and Displaying Dates (Basic Year/Month/Day Operations)
- 38Writing Several Unit Tests Together (Multiple Test Cases)
- 39Speeding Up Calculations with Memoization (Caching)
- 40Normalizing Strings (trim and Case Unification)
- 41The Difference Between Shallow Copy and Deep Copy
- 42The Basics of Enums (Enumerated Types)
- 43Flattening Arrays (flatten)
- 44Reversing a String and Checking for a Palindrome
- 45Pairing Up Two Arrays (a zip Operation)
- 46Rounding Numbers (floor, ceil, and round)
- 47Multi-Line Strings (Template Literals)
- 48Returning Multiple Values from a Function (Array Destructuring)
- 49Finding the GCD and LCM (the Euclidean Algorithm)
- 50Formatting Numbers (Digit Alignment and Decimal Precision)
- 51Cleanup Processing with try/catch/finally
- 52Writing Type-Agnostic, General-Purpose Functions
- 53The Basics of Map (an Object for Key-Value Pairs)
- 54Generating Random Numbers
- 55Bitwise Operations (AND, OR, XOR, and Shift Operations)
- 56Using static (Static Class Properties and Methods)
- 57Waiting a Fixed Amount of Time (setTimeout and await)
- 58Watch Out for Floating-Point Rounding Error
- 59Transforming and Flattening at Once with flatMap()
- 60FizzBuzz (the Classic Practice Problem)
- 61Checking Whether a Number Is Prime
- 62Set Operations with Set (Union, Intersection, and Difference)
- 63Converting Number Bases (Binary and Hexadecimal)
- 64Checking That Brackets Match (an Application of Stacks)
- 65Checking for an Anagram
- 66Checking Whether a Year Is a Leap Year
- 67Converting Temperature (Celsius ⇄ Fahrenheit)
- 68Finding the Prime Factorization
- 69[Applied] Build a Simple To-Do List Tool
Creating Functions
In this lesson you'll learn how to write functions in JavaScript so you can write code that reuses the same logic multiple times. This is written for beginners who searched "JavaScript how to create a function" or "JavaScript function usage."
A function bundles a piece of processing and gives it a name. You define one with function name(arguments) { ...; return value; }, and call it with name(value). Think of it like a recipe: once you've written down a set of steps and given it a name, you can reproduce the same result any time you need it. The power of a function is that changing the arguments lets you get different results from the same logic.
The sample code defines a function called greet that takes an argument named name and uses return to give back a greeting message. A value returned with return can be used directly at the call site, for example console.log(greet("Bob")).
A common beginner mistake is forgetting to write return, which makes the function's result undefined. return means "finalize the function's result here and hand it back to the caller," so any function meant to produce a value absolutely needs it. Also watch out for confusion when a variable defined outside the function shares a name with one of its arguments.
In real development, the standard approach when you need to reuse the same calculation or data processing in multiple places is to extract it into a function first. Splitting your code into well-sized functions makes it easier to follow, and easier to fix bugs and write tests. The quality of your function design has a big impact on real-world code quality.
Some functions don't return a value and just perform an action — in that case you can omit return, and the caller simply runs the function without using a return value. Being conscious of the distinction between "functions that return a value" and "functions that just perform an action" makes your code's intent much clearer.
Function naming has its own tricks too: giving a function a name like greet or calculateTotal, where the verb conveys "what this function does," is the basic rule. A function whose name alone lets you guess what it does is a real kindness to whoever reads your code.
💡 Anything passed to console.log() appears in the output below.
