PowerShell scripting voor beginners

Dit stuk leidt je van een lege editor naar een werkend `.ps1`-bestand dat je zonder nadenken kunt uitvoeren. Geen volledige taalcursus, wel de basis waarmee je zelf verder kunt.

Vereisten

Je hebt nodig:

• Windows 10 of 11, of Windows Server 2016 of later voor de ingebouwde Windows PowerShell 5.1. Op Linux en macOS werkt PowerShell 7.x ook, maar de voorbeelden hier zijn Windows-gericht omdat de meeste beheertaken dat zijn.
• PowerShell 7.4 LTS of 7.5. De 7.4 LTS wordt ondersteund tot 10 november 2026 en is de versie die je op productie wilt. 7.5 is verschenen op 23 januari 2025 met ondersteuning tot 12 mei 2026 — prima om mee te leren, minder geschikt voor systemen die jaren zonder onderhoud moeten draaien.
• Basiskennis van een command-line. Je moet weten wat `cd` doet en hoe je een pad opgeeft. Meer niet.
• Een teksteditor. Visual Studio Code met de PowerShell-extensie is de standaard, maar Kladblok werkt ook als je nog niets wilt installeren.

Controleer eerst welke versie je hebt:

```powershell $PSVersionTable.PSVersion ```

Staat daar 5.1 en wil je 7.4? Installeer die dan via `winget`:

```powershell winget install --id Microsoft.PowerShell --source winget ```

Je kunt 5.1 en 7.x naast elkaar hebben. Ze bijten elkaar niet.

Stappen

1. Open de console en leer het verschil met cmd

Start PowerShell. Op Windows 11 heet het gewoon PowerShell in het startmenu; de oudere Windows PowerShell is 5.1.

Het verschil met `cmd.exe` zit niet in de looks maar in wat er onder de motorkap gebeurt. Waar `cmd` platte tekst teruggeeft, geeft PowerShell objecten terug. Dat klinkt academisch tot je iets wilt filteren.

```powershell Get-Process | Where-Object { $_.CPU -gt 10 } ```

In `cmd` zou je die uitvoer moeten parsen met tekstgrepen. Hier niet. Dat is de reden dat je PowerShell leert in plaats van batch-bestanden blijft schrijven.

2. Leer het cmdlet-patroon

Elke ingebouwde opdracht in PowerShell is een cmdlet en volgt het patroon `Werkwoord-ZelfstandigNaamwoord`. `Get-Process`, `Stop-Service`, `New-Item`.

Dat is geen decoratie. Het betekent dat je kunt raden. Wil je iets ophalen? Probeer `Get-`. Wil je iets maken? `New-`. En met `Get-Command` zoek je wat er bestaat:

```powershell Get-Command -Verb Get -Noun Service ```

De prijs voor die consistentie is dat commando's langer zijn dan hun Unix-equivalenten. `ls` wordt `Get-ChildItem`, en dat typ je niet even snel. Daar staat tegenover dat je nooit meer hoeft te zoeken of het nu `-r`, `-R` of `--recursive` was.

3. Maak je eerste script

Een script is niets meer dan een tekstbestand met de extensie `.ps1`. Maak `Hallo.ps1` aan en zet er dit in:

```powershell Write-Host "Hallo, dit is mijn eerste script." Get-ComputerInfo -Property "OsName", "OsArchitecture", "WindowsVersion" ```

`Write-Host` schrijft direct naar het scherm. `Get-ComputerInfo` haalt systeeminformatie op en geeft een object terug dat PowerShell netjes voor je uitprint.

Sla het op in een map die je terugvindt, bijvoorbeeld `C:\Scripts\Hallo.ps1`.

4. Zet het execution policy goed

Dit is de stap waar beginners struikelen. Standaard staat het execution policy op `Restricted`, en dan weigert PowerShell je script.

Controleer het:

```powershell Get-ExecutionPolicy ```

Staat er `Restricted`, dan krijg je bij het uitvoeren een foutmelding die je niet meteen begrijpt. Zet het beleid op `RemoteSigned`:

```powershell Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser ```

`RemoteSigned` betekent: lokale scripts mogen draaien, gedownloade scripts moeten ondertekend zijn. Dat is de juiste balans. `Unrestricted` laat alles toe en dat wil je niet — een `.ps1` uit een e-mailbijlage is net zo gevaarlijk als een `.exe`.

De `-Scope CurrentUser` zorgt dat je geen administrator-rechten nodig hebt en alleen je eigen account raakt. Andere gebruikers op de machine merken er niets van.

5. Voer het script uit

Navigeer naar de map en start het script:

```powershell cd C:\Scripts .\Hallo.ps1 ```

Die `.\` is geen typfout. PowerShell voert standaard geen bestanden uit het huidige map uit, om te voorkomen dat je per ongeluk `Hallo.ps1` uitvoert terwijl je `hallo` bedoelde en er ergens een kwaadaardig bestand met die naam staat. Je moet expliciet zeggen: dit bestand, hier.

6. Werk met variabelen en logica

Een script dat altijd hetzelfde doet is een veredelde sneltoets. Variabelen maken het bruikbaar.

```powershell $serviceNaam = "Spooler" $service = Get-Service -Name $serviceNaam

if ($service.Status -eq "Stopped") { Write-Host "Service $serviceNaam stond stil, start nu." Start-Service -Name $serviceNaam } else { Write-Host "Service $serviceNaam draait al." } ```

Variabelen beginnen met `$`. Vergelijken doe je met `-eq`, `-ne`, `-gt`, `-lt` in plaats van `==`, `!=`, `>`, `<`. Dat is even wennen, maar het voorkomt dat PowerShell `>` aanziet voor een vergelijking terwijl jij bedoelde dat de uitvoer naar een bestand moest.

7. Herhaal met een lus

Voor taken die je over meerdere objecten uitvoert, gebruik je `foreach`. Stel je wilt alle gestopte services zien:

```powershell $services = Get-Service | Where-Object { $_.Status -eq "Stopped" }

foreach ($s in $services) { Write-Host "Gestopt: $($s.DisplayName)" } ```

Die `$($s.DisplayName)` ziet er vreemd uit. Het is subexpression syntax: binnen een string met dubbele quotes kun je zo een eigenschap van een object invoegen. Zonder de `$()` krijg je de letterlijke tekst `$s.DisplayName` te zien. Dat is een klassieke beginnersfout.

8. Zet het in een functie en hergebruik

Een script dat je vaker draait, wil je parameteriseren. Dan hoef je niet elke keer het bestand open te maken.

```powershell param( [Parameter(Mandatory = $true)] [string]$ServiceNaam )

$service = Get-Service -Name $ServiceNaam -ErrorAction SilentlyContinue

if (-not $service) { Write-Error "Service $ServiceNaam niet gevonden." exit 1 }

if ($service.Status -eq "Stopped") { Start-Service -Name $ServiceNaam Write-Host "Service $ServiceNaam gestart." } else { Write-Host "Service $ServiceNaam draaide al." } ```

Sla dit op als `Start-ServiceAlsGestopt.ps1`. De `Mandatory = $true` zorgt dat PowerShell om de parameter vraagt als je hem vergeet. De `-ErrorAction SilentlyContinue` onderdrukt de foutmelding die `Get-Service` anders geeft bij een niet-bestaande service — je vangt die zelf af met een nette melding.

Aanroepen gaat zo:

```powershell .\Start-ServiceAlsGestopt.ps1 -ServiceNaam Spooler ```

Verificatie

Draai het script tegen een service die je kent. Stop eerst de Print Spooler handmatig via `services.msc`, of gebruik een testservice die je veilig kunt starten en stoppen.

```powershell .\Start-ServiceAlsGestopt.ps1 -ServiceNaam Spooler Get-Service -Name Spooler | Select-Object Name, Status ```

De tweede regel moet `Running` tonen. Draai het script nog een keer — nu hoort de melding "draaide al" te komen en gebeurt er niets. Dat is precies wat je wilt: idempotent gedrag, het script doet niets als er niets te doen is.

Wil je weten welke versie je gebruikt hebt tijdens het testen:

```powershell $PSVersionTable ```

Noteer die. Als je later een foutmelding krijgt die je niet thuis kunt brengen, is de versie het eerste waar iemand naar vraagt.

Veelgestelde problemen

"cannot be loaded because running scripts is disabled on this system" — Je execution policy staat nog op `Restricted`. Zie stap 4. Draai `Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser` en probeer opnieuw. Het is geen fout in je script.

"The term 'Hallo.ps1' is not recognized" — Je vergat `.\` voor de bestandsnaam. PowerShell zoekt niet standaard in de huidige map, alleen in `$env:PATH`. Typ `.\Hallo.ps1`.

"Cannot bind argument to parameter 'Name' because it is null" — Je variabele heeft geen waarde gekregen, meestal omdat je hem verkeerd gespeld hebt of omdat de vorige regel niets teruggaf. Voeg `Write-Host $ServiceNaam` toe vlak voor de regel die klaagt. Negen van de tien keer zie je dan meteen wat er mis is.

Waar je verder gaat

De officiële documentatie staat op Microsoft Learn, inclusief de module Inleiding tot scripting in PowerShell. Die is in het Nederlands beschikbaar en dekt dezelfde basis als hierboven, met meer oefeningen.

Het echte werk begint wanneer je een taak hebt die je drie keer per week handmatig doet. Dan schrijf je het script niet omdat het moet, maar omdat je het beu bent. Dat is het moment waarop PowerShell blijft hangen.

Er is ook een eerlijke kanttekening: voor eenmalige commando's is de console sneller dan een script. Niet alles hoeft geautomatiseerd. Een script dat je één keer draait, is een script dat je één keer hebt getest.