PowerShell 7 Grundkurs 002: Ordner automatisch erstellen

Worum geht es in diesem Teil?

In diesem zweiten Teil des PowerShell-7-Grundkurses erstellen wir automatisch mehrere Ordner.

Dafür verwenden wir diesmal nicht mehrere einzelne Befehle, sondern eine Liste mit Ordnernamen und eine foreach-Schleife.

Zusätzlich gibt es in diesem Teil zwei Varianten:

01_Einfach
02_SendTo_Projektordner_erstellen

Die erste Variante erstellt eine feste Ordnerstruktur im aktuellen Ordner.

Die zweite Variante ist eine SendTo-Version. Damit kann ein Ordner über den Windows-Explorer an das Skript übergeben werden. Das Skript erstellt die Projektordner dann direkt in diesem ausgewählten Zielordner.

Was ist das Ziel?

Das Skript soll mehrere Standardordner erstellen, ohne dass jeder Ordner einzeln von Hand angelegt werden muss.

Statt acht Ordner im Explorer anzulegen, schreiben wir die Ordnernamen in eine Liste. Danach geht PowerShell diese Liste automatisch durch und erstellt jeden Ordner, der noch nicht vorhanden ist.

Das Prinzip ist:

Ordnerliste vorbereiten
jeden Eintrag der Liste durchgehen
prüfen, ob der Ordner schon existiert
fehlende Ordner erstellen

In der einfachen Variante passiert das im aktuellen Ordner.

In der SendTo-Variante wird zusätzlich ein Zielordner übergeben. Dadurch kann man die Ordnerstruktur sehr bequem in einem ausgewählten Projektordner erstellen lassen.

Welche Ordner werden erstellt?

In diesem Beispiel wird folgende Ordnerstruktur erstellt:

01_Rohmaterial
02_Audio
03_Projektdateien
04_Grafiken
05_Export
06_Thumbnail
07_Backup
08_UmlauttestäöüßÄÖÜ

Der letzte Ordner ist zusätzlich ein kleiner Umlauttest. Damit kann man prüfen, ob Umlaute und Sonderzeichen korrekt gespeichert und angezeigt werden.

Powershell Grundkurs 002_Ordner_erstellen

Warum ist die Listen-Variante sinnvoll?

Man könnte jeden Ordner einzeln prüfen und erstellen.

Zum Beispiel:

if (-not (Test-Path "01_Rohmaterial")) {
    New-Item -ItemType Directory -Name "01_Rohmaterial" | Out-Null
}

Das funktioniert, wird aber schnell unübersichtlich, wenn viele Ordner erstellt werden sollen.

Mit einer Liste und einer Schleife wird das Skript deutlich besser wartbar.

Wenn später ein neuer Ordner dazukommen soll, muss nur ein neuer Eintrag in die Liste geschrieben werden.

Zum Beispiel:

"09_Notizen"

Die Schleife verarbeitet diesen Eintrag dann automatisch mit.

Hinweis zur Kursreihe

Diese PowerShell-7-Reihe ist Teil einer größeren Windows-Automatisierungsreihe. Viele Aufgaben werden in mehreren Sprachen umgesetzt, damit man die unterschiedlichen Lösungswege vergleichen kann.

Geplant sind Varianten mit:

Batch
PowerShell 7
Python

Die Aufgabe aus diesem Teil gibt es also auch als Batch-Version und später als Python-Version.

Dadurch kann man sehr gut vergleichen:

Wie löst Batch die Aufgabe?
Wie löst PowerShell 7 die Aufgabe?
Wie löst Python die Aufgabe?

Downloads zu diesem Teil

Für diesen Teil gibt es zwei Varianten mit PowerShell-Dateien und Starter-Batchdateien.

C:\TOPTORIALS_CODE\010_PowerShell_7_Grundkurs

C:\TOPTORIALS_CODE\010_PowerShell_7_Grundkurs\002_Ordner_erstellen

01_Einfach
02_SendTo_Projektordner_erstellen

Testumgebung zum Mitmachen

Für diese Tutorialreihe gibt es zusätzlich eine vorbereitete Testumgebung. Für diesen Teil ist sie sehr praktisch, weil hier Ordner erstellt werden.

Die Testumgebung enthält vorbereitete Ordner und Beispieldateien für die späteren Teile des PowerShell-7-Grundkurses. Dadurch kannst du die Skripte gefahrlos ausprobieren, ohne eigene wichtige Dateien verwenden zu müssen.

Die Testumgebung ist sprachübergreifend aufgebaut. Das bedeutet: Die gleiche Grundstruktur kann auch für die passenden Batch– und Python-Versionen verwendet werden. Für den PowerShell-7-Grundkurs arbeiten wir mit einer eigenen Kopie des Testdatenordners.

C:\TOPTORIALS_CODE\1000_TESTBEREICH

C:\TOPTORIALS_CODE\1000_TESTBEREICH\TOPTORIALS_Testdaten_Windows_Automatisierung_V001

TOPTORIALS_Testdaten_Windows_Automatisierung_PowerShell_7_V001

Danach sieht der Pfad zum Testdatenordner für den PowerShell-7-Grundkurs zum Beispiel so aus:

C:\TOPTORIALS_CODE\1000_TESTBEREICH\TOPTORIALS_Testdaten_Windows_Automatisierung_PowerShell_7_V001

Für diesen Teil kann das Skript in einem eigenen Testordner ausgeführt werden. Dadurch sieht man sofort, welche Ordner automatisch erstellt wurden.

Sicherheitshinweis

Enthaltene Dateien

Zu diesem Teil gehören zwei Varianten.

Variante 1: Einfach

01_Einfach
├── 002_ordner_erstellen.ps1
└── 002_ordner_erstellen_starter_batch.bat

Variante 2: SendTo-Projektordner erstellen

02_SendTo_Projektordner_erstellen
├── 002_sendto_projektordner_erstellen.ps1
└── 002_sendto_projektordner_erstellen_starter_batch.bat

Variante 1: Einfache Ordnerstruktur erstellen

Die einfache Variante erstellt die Ordner im aktuellen Ordner.

Diese Variante eignet sich gut für den Einstieg, weil man hier zuerst die Grundidee versteht:

Liste erstellen
Liste mit foreach durchgehen
prüfen, ob ein Ordner existiert
fehlende Ordner erstellen

Der komplette Code der einfachen PowerShell-Datei

Die Datei heißt:

002_ordner_erstellen.ps1

# ============================================================
# TOPTORIALS OFFICE - PowerShell 7 Grundkurs
# Script: 002_ordner_erstellen.ps1
# Beschreibung: Erstellt eine feste Standardordnerstruktur im aktuellen Ordner.
# Autor: Chris
# YouTube: https://www.youtube.com/@TOPTORIALS-OFFICE
# Webseite: https://www.toptorials.com
# Version: 1.0
# Stand: 2026-07-21
#
# ============================================================

Write-Host ""
Write-Host "Standardordner werden erstellt..."
Write-Host ""

$ordnerListe = @(
    "01_Rohmaterial"
    "02_Audio"
    "03_Projektdateien"
    "04_Grafiken"
    "05_Export"
    "06_Thumbnail"
    "07_Backup"
    "08_UmlauttestäöüßÄÖÜ"
)

foreach ($ordner in $ordnerListe) {
    if (-not (Test-Path $ordner)) {
        New-Item -ItemType Directory -Name $ordner | Out-Null
    }
}

Write-Host ""
Write-Host "Fertig."
Write-Host ""

Read-Host "Drücke Enter zum Beenden"

Code der einfachen PowerShell-Datei erklärt

Kommentarblock

In PowerShell beginnen Kommentare mit einer Raute:

#

Der obere Bereich ist ein Kommentarblock. Er wird nicht ausgeführt, sondern enthält Informationen zum Skript.

Zum Beispiel:

# TOPTORIALS OFFICE - PowerShell 7 Grundkurs
# Script: 002_ordner_erstellen.ps1
# Beschreibung: Erstellt eine feste Standardordnerstruktur im aktuellen Ordner.

Solche Informationen sind sehr hilfreich, wenn man später viele Skripte gesammelt hat und schnell erkennen möchte, wofür eine Datei gedacht ist.

Text ausgeben mit Write-Host

Mit Write-Host geben wir Text im PowerShell-Fenster aus.

Beispiel:

Write-Host "Standardordner werden erstellt..."

Leere Zeilen geben wir in diesem Skript so aus:

Write-Host ""

Dadurch wird die Ausgabe im Fenster besser lesbar.

PowerShell kann Zeilenumbrüche auch innerhalb eines Textes mit `n schreiben. Für diesen Grundkurs verwenden wir aber bewusst eigene Write-Host-Zeilen, weil das am Anfang leichter zu erkennen ist.

Die Ordnerliste

Der wichtigste neue Teil beginnt mit:

$ordnerListe = @(

Damit erstellen wir eine Liste, genauer gesagt ein Array.

In dieser Liste stehen die Ordnernamen:

$ordnerListe = @(
    "01_Rohmaterial"
    "02_Audio"
    "03_Projektdateien"
    "04_Grafiken"
    "05_Export"
    "06_Thumbnail"
    "07_Backup"
    "08_UmlauttestäöüßÄÖÜ"
)

Die Variable heißt:

$ordnerListe

Das Dollarzeichen zeigt in PowerShell an, dass es sich um eine Variable handelt.

Die Schreibweise:

@(
    ...
)

erstellt eine Liste mit mehreren Einträgen.

Jeder Ordnername steht hier in einer eigenen Zeile. Dadurch ist die Liste sehr gut lesbar und kann leicht erweitert werden.

Wenn später ein weiterer Ordner hinzukommen soll, kann man einfach eine neue Zeile ergänzen:

"09_Notizen"

Einträge in einer Zeile oder untereinander?

In PowerShell kann man eine Liste auch in einer Zeile schreiben. Dann müssen die Einträge aber mit Kommas getrennt werden:

$ordnerListe = @("01_Rohmaterial", "02_Audio", "03_Projektdateien")

Wenn die Einträge untereinander stehen, ist die Schreibweise ohne Kommas sehr gut lesbar:

$ordnerListe = @(
    "01_Rohmaterial"
    "02_Audio"
    "03_Projektdateien"
)

Merksatz:

Mehrere Einträge in einer Zeile brauchen Kommas.
Mehrere Einträge untereinander brauchen in PowerShell keine Kommas.

Einzelne Einträge aus der Liste lesen

PowerShell zählt bei Listen wie viele andere Programmiersprachen ab 0.

Der erste Eintrag wäre also:

$ordnerListe[0]

Der zweite Eintrag wäre:

$ordnerListe[1]

Der letzte Eintrag kann auch mit -1 gelesen werden:

$ordnerListe[-1]

Für dieses Skript brauchen wir das nicht direkt, aber es hilft beim Verständnis von Listen.

Die foreach-Schleife

Jetzt kommt die Schleife:

foreach ($ordner in $ordnerListe) {
    if (-not (Test-Path $ordner)) {
        New-Item -ItemType Directory -Name $ordner | Out-Null
    }
}

Die erste Zeile lautet:

foreach ($ordner in $ordnerListe) {

Das kann man fast wie einen deutschen Satz lesen:

Für jeden Ordner in der OrdnerListe ...

PowerShell geht also jeden Eintrag aus der Liste einzeln durch.

Beim ersten Durchlauf enthält $ordner diesen Wert:

01_Rohmaterial

Beim zweiten Durchlauf enthält $ordner diesen Wert:

02_Audio

Beim dritten Durchlauf:

03_Projektdateien

Und so weiter.

Die Variable $ordner enthält also immer nur den aktuellen Eintrag aus der Liste.

Prüfen, ob ein Ordner existiert

Innerhalb der Schleife steht:

if (-not (Test-Path $ordner)) {

Diese Zeile prüft, ob der aktuelle Ordner noch nicht existiert.

Dafür ist zuerst dieser Teil wichtig:

Test-Path $ordner

Test-Path prüft, ob ein Pfad existiert.

Wenn der Pfad existiert, gibt PowerShell zurück:

True

Wenn der Pfad nicht existiert, gibt PowerShell zurück:

False

Beispiel:

Test-Path "01_Rohmaterial"

Wenn der Ordner vorhanden ist, ist das Ergebnis True.

Wenn der Ordner nicht vorhanden ist, ist das Ergebnis False.

Was bedeutet -not?

Der Operator:

-not

bedeutet:

nicht

Er kehrt ein Ergebnis um.

Aus True wird False.

Aus False wird True.

Diese Zeile:

if (-not (Test-Path $ordner)) {

bedeutet also:

Wenn der Pfad aus $ordner nicht existiert, dann ...

Oder einfacher gesagt:

Wenn dieser Ordner noch nicht vorhanden ist, dann erstelle ihn.

Warum steht ein Minus vor not?

In PowerShell beginnen viele Operatoren mit einem Minuszeichen.

Zum Beispiel:

-not
-eq
-ne
-gt
-lt
-and
-or

Das Minus gehört fest zum Operator dazu.

Deshalb schreibt man in PowerShell:

-not

und nicht einfach:

not

Den Ordner erstellen mit New-Item

Wenn der Ordner noch nicht existiert, wird diese Zeile ausgeführt:

New-Item -ItemType Directory -Name $ordner | Out-Null

Diese Zeile erstellt den Ordner.

Die Bestandteile sind:

New-Item
-ItemType Directory
-Name $ordner
| Out-Null

Was bedeutet New-Item?

New-Item bedeutet:

Erstelle ein neues Element.

PowerShell verwendet hier einen allgemeinen Befehl, der nicht nur Ordner erstellen kann.

New-Item kann je nach Parameter zum Beispiel Dateien oder Ordner erstellen.

Deshalb müssen wir genauer angeben, was erstellt werden soll.

Was bedeutet -ItemType Directory?

-ItemType Directory

bedeutet:

Das neue Element soll ein Ordner sein.

-ItemType ist ein Parameter.

Directory ist der Wert für diesen Parameter.

Was bedeutet -Name $ordner?

-Name $ordner

bedeutet:

Der Name des neuen Ordners kommt aus der Variable $ordner.

Wenn $ordner gerade diesen Wert enthält:

01_Rohmaterial

dann wird dieser Ordner erstellt.

Beim nächsten Durchlauf enthält $ordner dann:

02_Audio

Dann wird dieser Ordner erstellt.

Was sind Parameter?

In PowerShell heißen Angaben wie -ItemType oder -Name Parameter.

Ein Parameter beginnt meistens mit einem Minuszeichen und steuert genauer, wie ein Befehl ausgeführt wird.

Beispiel:

New-Item -ItemType Directory -Name "Test"

Bedeutung:

New-Item        = Erstelle etwas Neues
-ItemType       = Welche Art?
Directory       = Einen Ordner
-Name           = Mit welchem Namen?
"Test"          = Name des Ordners

Wichtig ist der Unterschied zwischen Parametern und Operatoren.

Parameter gehören zu einem Befehl:

-ItemType
-Name
-Path
-Recurse

Operatoren vergleichen, verknüpfen oder verändern Ausdrücke:

-not
-eq
-ne
-gt
-lt

Beide beginnen in PowerShell oft mit einem Minuszeichen, haben aber unterschiedliche Aufgaben.

Was macht | Out-Null?

Normalerweise gibt New-Item nach dem Erstellen eines Ordners eine Rückmeldung aus.

Diese Rückmeldung kann ungefähr so aussehen:

Directory: C:\TOPTORIALS_CODE\...

Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
d-----        ...                         01_Rohmaterial

Das ist technisch nützlich, aber für dieses einfache Tutorial wäre die Ausgabe unnötig lang.

Mit:

| Out-Null

unterdrücken wir diese normale Rückgabe.

Das bedeutet:

Der Ordner wird erstellt, aber die automatische Rückmeldung wird nicht angezeigt.

Dadurch bleibt die Konsolenausgabe sauber.

Alternative Kurzform mit mkdir

PowerShell kennt auch kürzere Schreibweisen.

Zum Beispiel:

mkdir $ordner | Out-Null

Das funktioniert häufig ebenfalls.

Für diesen Grundkurs verwenden wir aber bewusst:

New-Item -ItemType Directory -Name $ordner | Out-Null

Diese Variante ist länger, aber besser lesbar und erklärt deutlicher, was PowerShell genau macht.

Starter-Batchdatei der einfachen Variante

Die Datei heißt:

002_ordner_erstellen_starter_batch.bat

@echo off
REM ============================================================
REM TOPTORIALS OFFICE - PowerShell 7 Grundkurs
REM Script: 002_ordner_erstellen_starter_batch.bat
REM Beschreibung: Startet das PowerShell-7-Skript 002_ordner_erstellen.ps1.
REM Autor: Chris
REM YouTube: https://www.youtube.com/@TOPTORIALS-OFFICE
REM Webseite: https://www.toptorials.com
REM Version: 1.0
REM Stand: 2026-07-21
REM
REM ============================================================

pwsh -ExecutionPolicy Bypass -File "%~dp0\002_ordner_erstellen.ps1"

Variante 2: Projektordner über SendTo erstellen

Die zweite Variante ist praktischer, wenn die Ordnerstruktur nicht im Skriptordner erstellt werden soll, sondern in einem ausgewählten Zielordner.

Die Idee ist:

Im Explorer einen Ordner auswählen
Rechtsklick auf den Ordner
Senden an
Starter-Batchdatei auswählen
PowerShell erstellt die Projektordner in diesem Zielordner

Dadurch wird die Variante flexibler.

Die einfache Variante erstellt Ordner im aktuellen Ordner.

Die SendTo-Variante erstellt Ordner in einem übergebenen Ordner.

Der komplette Code der SendTo-PowerShell-Datei

Die Datei heißt:

002_sendto_projektordner_erstellen.ps1

# ============================================================
# TOPTORIALS OFFICE - PowerShell 7 Grundkurs
# Script: 002_sendto_projektordner_erstellen.ps1
# Beschreibung: Erstellt eine Creator-Ordnerstruktur in einem übergebenen Ordner.
# Autor: Chris
# YouTube: https://www.youtube.com/@TOPTORIALS-OFFICE
# Webseite: https://www.toptorials.com
# Version: 1.0
# Stand: 2026-07-21
#
# ============================================================

param (
    [string]$Zielordner
)

Write-Host ""

if ([string]::IsNullOrWhiteSpace($Zielordner)) {
    Write-Host "Bitte übergib einen Ordner."
    Write-Host ""
    Write-Host "Du kannst zum Beispiel einen Ordner auf die Starter-Batchdatei ziehen"
    Write-Host "oder Rechtsklick - Senden an verwenden."
    Write-Host ""
    Read-Host "Drücke Enter zum Beenden"
    exit
}

if (-not (Test-Path -Path $Zielordner -PathType Container)) {
    Write-Host "Der übergebene Pfad ist kein Ordner:"
    Write-Host $Zielordner
    Write-Host ""
    Read-Host "Drücke Enter zum Beenden"
    exit
}

Write-Host "Creator-Ordnerstruktur wird erstellt in:"
Write-Host $Zielordner
Write-Host ""

$ordnerListe = @(
    "01_Rohmaterial"
    "02_Audio"
    "03_Projektdateien"
    "04_Grafiken"
    "05_Export"
    "06_Thumbnail"
    "07_Backup"
    "08_UmlauttestäöüßÄÖÜ"
)

foreach ($ordner in $ordnerListe) {
    $ordnerPfad = Join-Path -Path $Zielordner -ChildPath $ordner

    if (-not (Test-Path -Path $ordnerPfad -PathType Container)) {
        New-Item -ItemType Directory -Path $ordnerPfad | Out-Null
    }
}

Write-Host ""
Write-Host "Fertig."
Write-Host ""

Read-Host "Drücke Enter zum Beenden"

Code der SendTo-PowerShell-Datei erklärt

Parameter mit param entgegennehmen

Direkt nach dem Kommentarblock steht:

param (
    [string]$Zielordner
)

Damit kann das PowerShell-Skript einen Wert entgegennehmen, der beim Start übergeben wird.

In diesem Fall ist das der Zielordner.

[string] bedeutet, dass dieser Wert als Text behandelt wird.

$Zielordner ist die Variable, in der dieser übergebene Pfad gespeichert wird.

Wenn also ein Ordner über die Starter-Batchdatei an das PowerShell-Skript übergeben wird, landet dieser Pfad in:

$Zielordner

Prüfen, ob ein Zielordner übergeben wurde

Danach folgt diese Prüfung:

if ([string]::IsNullOrWhiteSpace($Zielordner)) {

Diese Zeile prüft, ob überhaupt ein brauchbarer Zielordner übergeben wurde.

[string] steht für den Datentyp Text.

::IsNullOrWhiteSpace ist eine eingebaute statische Methode der String-Klasse.

Man kann die Zeile so lesen:

Prüfe, ob $Zielordner leer ist, keinen Wert hat oder nur aus Leerzeichen besteht.

Diese Prüfung erkennt also zum Beispiel:

gar keinen Wert
leeren Text
nur Leerzeichen

Wenn das der Fall ist, wurde kein brauchbarer Zielordner übergeben.

Dann zeigt das Skript eine Meldung an:

Bitte übergib einen Ordner.

Danach wartet das Skript auf Enter und beendet sich mit:

exit

Warum steht hier [string] vorne?

PowerShell kann viele Funktionen aus .NET direkt verwenden.

Die Schreibweise:

[string]::IsNullOrWhiteSpace($Zielordner)

bedeutet, dass eine statische Methode der String-Klasse verwendet wird.

Das Muster ist:

[Klasse]::Methode(Wert)

Für dieses Skript muss man das nicht im Detail beherrschen. Wichtig ist nur:

[string]::IsNullOrWhiteSpace($Zielordner)
prüft, ob $Zielordner leer oder unbrauchbar ist.

Prüfen, ob der übergebene Pfad wirklich ein Ordner ist

Als Nächstes folgt diese Zeile:

if (-not (Test-Path -Path $Zielordner -PathType Container)) {

Diese Prüfung kontrolliert, ob der übergebene Pfad wirklich ein Ordner ist.

Test-Path prüft, ob ein Pfad existiert.

Mit:

-Path $Zielordner

geben wir an, welcher Pfad geprüft werden soll.

Mit:

-PathType Container

geben wir an, dass dieser Pfad ein Ordner sein muss.

In PowerShell bedeutet Container in diesem Zusammenhang:

Ordner / Verzeichnis / etwas, das andere Elemente enthalten kann

Der Gegenbegriff wäre:

Leaf

Das steht eher für ein einzelnes Endelement, zum Beispiel eine Datei.

Für normale Windows-Pfade kann man sich merken:

Container = Ordner
Leaf      = Datei

Diese Zeile:

if (-not (Test-Path -Path $Zielordner -PathType Container)) {

bedeutet also:

Wenn der übergebene Pfad nicht existiert
oder kein Ordner ist,
dann zeige eine Fehlermeldung.

Warum Container und nicht Directory?

Bei Test-Path heißt der passende Wert nicht Directory, sondern Container.

PowerShell verwendet hier allgemeinere Begriffe, weil PowerShell nicht nur mit normalen Dateien und Ordnern arbeiten kann, sondern auch mit anderen sogenannten Providern.

Für normale Windows-Ordner bedeutet Container aber ganz praktisch:

Der Pfad muss ein Ordner sein.

Ziel anzeigen

Wenn ein gültiger Ordner übergeben wurde, gibt das Skript aus:

Write-Host "Creator-Ordnerstruktur wird erstellt in:"
Write-Host $Zielordner
Write-Host ""

Dadurch sieht man im Fenster, in welchem Zielordner die Ordnerstruktur erstellt wird.

Ordnerliste in der SendTo-Variante

Auch die SendTo-Variante verwendet wieder eine Ordnerliste:

$ordnerListe = @(
    "01_Rohmaterial"
    "02_Audio"
    "03_Projektdateien"
    "04_Grafiken"
    "05_Export"
    "06_Thumbnail"
    "07_Backup"
    "08_UmlauttestäöüßÄÖÜ"
)

Die Liste funktioniert genauso wie in der einfachen Variante.

Der Unterschied ist nicht die Liste selbst, sondern der Zielpfad.

In der einfachen Variante wird der Ordner direkt im aktuellen Ordner erstellt.

In der SendTo-Variante wird jeder Ordner in einem übergebenen Zielordner erstellt.

Vollständigen Ordnerpfad mit Join-Path erstellen

In der Schleife steht jetzt zusätzlich diese Zeile:

$ordnerPfad = Join-Path -Path $Zielordner -ChildPath $ordner

Diese Zeile baut aus dem Zielordner und dem aktuellen Ordnernamen einen vollständigen Pfad.

Beispiel:

$Zielordner = C:\Testprojekt
$ordner     = 01_Rohmaterial

Daraus wird:

C:\Testprojekt\01_Rohmaterial

Man könnte Pfade theoretisch auch selbst mit einem Backslash zusammensetzen.

Zum Beispiel:

$Zielordner + "\" + $ordner

Besser ist aber Join-Path, weil PowerShell damit Pfade sauber zusammensetzt.

Prüfen, ob der Unterordner schon existiert

Danach prüft das Skript:

if (-not (Test-Path -Path $ordnerPfad -PathType Container)) {

Das bedeutet:

Wenn dieser Unterordner im Zielordner noch nicht existiert, dann ...

Wieder verwenden wir -PathType Container, weil wir gezielt Ordner prüfen.

Ordner im Zielordner erstellen

In der SendTo-Variante erstellen wir den Ordner mit:

New-Item -ItemType Directory -Path $ordnerPfad | Out-Null

Hier verwenden wir -Path statt -Name.

Der Grund ist:

-Name $ordner
= Name im aktuellen Ordner

-Path $ordnerPfad
= vollständiger Zielpfad

Da wir bei der SendTo-Variante den vollständigen Pfad bereits mit Join-Path zusammengesetzt haben, ist -Path hier die passende Variante.

Starter-Batchdatei der SendTo-Variante

Die Datei heißt:

002_sendto_projektordner_erstellen_starter_batch.bat

@echo off
REM ============================================================
REM TOPTORIALS OFFICE - PowerShell 7 Grundkurs
REM Script: 002_sendto_projektordner_erstellen_starter_batch.bat
REM Beschreibung: Startet das PowerShell-7-SendTo-Skript.
REM Autor: Chris
REM YouTube: https://www.youtube.com/@TOPTORIALS-OFFICE
REM Webseite: https://www.toptorials.com
REM Version: 1.0
REM Stand: 2026-07-21
REM
REM ============================================================

chcp 65001 >nul

pwsh -ExecutionPolicy Bypass -File "%~dp0\002_sendto_projektordner_erstellen.ps1" "%~1"

Code der SendTo-Starter-Batchdatei erklärt

@echo off

@echo off

Diese Zeile verhindert, dass die Befehle der Batchdatei selbst im Fenster angezeigt werden.

Codepage auf UTF-8 setzen

Diese Zeile ist neu:

chcp 65001 >nul

Damit wird die Codepage der Eingabeaufforderung auf UTF-8 gesetzt.

Das kann bei Umlauten und Sonderzeichen helfen.

65001 steht für UTF-8.

>nul sorgt dafür, dass die Rückmeldung von chcp nicht angezeigt wird.

PowerShell 7 starten und Zielordner übergeben

Der wichtigste Befehl ist:

pwsh -ExecutionPolicy Bypass -File "%~dp0\002_sendto_projektordner_erstellen.ps1" "%~1"

Die ersten Teile kennen wir bereits:

pwsh
= startet PowerShell 7

-ExecutionPolicy Bypass
= erlaubt die Ausführung für diesen Startvorgang

-File
= führt die angegebene PowerShell-Datei aus

"%~dp0\002_sendto_projektordner_erstellen.ps1"
= PowerShell-Skript im gleichen Ordner wie die Starter-Batchdatei

Neu ist am Ende:

"%~1"

Das steht für den ersten übergebenen Parameter.

Wenn man also einen Ordner auf die Starter-Batchdatei zieht oder über SendTo an die Batchdatei übergibt, landet dieser Ordnerpfad in %1.

Mit %~1 wird der erste Parameter ohne äußere Anführungszeichen übernommen.

Danach setzen wir selbst wieder Anführungszeichen darum:

"%~1"

Dadurch bleiben auch Pfade mit Leerzeichen sauber erhalten.

Dieser Pfad wird dann an das PowerShell-Skript übergeben und landet dort in:

$Zielordner

Was wäre bei mehreren übergebenen Ordnern?

Für dieses Tutorial verwenden wir bewusst einen Zielordner.

Dafür ist diese Schreibweise richtig:

"%~1"

Wenn man später mehrere übergebene Parameter weitergeben möchte, verwendet man in Batch normalerweise:

%*

Das steht für alle übergebenen Parameter.

Eine Schreibweise wie %~* ist nicht die übliche sinnvolle Variante.

Merksatz:

%1   = erster Parameter
%~1  = erster Parameter ohne äußere Anführungszeichen
%*   = alle Parameter

SendTo-Verknüpfung einrichten

Damit die SendTo-Variante bequem über den Explorer genutzt werden kann, kann eine Verknüpfung zur Starter-Batchdatei im SendTo-Ordner abgelegt werden.

Den SendTo-Ordner kann man über Ausführen öffnen:

shell:sendto

Dazu:

Windows-Taste + R
shell:sendto eingeben
Enter drücken

In diesen Ordner kann man eine Verknüpfung zu dieser Datei legen:

002_sendto_projektordner_erstellen_starter_batch.bat

Danach kann man im Explorer einen Ordner mit der rechten Maustaste anklicken und über Senden an die Projektordner erstellen lassen.

Was passiert beim Ausführen der SendTo-Variante?

Wenn die SendTo-Variante gestartet wird, passiert Folgendes:

Ein Ordner wird an die Starter-Batchdatei übergeben.
Die Batchdatei startet PowerShell 7 mit pwsh.
Der übergebene Ordner wird an das PowerShell-Skript weitergegeben.
PowerShell speichert den Pfad in $Zielordner.
Das Skript prüft, ob überhaupt ein Zielordner übergeben wurde.
Das Skript prüft, ob der Pfad wirklich ein Ordner ist.
Die Ordnerliste wird geladen.
Für jeden Ordnernamen wird mit Join-Path ein vollständiger Pfad gebaut.
Test-Path prüft, ob der Unterordner schon existiert.
Fehlende Ordner werden mit New-Item erstellt.
Out-Null unterdrückt die automatische Rückgabe.
Am Ende wartet Read-Host auf Enter.

Typische Fehler

PowerShell 7 wurde nicht gefunden

Wenn beim Starten der Batchdatei eine Meldung erscheint, dass pwsh nicht gefunden wurde, ist PowerShell 7 wahrscheinlich noch nicht installiert oder der Befehl ist nicht im Systempfad verfügbar.

Prüfe in der Eingabeaufforderung:

pwsh --version

Wenn das nicht funktioniert, installiere PowerShell 7 zuerst.

Es wurde kein Ordner übergeben

Wenn die SendTo-Starter-Batchdatei direkt per Doppelklick gestartet wird, wurde kein Zielordner übergeben.

Dann zeigt das Skript diese Meldung:

Bitte übergib einen Ordner.

Die SendTo-Variante ist dafür gedacht, dass ein Ordner an das Skript übergeben wird.

Zum Beispiel über:

Rechtsklick auf Ordner
Senden an
Starter-Batchdatei auswählen

Der übergebene Pfad ist kein Ordner

Wenn kein Ordner, sondern etwas anderes übergeben wird, erkennt das Skript das mit:

Test-Path -Path $Zielordner -PathType Container

Dadurch wird geprüft, ob der übergebene Pfad wirklich ein Ordner ist.

Die Datei heißt versehentlich .ps1.txt

Wenn die Datei im Editor gespeichert wurde, kann es passieren, dass sie versehentlich so heißt:

002_ordner_erstellen.ps1.txt

Richtig ist:

002_ordner_erstellen.ps1

oder bei der SendTo-Variante:

002_sendto_projektordner_erstellen.ps1

Blende im Explorer am besten die Dateinamenerweiterungen ein, damit du die echte Endung sehen kannst.

Umlaute sehen falsch aus

Wenn Umlaute wie äöüß falsch angezeigt werden, kann das mit der Kodierung der Datei oder mit der verwendeten Konsole zusammenhängen.

Für diese Kursreihe empfiehlt es sich, die Dateien als UTF-8 zu speichern.

In VS Code sieht man die Kodierung normalerweise unten rechts in der Statusleiste. Dort sollte UTF-8 stehen.

Einträge in der Liste stehen in einer Zeile ohne Kommas

Diese Schreibweise ist falsch:

$ordnerListe = @("01_Rohmaterial" "02_Audio" "03_Projektdateien")

Wenn mehrere Einträge in einer Zeile stehen, müssen sie mit Kommas getrennt werden:

$ordnerListe = @("01_Rohmaterial", "02_Audio", "03_Projektdateien")

Wenn die Einträge untereinander stehen, kann man die Liste ohne Kommas schreiben:

$ordnerListe = @(
    "01_Rohmaterial"
    "02_Audio"
    "03_Projektdateien"
)

Nützliche PowerShell-Befehle für Dateien, Ordner und Pfade

Viele PowerShell-Befehle rund um Dateien und Ordner enden auf -Item oder -Path.

Item = meistens Datei oder Ordner
Path = meistens Pfad oder Speicherort

Eine kleine Übersicht:

Was haben wir gelernt?

In diesem Teil wurden mehrere wichtige Grundlagen gezeigt:

Eine Liste kann mit @(... ) erstellt werden.
Jeder Ordnername kann als eigener Listeneintrag gespeichert werden.
foreach geht eine Liste Eintrag für Eintrag durch.
$ordner enthält immer den aktuellen Eintrag aus der Liste.
Test-Path prüft, ob ein Pfad existiert.
-not bedeutet nicht und kehrt ein Ergebnis um.
New-Item erstellt ein neues Element.
-ItemType Directory gibt an, dass ein Ordner erstellt werden soll.
-Name $ordner verwendet den aktuellen Ordnernamen.
Out-Null unterdrückt die automatische Rückgabe.
param kann übergebene Werte entgegennehmen.
[string] steht für einen Textwert.
[string]::IsNullOrWhiteSpace prüft, ob ein Text leer oder unbrauchbar ist.
-PathType Container prüft, ob ein Pfad wirklich ein Ordner ist.
Join-Path setzt Pfade sauber zusammen.
-Path kann einen vollständigen Zielpfad verwenden.
%~1 steht in Batch für den ersten übergebenen Parameter ohne äußere Anführungszeichen.
Die Starter-Batchdatei startet gezielt PowerShell 7 mit pwsh.

Damit haben wir nicht nur eine einfache Ordnerstruktur mit PowerShell 7 erstellt, sondern auch eine praktischere SendTo-Variante gebaut.

In den nächsten Teilen werden wir weiter mit Dateien, Ordnern, Listen und später auch mit ausgewählten Dateien arbeiten.

Video zu diesem Tutorial:

Das könnte Dich auch interessieren

Keine Einträge gefunden