Functies

Functies zijn een kernonderdeel van JavaScript en vormen de bouwstenen van elk programma. Een functie is een blok code dat kan worden hergebruikt om een specifieke taak uit te voeren. Functies maken het mogelijk om je code efficiënter, leesbaarder en herbruikbaarder te maken door herhaling te verminderen en logica te structureren.

Hoe functies definiëren?

In JavaScript kunnen functies op verschillende manieren worden gedefinieerd:

Functie-declaratie

Functiedeclaratie is de meest gebruikelijke manier om een functie te definiëren.

function begroet(naam) {
  console.log(`Hallo, ${naam}!`);
}
begroet("Jan"); // Output: Hallo, Jan!

Functie-uitdrukking

Een functie kan worden opgeslagen in een variabele.

const vermenigvuldig = function (a, b) {
  return a * b;
};
console.log(vermenigvuldig(3, 4)); // Output: 12

Arrow functions

Een compacte manier om functies te schrijven.

const optellen = (a, b) => a + b;
console.log(optellen(5, 7)); // Output: 12

Functies en Parameters

Functies kunnen parameters accepteren en een waarde teruggeven met return:

function berekenSom(a, b) {
  return a + b;
}
const resultaat = berekenSom(10, 20);
console.log(resultaat); // Output: 30

Functies kunnen ook standaardwaarden hebben voor parameters:

function begroet(naam = "gast") {
  console.log(`Hallo, ${naam}!`);
}
begroet(); // Output: Hallo, gast!

Verschillen met C

Hoewel functies in JavaScript en methoden in C# vergelijkbare doelen dienen, zijn er enkele opvallende verschillen:

Dynamische versus statische typen

In JavaScript is het niet nodig om de datatypes van parameters of returnwaarden op te geven, omdat het een dynamisch getypeerde taal is. In C# moet je altijd expliciet de types specificeren.

function vermenigvuldig(a, b) {
  return a * b;
}
// Geen type nodig in JavaScript

// In C#:
int Vermenigvuldig(int a, int b) {
    return a * b;
}

Hoisting

• Functies in JavaScript die zijn gedefinieerd met een functieverklaring worden "gehoist", wat betekent dat ze overal in hun scope kunnen worden aangeroepen, zelfs voordat ze zijn gedefinieerd. In C# moet een methode worden gedeclareerd voordat deze wordt aangeroepen.

console.log(optellen(3, 4)); // Output: 7
function optellen(a, b) {
  return a + b;
}

// In C# zou dit een fout veroorzaken:
Console.WriteLine(Optellen(3, 4)); // Fout: Methode is niet gedefinieerd
int Optellen(int a, int b) {
    return a + b;
}

Anonimiteit en flexibiliteit

• JavaScript-functies kunnen anoniem zijn en als waarden worden doorgegeven aan andere functies (first-class functies). In C# kan dit worden bereikt met delegates of lambda-expressies, maar de syntax is minder flexibel.

const uitvoer = (callback) => callback('Wereld');
uitvoer(naam => console.log(`Hallo, ${naam}!`)); // Output: Hallo, Wereld!

// In C#:
void Uitvoer(Action<string> callback) {
    callback("Wereld");
}
Uitvoer(naam => Console.WriteLine($"Hallo, {naam}!"));

Asynchronie

• JavaScript ondersteunt asynchrone functies en promisses om niet-blokkerende code te schrijven. C# heeft vergelijkbare functionaliteit met async en await, maar asynchronie is ingebakken in JavaScript vanwege de noodzaak voor niet-blokkerende browseroperaties.

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

// In C#:
async Task FetchData() {
    var response = await httpClient.GetStringAsync("https://api.example.com/data");
    Console.WriteLine(response);
}

Functies in JavaScript bieden een grote mate van flexibiliteit en worden op veel verschillende manieren toegepast. Door de verschillen tussen JavaScript en C# te begrijpen, kun je hun sterke punten optimaal benutten.