Milyen funkciók léteznek a JavaScript-ben?

A JavaScript-ben a következő típusú függvények léteznek:

Függvénydeklarációk (Function Declarations): Alap szintaxis a függvény definiálásához. A fordítás során felhozhatók (hoisted).
```
function sayHello() {
  // Függvény törzse
  console.log("Szia!");
}
```
Függvénykifejezések (Function Expressions): Egy függvény egy változóhoz van rendelve. Nem hozhatók fel (hoisted). Lehetnek névvel vagy névtelenek.
```
const greetUser = function(name) {
  // Függvény törzse
  console.log(`Szia, ${name}!`);
};
```
Nyílfüggvények (Arrow Functions): Rövidebb szintaxis, amit az ES6 vezetett be. Különleges viselkedésük van a this-el kapcsolatban.
```
const add = (a, b) => a + b;
```
Objektum metódusok (Object Methods): Olyan függvények, amiket egy objektum tulajdonságaként definiálnak.
```
const user = {
  name: "Ivan",
  sayName: function() {
    console.log(this.name);
  }
};
```
Generator függvények (Generator Functions): Olyan függvények, amik a yield segítségével szüneteltethetők és folytathatók. Iterator-t adnak vissza.
```
function* counter() {
  let i = 0;
  while (true) {
    yield i++;
  }
}
```

Aszinkron függvények (Async Functions): Promiszekkel dolgoznak, és az await kulcsszóval várakoznak a promisek teljesülésére.

async function fetchData() {
  const response = await fetch("https://api.example.com/data");
  const data = await response.json();
  return data;
}

Konstruktor függvények (Constructor Functions): Olyan függvények, amiket a new operátorral használnak objektumok létrehozására. Hagyományos OOP megközelítés a classok megjelenése előtt.
```
function Person(name, age) {
  this.name = name;
  this.age = age;
}

const person1 = new Person("Petr", 30);
```

Visszahívó függvények (Callback Functions): Olyan függvények, amiket másik függvény argumentumaként adnak át, és egy adott pillanatban futtatnak.

function processArray(arr, callback) {
  for (let i = 0; i < arr.length; i++) {
    callback(arr[i]);
  }
}

processArray([1, 2, 3], function(item) {
  console.log(item * 2);
});

Azonnal meghívott függvénykifejezések (IIFE - Immediately Invoked Function Expressions): Olyan függvények, amik azonnal futnak a definíciójuk után. Lokális környezetet hoznak létre.
```
(function() {
  // Lokális kód
  const secret = "titok";
  console.log(secret);
})();
```

Minden függvény típusnak megvannak a saját szintaxis jellemzői, hatóköre (this) és felhasználási forgatókönyvei.