Welke functies bestaan er in JavaScript?

In JavaScript, bestaan de volgende soorten functies:

Functie-verklaringen (Function Declarations): Basis syntax voor het definiëren van een functie. Worden gehoist (hoisted) tijdens de compilatie.
```
function sayHello() {
  // Functielichaam
  console.log("Hallo!");
}
```
Functie-expressies (Function Expressions): Een functie wordt toegewezen aan een variabele. Worden niet gehoist. Kunnen genummerd of anoniem zijn.
```
const greetUser = function(name) {
  // Functielichaam
  console.log(`Hallo, ${name}!`);
};
```
Pijlfuncties (Arrow Functions): Meer beknopte syntax geïntroduceerd in ES6. Hebben specifieke gedragingen met this.
```
const add = (a, b) => a + b;
```

Objectmethoden (Object Methods): Functies gedefinieerd als eigenschappen van een object.

const user = {
  name: "Ivan",
  sayName: function() {
    console.log(this.name);
  }
};

Generatorfuncties (Generator Functions): Functies die hun uitvoering kunnen pauzeren en hervatten met yield. Geven een iterator terug.
```
function* counter() {
  let i = 0;
  while (true) {
    yield i++;
  }
}
```

Asynchrone functies (Async Functions): Functies die werken met beloftes en await gebruiken om te wachten op de voltooiing ervan.

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

Constructorfuncties (Constructor Functions): Functies die met de new-operator worden gebruikt om objecten te maken. Traditionele aanpak voor OOP vóór de komst van klassen.
```
function Person(name, age) {
  this.name = name;
  this.age = age;
}

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

Callbackfuncties (Callback Functions): Functies die worden doorgegeven als argument aan een andere functie om op een bepaald moment uit te voeren.

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);
});

IIFE (Immediately Invoked Function Expressions): Functies die direct na hun definitie worden uitgevoerd. Worden gebruikt om een lokale scope te creëren.
```
(function() {
  // Lokale code
  const secret = "geheim";
  console.log(secret);
})();
```

Elke functietype heeft zijn eigen syntax, scope (this) en gebruiksscenario's.