Functions in javascript

In JavaScript, functions are a fundamental building block of the language. They are used to group code into reusable units, and they play a crucial role in structuring and organizing JavaScript programs. Here are some key aspects of functions in JavaScript:

Function Declaration: Functions in JavaScript can be declared using the function keyword. Here's a simple example:

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

// Calling the function
greet("John"); // Output: Hello, John!

In this example, greet is a function that takes a parameter (name) and logs a greeting message to the console.

Function Expression:

Functions can also be defined using function expressions, where a function is assigned to a variable. Function expressions can be anonymous or named.

// Anonymous function expression
const multiply = function(x, y) {
  return x * y;
};

// Named function expression
const add = function sum(a, b) {
  return a + b;
};

console.log(multiply(3, 4)); // Output: 12
console.log(add(5, 6)); // Output: 11

Arrow Functions (ES6+):

Arrow functions provide a more concise syntax for defining functions, especially for simple functions with a single statement.

const square = (x) => x * x;

console.log(square(3)); // Output: 9

Default Parameters:

JavaScript allows you to specify default values for function parameters.

function greet(name = "Guest") {
  console.log("Hello, " + name + "!");
}

greet(); // Output: Hello, Guest!
greet("John"); // Output: Hello, John!

Rest Parameters:

The rest parameter allows a function to accept an indefinite number of arguments as an array.

function sum(...numbers) {
  return numbers.reduce((acc, num) => acc + num, 0);
}

console.log(sum(1, 2, 3, 4)); // Output: 10

Callback Functions:

JavaScript supports the concept of callback functions, where a function is passed as an argument to another function.

function processNumbers(numbers, callback) {
  return numbers.map(callback);
}

const double = (num) => num * 2;

const numbers = [1, 2, 3, 4];
const doubledNumbers = processNumbers(numbers, double);
console.log(doubledNumbers); // Output: [2, 4, 6, 8]

Function Scope:

Variables declared within a function are scoped to that function.

function example() {
  var localVar = "I am a local variable";
  console.log(localVar);
}

example(); // Output: I am a local variable
// console.log(localVar); // This would result in an error since localVar is not defined in this scope

Hoisting:

Function declarations are hoisted to the top of their containing scope, which means you can call a function before it's declared in the code.

greet("John"); // Output: Hello, John!

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

This are the functions in js for code organization, reusability, and creating modular and maintainable applications.