Batch-Scripting: Grundstruktur und Variablen

Bisher hast du CMD-Befehle einzeln eingetippt. Aber wenn du dieselbe Sequenz öfter brauchst – z.B. „Backup machen + Logs aufräumen + Dienst neu starten" – wäre es nervig das jedes Mal zu wiederholen. Batch-Skripte lösen das: Du packst die Befehle in eine .bat- oder .cmd-Datei und führst sie als Ganzes aus.

Batch ist eine der ältesten Skriptsprachen die heute noch in Gebrauch ist – ihre Wurzeln reichen bis MS-DOS 1981 zurück. Das bedeutet: extrem stabil und kompatibel, aber auch extrem eigenwillig in der Syntax. Wer aus Bash oder PowerShell kommt, wird Batch befremdlich finden. Aber: in Windows-Umgebungen sind Batch-Skripte allgegenwärtig – Build-Skripte, Install-Routinen, Backup-Jobs. Wer sie nicht lesen kann, ist als FISI eingeschränkt.

1) Mein erstes Batch-Skript

Ein Batch-Skript ist nichts anderes als eine Textdatei mit der Endung .bat oder .cmd (siehe L1). Inhalt: CMD-Befehle, eine pro Zeile. Speichere folgendes als hallo.bat:

@echo off echo Hallo Welt! echo Heute ist %date% pause

Ausführen kannst du es per Doppelklick oder über die CMD:

hallo.bat ausführen

C:\Skripte> hallo.bat Hallo Welt! Heute ist 17.05.2026 Drücken Sie eine beliebige Taste . . .

Drei Zeilen, drei wichtige Konzepte: @echo off schaltet die automatische Ausgabe jedes Befehls aus (sonst würde CMD jeden Befehl vor der Ausführung anzeigen). echo TEXT gibt Text aus. %date% ist eine Variable die das aktuelle Datum enthält. Und pause wartet auf eine Tastatureingabe – praktisch wenn das Skript per Doppelklick gestartet wird, damit das Fenster nicht sofort wieder zugeht.

2) Die @echo off-Konvention

Jede ernsthafte Batch-Datei beginnt mit @echo off. Was passiert ohne? Jeder Befehl würde zweimal angezeigt – einmal als Eingabe-Echo des Interpreters, dann als Ergebnis-Ausgabe. Bei längeren Skripten unübersichtlich. Das @ bedeutet „diesen einzelnen Befehl nicht anzeigen", echo off schaltet es global ab. @echo off kombiniert beides: schaltet global ab, ohne selbst angezeigt zu werden. Konvention seit DOS-Zeiten.

Für Debugging temporär wieder einschalten: echo on. Oder einzelne Befehle vorübergehend mit echo davor sichtbar machen. Ohne @echo off debuggst du übrigens leichter – Anfänger lassen es manchmal weg um zu sehen was passiert.

3) Kommentare und Lesbarkeit

Wie jede Skriptsprache hat Batch Kommentare. REM (von „Remark") oder die abgekürzte Form :: – beides nimmt Batch nicht als Befehl wahr:

@echo off REM Dies ist ein Kommentar mit REM (offiziell) :: Dies ist ein Kommentar mit Doppel-Doppelpunkt (kürzer) REM ======================================== REM backup.bat - Tägliches Backup-Skript REM Autor: Anna Schmidt REM Stand: 17.05.2026 REM ======================================== echo Backup startet...

Technischer Unterschied: REM ist ein echter Befehl, :: ist ein ungültiges Label das CMD einfach ignoriert. Das hat eine kuriose Folge: :: ist in for-Schleifen und Blocks nicht erlaubt, weil es als Label interpretiert wird (Labels in Code-Blöcken sind verboten). Im Zweifel: REM nutzen, das funktioniert immer.

4) Variablen: set und %name%

Variablen in Batch sind Strings, die in der Umgebungs-Tabelle der laufenden CMD-Session leben. Setzen mit set, lesen mit %name%:

@echo off set name=Anna set alter=25 echo Hallo %name% echo Du bist %alter% Jahre alt. REM Variable beim Setzen verwenden set greeting=Hallo %name%! echo %greeting% REM Eine Variable löschen set alter= echo Alter: %alter% REM Output: "Alter: " (leer)

Wichtige Falle: set name = Anna mit Leerzeichen um das Gleichheitszeichen funktioniert NICHT korrekt – die Variable würde dann name (mit Space) heißen und den Wert Anna haben. Immer ohne Spaces um =: set name=Anna. Das ist eine der berüchtigsten Batch-Stolperfallen.

5) Variable-Lifecycle visualisieren

Wenn du verstehen willst wie Variablen sich verhalten, hilft eine schrittweise Visualisierung. Klick Schritt für Schritt durch und beobachte die Variablen-Tabelle:

Variable-Tracer: Werte zur Laufzeit

In Batch werden Variablen zur Parse-Zeit ersetzt – also bevor der Code ausgeführt wird. Das hat Konsequenzen für Schleifen und if-Blöcke, wo du oft die Delayed Expansion mit !var! statt %var% brauchst. Mehr dazu in L7 Schleifen und Bedingungen.

6) Eingabe vom Benutzer: set /p

Wenn das Skript interaktiv etwas vom User abfragen soll: set /p mit Prompt:

@echo off set /p name=Wie heißt du? echo Hallo, %name%! set /p alter=Wie alt bist du? echo %alter% ist ein schönes Alter. REM Default-Wert bei leerer Eingabe set stadt=Berlin set /p stadt=Stadt [%stadt%]: echo Stadt: %stadt%

Bei der letzten Variante (mit vorhandenem Default) wird die Variable nur überschrieben wenn der User etwas eingibt. Drückt er nur Enter, bleibt der Default. Klassisches Pattern für Konfigurations-Skripte. Allerdings: set /p kann keine versteckte Eingabe (für Passwörter) – dafür gibt es keinen nativen Batch-Weg. Wer sowas braucht, nutzt PowerShell mit Read-Host -AsSecureString.

7) Arithmetik mit set /a

Variablen in Batch sind Strings. Aber mit set /a kannst du sie als Zahlen behandeln und rechnen:

@echo off set /a summe=5+3 echo 5+3 = %summe% set /a produkt=7*8 echo 7*8 = %produkt% REM Mit Variablen rechnen - kein % nötig! set /a a=10 set /a b=3 set /a c=a+b*2 echo 10+3*2 = %c% REM 16 REM Inkrement / Dekrement set /a i=0 set /a i+=1 REM i=1 set /a i*=3 REM i=3 REM Modulo (% in Skript! muss verdoppelt werden) set /a rest=17 %% 5 echo 17 mod 5 = %rest% REM 2

Wichtige Eigenheiten von set /a: NUR Ganzzahlen (keine Dezimalzahlen!), Variablen werden ohne % benutzt (im Gegensatz zu set ohne /a), Modulo-Zeichen % muss in Skripten als %% geschrieben werden (weil % sonst als Variablen-Klammer interpretiert würde). Operatoren: + - * / % ** ! – ähnlich C. Größere Berechnungen oder Fließkommazahlen? Dann ist Batch das falsche Werkzeug – nimm PowerShell oder Python.

8) Eingebaute spezielle Variablen

Es gibt einige System-Variablen die immer verfügbar sind. Die wichtigsten:

Spezielle Batch-Variablen

%date%

Aktuelles Datum

17.05.2026

%time%

Aktuelle Uhrzeit

14:32:47,23

%cd%

Aktueller Pfad

C:\Skripte

%username%

Angemeldeter User

anna.schmidt

%computername%

Computer-Name

LAPTOP-ANNA

%userprofile%

Home-Verzeichnis

C:\Users\anna

%appdata%

Roaming-Appdata

C:\Users\anna\AppData\Roaming

%temp%

Temp-Verzeichnis

C:\Users\...\Temp

%path%

Suchpfad für Executables

C:\Windows;...

%errorlevel%

Exit-Code des letzten Befehls (0=OK)

0 oder >0

%random%

Zufallszahl 0-32767

14729

%cmdcmdline%

Wie wurde CMD gestartet?

C:\Windows\...\cmd.exe

Alle aktuellen Variablen sehen mit set ohne Argumente. Eine bestimmte mit echo %name%. Variablen werden zur CMD-Session hinzugefügt und gehen beim Schließen verloren. Permanent setzen via System-Einstellungen oder mit setx. Mehr zu Umgebungsvariablen in L5.

9) String-Manipulation mit Substring-Syntax

Batch hat eine seltsame aber mächtige Syntax für String-Operationen. Mit %var:~START,LENGTH% schneidest du Teile aus:

@echo off set text=Hello World REM Erste 5 Zeichen echo %text:~0,5% REM "Hello" REM Ab Position 6, Rest echo %text:~6% REM "World" REM Letzte 5 Zeichen echo %text:~-5% REM "World" REM Klassiker: Jahr/Monat/Tag aus %date% extrahieren REM Bei %date% = "17.05.2026" set tag=%date:~0,2% set monat=%date:~3,2% set jahr=%date:~6,4% echo Heute: %jahr%-%monat%-%tag% REM 2026-05-17 REM String-Ersetzung: %var:ALT=NEU% set pfad=C:\Users\anna\Documents echo %pfad:\=/% REM C:/Users/anna/Documents

Das Substring-Pattern ist DAS Werkzeug für Datums-Stempel in Backup-Dateinamen: backup-%jahr%%monat%%tag%.zip wird zu backup-20260517.zip. Praktisch sortierbar, eindeutig, läuft täglich automatisch (mehr zur Automatisierung in K44 L9 Task Scheduler).

Aber Vorsicht: die Position der Datums-Teile hängt vom Gebietsschema ab! In Deutschland 17.05.2026, in US-englisch 05/17/2026. Bei portablen Skripten lieber einen WMI-Trick nutzen oder gleich PowerShell.

10) Skript-Argumente: %1, %2, %~dp0

Wenn dein Skript Parameter erwarten soll – z.B. backup.bat C:\Daten D:\Sicherung – greifst du sie über %1, %2, %3, ... ab. Genau wie in Bash mit $1, $2:

@echo off REM backup.bat - erwartet Quelle und Ziel if "%~1"=="" ( echo Verwendung: backup.bat ^ ^ exit /b 1 ) set quelle=%~1 set ziel=%~2 echo Sichere %quelle% nach %ziel% xcopy "%quelle%" "%ziel%" /s /e /y

Die spezielle Form %~1 entfernt eventuelle Anführungszeichen vom Argument. Wenn jemand backup.bat "C:\Mit Leerzeichen" aufruft, ist %1 mit Quotes, %~1 ohne. Faustregel: fast immer %~1 nutzen.

Es gibt noch mehr Modifier:

Modifier	Was es macht	Beispiel-Wert
`%1`	Original-Argument	"C:\Mein Pfad"
`%~1`	Ohne Anführungszeichen	C:\Mein Pfad
`%~d1`	Nur Laufwerk	C:
`%~p1`	Nur Pfad	\Mein Pfad\
`%~n1`	Nur Dateiname (ohne Endung)	file
`%~x1`	Nur Endung	.txt
`%~dp1`	Laufwerk + Pfad (kombiniert)	C:\Mein Pfad\
`%~f1`	Voller absoluter Pfad	C:\Mein Pfad\file.txt
`%~z1`	Dateigröße in Bytes	1245

Besonders wichtig: %~dp0 – das gibt dir den Pfad des Skripts selbst. Damit kannst du Hilfsdateien neben dem Skript referenzieren, egal wo das Skript aufgerufen wird:

@echo off REM Pfad des Skripts selbst echo Skript liegt in: %~dp0 REM Eine Datei daneben laden set configfile=%~dp0config.ini type "%configfile%"

11) Alle Argumente auf einmal: %*

%* ist die Sammlung aller Argumente. Praktisch um sie an einen anderen Befehl weiterzureichen:

@echo off REM logger.bat - reicht alles an Logger-EXE durch REM Aufruf: logger.bat -level ERROR -msg "Etwas ging schief" echo [%date% %time%] logger.exe %* logger.exe %*

Auch nützlich: shift verschiebt die Argument-Liste um eins. Nach shift wird aus dem alten %2 das neue %1. Praktisch für Skripte die beliebig viele Argumente verarbeiten:

@echo off REM Schleife durch alle Argumente :loop if "%~1"=="" goto ende echo Argument: %~1 shift goto loop :ende echo Fertig.

12) Errorlevel: hat der Befehl funktioniert?

Jeder Befehl in Windows setzt nach Ausführung einen Exit-Code in der Variable %errorlevel%. Konvention: 0 = Erfolg, alles andere = irgendein Fehler. Damit kannst du auf Fehler reagieren:

@echo off ping -n 1 server.firma.local >nul if %errorlevel% NEQ 0 ( echo Server nicht erreichbar! exit /b 1 ) echo Server erreichbar. REM Backup machen, Erfolg prüfen xcopy C:\Daten D:\Backup /s /e /y if %errorlevel% EQU 0 ( echo Backup erfolgreich ) else ( echo Backup fehlgeschlagen mit Code %errorlevel% exit /b 2 )

Der eigene Skript-Exit-Code wird mit exit /b N gesetzt. Das ist wichtig wenn andere Skripte dein Skript aufrufen – sie können dann auf den Code reagieren. Mehr zu Bedingungen (if, else) in L7.

13) Umleitung und Pipes

Wie in Bash oder PowerShell kann auch Batch Ausgaben in Dateien umleiten oder zwischen Befehlen verketten:

REM Output in Datei schreiben (überschreibt) dir > liste.txt REM Anhängen echo Heute war ok >> log.txt REM Fehler unterdrücken (stderr nach NUL) del moeglicherweise-nicht-da.txt 2>nul REM stdout UND stderr in eine Datei dir nicht-existent > log.txt 2>&1 REM Pipe: Ausgabe von dir an findstr weiterleiten dir | findstr ".txt" REM Zeilen zählen dir /b | find /c /v "" REM Nul ist Windows' /dev/null ping google.com >nul 2>&1

Wichtige Konstrukte: > überschreibt, >> hängt an, 2> für stderr, 2>&1 verknüpft stderr mit stdout, nul ist das Windows-Pendant zu /dev/null. Mit der Pipe | verkettest du Befehle – find und findstr sind die wichtigsten Filter-Tools.

14) findstr – Filter wie grep

Der Such-Befehl: findstr sucht Text in Dateien oder Pipe-Input. Vergleichbar mit grep in Bash, allerdings deutlich weniger mächtig:

REM In Datei suchen findstr "ERROR" log.txt REM Mehrere Wörter (mit OR) findstr "ERROR WARN" log.txt REM Mit Optionen findstr /i "error" log.txt REM case-insensitive findstr /n "error" log.txt REM mit Zeilennummern findstr /v "DEBUG" log.txt REM invertiert (alles ohne DEBUG) findstr /c:"exact phrase" log.txt REM exakte Phrase findstr /b "^" log.txt REM mit Regex REM Aus Pipe tasklist | findstr "chrome" netstat -an | findstr ":80 "

Wichtige Optionen: /i ignore case, /n mit Zeilennummern, /v invers (was NICHT matcht), /c: für exakte Phrasen mit Leerzeichen, /r für eingeschränkte Regex. Für ernsthaftere Textverarbeitung in einem Skript ist Batch aber wirklich nicht ideal – PowerShell mit Select-String oder Python mit re sind dafür viel besser.

15) Ein realistisches Beispiel-Skript

Zum Abschluss alles zusammen – ein Backup-Skript mit Datums-Stempel, Logging, Fehlerbehandlung:

@echo off REM ============================================ REM backup.bat - Tägliches Daten-Backup REM Aufruf: backup.bat [Quelle] [Ziel] REM ============================================ setlocal REM Argumente prüfen if "%~1"=="" ( echo Verwendung: backup.bat ^ [Ziel] exit /b 1 ) REM Quelle und Ziel setzen set quelle=%~1 set ziel=%~2 if "%ziel%"=="" set ziel=D:\Backup REM Zeitstempel bauen (deutsches Format!) set jahr=%date:~6,4% set monat=%date:~3,2% set tag=%date:~0,2% set ts=%jahr%-%monat%-%tag% REM Backup-Ordner mit Datums-Stempel set zielordner=%ziel%\backup-%ts% set logfile=%ziel%\backup-%ts%.log REM Quelle existiert? if not exist "%quelle%" ( echo [FEHLER] Quelle existiert nicht: %quelle% exit /b 2 ) REM Ziel anlegen if not exist "%ziel%" ( md "%ziel%" ) REM Backup starten echo [%date% %time%] Backup gestartet > "%logfile%" echo Quelle: %quelle% >> "%logfile%" echo Ziel: %zielordner% >> "%logfile%" xcopy "%quelle%" "%zielordner%" /s /e /i /y /h >> "%logfile%" 2>&1 if %errorlevel% EQU 0 ( echo [%date% %time%] Backup erfolgreich >> "%logfile%" echo Backup OK: %zielordner% exit /b 0 ) else ( echo [%date% %time%] Backup FEHLGESCHLAGEN (Code: %errorlevel%) >> "%logfile%" echo Backup fehlgeschlagen, siehe %logfile% exit /b 3 ) endlocal

Das ist ein realistisches Pattern: Argument-Validierung, Zeitstempel-Logik, Logging, Errorlevel-Handling, klare Exit-Codes. setlocal / endlocal begrenzen Variablen-Änderungen auf das Skript (sie werden nicht in die aufrufende CMD-Session „durchsickern"). Auch if not exist ist ein Pattern für Pre-Checks – mehr zu Bedingungen in L7.

Zusammenfassung

Batch-Skripte sind .bat/.cmd-Dateien mit CMD-Befehlen. Beginnen mit @echo off für saubere Ausgabe. Kommentare mit REM oder :: (in Blocks: nur REM!). Variablen: set name=Wert setzen (keine Spaces um =!), %name% lesen. Eingabe: set /p. Rechnen: set /a nur Ganzzahlen. Spezielle Variablen: %date%, %time%, %cd%, %username%, %errorlevel%, %random%. Substring-Syntax: %var:~START,LEN% für Zeichen-Bereiche. Argumente: %1 bis %9, modifier %~1 (ohne Quotes), %~dp1 (Pfad), %~dp0 (Pfad des Skripts), %* (alle), shift für Schleife. Exit-Code: %errorlevel% prüfen, eigener mit exit /b N. Umleitung: >, >>, 2>nul, |. Filter: findstr mit /i, /n, /v. Scoping: setlocal/endlocal. Im Vergleich zu Bash und PowerShell deutlich limitierter – aber überall verfügbar und seit 40 Jahren stabil.