Variabelen

Inleiding

Variabelen zijn een van de fundamentele bouwstenen in JavaScript en zijn essentieel om gegevens in je programma op te slaan en te manipuleren. Een variabele werkt als een container waarin je informatie kunt bewaren, zoals getallen, tekst of andere gegevens. Met variabelen kun je je code flexibeler en dynamischer maken.

Declaratie van variabelen

In JavaScript kun je variabelen declareren met de sleutelwoorden var, let en const. Elk van deze heeft een specifieke rol en gebruikscontext:

• var: Wordt gebruikt om variabelen te declareren in oudere JavaScript-versies. Het heeft een functionele scope, wat betekent dat het alleen binnen de functie waarin het is gedeclareerd beschikbaar is. In moderne code wordt var vaak vermeden.

• let: Wordt gebruikt om variabelen te declareren met een blokscope. Dit betekent dat de variabele alleen beschikbaar is binnen het blok waarin deze is gedefinieerd, zoals binnen een lus of een functie. let biedt meer controle en is veiliger in gebruik dan var.

• const: Wordt gebruikt om constante variabelen te declareren, waarvan de waarde niet kan worden herassigned. Het heeft ook een blokscope en wordt vaak gebruikt voor waarden die niet mogen veranderen.

Enkele voorbeelden

let leeftijd = 25; // Variabele met een veranderlijke waarde
const naam = "Jan"; // Constante waarde

console.log(naam); // Output: Jan
console.log(leeftijd); // Output: 25

leeftijd = 26; // Bijwerken van de waarde van leeftijd
console.log(leeftijd); // Output: 26

// const naam = "Piet"; // Dit zal een fout veroorzaken omdat const niet kan worden geüpdatet

Variabelen maken het ook mogelijk om berekeningen uit te voeren en gegevens te combineren:

let a = 10;
let b = 20;
let som = a + b; // Resultaat is 30
console.log(`De som van ${a} en ${b} is ${som}`); // Output: De som van 10 en 20 is 30

Hoe verschillen variabelen in JavaScript van variabelen in C#?

Hoewel variabelen in zowel JavaScript als C# bedoeld zijn om gegevens op te slaan, zijn er enkele belangrijke verschillen:

Dynamisch versus statisch typen

• JavaScript is een dynamisch getypeerde taal, wat betekent dat de datatypes van variabelen automatisch worden bepaald tijdens runtime. In C# is typen statisch, wat betekent dat je expliciet moet aangeven welk type gegevens een variabele opslaat (bijv. int, string).

let x = 42; // Dynamisch type in JavaScript
x = "Hallo"; // Geldig: het type kan veranderen

// In C#:
int x = 42; // Statisch type
x = "Hallo"; // Ongeldig: type mismatch

Scope en gebruik

In JavaScript is de scope van een variabele afhankelijk van de declaratie met var, let of const. var heeft functionele scope, terwijl let en const blokscope hebben. In C# hebben variabelen meestal blokscope en moeten ze binnen een methode of klasse worden gedeclareerd.

{
    let y = 10; // Blokscope in JavaScript
}
console.log(y); // Fout: y bestaat niet buiten het blok

// In C#:
{
    int y = 10; // Blokscope in C#
}
Console.WriteLine(y); // Fout: y bestaat niet buiten het blok

Constanten

In JavaScript gebruik je const om een constante te declareren. In C# gebruik je const of readonly, afhankelijk van of de waarde op compile-time of runtime wordt ingesteld.

const PI = 3.14; // JavaScript constante

// In C#:
const double PI = 3.14; // Constante waarde op compile-time
readonly double radius; // Runtime constante (bijv. ingesteld in een constructor)

Typebeperkingen

In C# worden variabelen strikt gecontroleerd op type, wat betekent dat je fouten bij het toewijzen van een verkeerd type direct detecteert. JavaScript biedt meer flexibiliteit, maar dat kan leiden tot bugs door onbedoelde typewisselingen.