JavaScript Functions:

JavaScript Functions

Why Use Functions?

Functions are the building blocks of JavaScript programs. They allow you to group together a set of instructions that perform a specific task. This makes your code more organized, reusable, and easier to maintain.

Syntax of a Function

function functionName(parameter1, parameter2) { 
  // Code to be executed
  return value;
}

Here's a breakdown of the syntax:

• function: Keyword indicating a function definition.
• functionName: Name you choose for your function.
• (parameter1, parameter2): Optional parameters passed to the function.
• { ... }: Code block containing the function's instructions.
• return value;: Optional statement to send back a value from the function.

Function Example

function greet(name) { 
  return "Hello, " + name + "!";
}

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

Parameters vs. Arguments

Parameters are variables declared within the function's parentheses (like name in the greet function). They represent placeholders for values you'll pass in when calling the function.

Arguments are the actual values you provide when you call a function (like "John" in greet("John")). These values are assigned to the corresponding parameters.

Function Return Type

The return statement determines the value a function sends back to the part of the code that called it. You can return any JavaScript data type, such as numbers, strings, arrays, or objects.

Function Inside a Function

You can define functions within other functions. This helps structure your code and create logical relationships between parts of your program.

function outerFunction() { 
  function innerFunction() { 
    console.log("This is from the inner function"); 
  }
  innerFunction(); 
}

In this example, innerFunction is defined inside outerFunction. You can only call innerFunction from within outerFunction.

Name Conflict

Summary

• Functions are reusable blocks of code that perform specific tasks.
• They improve code organization, reusability, and maintainability.
• Functions can accept parameters, perform operations, and return values.
• Avoid name conflicts by choosing unique names for variables and functions within the same scope.