Functions in JavaScript are blocks of code that perform a specific task and can be reused multiple times in a program. They are a fundamental building block of the language and are used to break down complex problems into smaller, more manageable parts.
A function is defined using the function
keyword followed by a function name, a list of parameters within parentheses, and a block of code within curly braces. The block of code within the function is executed when the function is called.
For example:
function greet(name) { console.log("Hello, " + name + "!"); } greet("John"); // prints "Hello, John!"
In this example, the greet
function takes a single argument name
and uses it to generate a greeting. The function can be called multiple times with different values for name
to generate different greetings.
Functions in JavaScript can also return a value using the return
keyword.
For example:
function add(a, b) { return a + b; } let result = add(2, 3); // result is 5
In this example, the add
function takes two arguments a
and b
, adds them together, and returns the result. The result of the function can be stored in a variable and used later in the program.
Functions can also be assigned to variables and passed as arguments to other functions. This allows for the creation of higher-order functions, which are functions that operate on other functions.
For example:
function square(x) { return x * x; } function cube(x) { return x * x * x; } function operate(fn, x) { return fn(x); } let result = operate(square, 4); // result is 16 result = operate(cube, 4); // result is 64
In this example, the operate
function takes two arguments: a function fn
and a value x
. It calls the function fn
with the argument x
and returns the result. This allows the same operate
function to be used with different functions, such as square
and cube
, to perform different operations on the same value.
Functions in JavaScript provide a powerful way to structure and reuse code. By breaking down problems into smaller, reusable parts, functions make it easier to write and maintain large, complex programs.