Different ways of writing a function in Javascript

Here are several ways to write functions in JavaScript:

Function declaration: This is the most common way of declaring a function in JavaScript. It uses the function keyword followed by the function name, parameter list in parentheses, and the function body in curly braces. For example:

`function addNumbers(x, y) {
  return x + y;
}`

Function expression: A function expression is created by assigning a function to a variable. It can be either an anonymous function or a named function. For example:

var addNumbers = function(x, y) {
  return x + y;
};

Arrow function: Arrow functions provide a shorter syntax for writing function expressions. They are denoted by a fat arrow => and do not require the function keyword. For example:

var addNumbers = (x, y) => {
  return x + y;
};

You can also omit the curly braces and return keyword for single-line arrow functions:

var addNumbers = (x, y) => x + y;

Function constructor: This method creates a function using the Function constructor. It takes a string of arguments and function body as parameters. For example:

var addNumbers = new Function('x', 'y', 'return x + y');

Generator function: A generator function returns an iterator object that can be used to iterate through a sequence of values. It is declared using the function* keyword and contains one or more yield statements. For example:

function* generateNumbers() {
  yield 1;
  yield 2;
  yield 3;
}

Immediately invoked function expression (IIFE): An IIFE is a function that is declared and invoked immediately. It is typically used to create a private scope for variables and functions. For example:

(function() {
  // code here
})();

These are some of the most common ways to write functions in JavaScript. Each has its own advantages and use cases, so it's important to choose the right method for your particular situation.