PowerShell 7 Grundkurs 003: Dateiliste erstellen und in die Zwischenablage kopieren

Worum geht es in diesem Teil?

In diesem dritten Teil des PowerShell-7-Grundkurses erstellen wir automatisch eine Dateiliste.

Dabei lernen wir, wie PowerShell Dateien als Objekte verarbeitet und wie man daraus gezielt bestimmte Informationen ausliest.

Zum Beispiel:

Dateiname
relativer Pfad
vollständiger Pfad

Dateiliste mit relativen Pfaden

Zusätzlich schreiben wir die fertige Liste in eine Textdatei und kopieren sie in die Zwischenablage.

Es gibt wieder zwei Varianten:

01_Einfach
02_SendTo_Dateiliste_erstellen

Die erste Variante wird direkt in einen Ordner kopiert und dort ausgeführt.

Die zweite Variante ist eine SendTo-Version. Damit können Dateien oder Ordner im Windows-Explorer markiert und über Senden an an das PowerShell-Skript übergeben werden.

Was ist das Ziel?

Das Skript soll aus Dateien automatisch eine Liste erstellen.

Je nach aktivierter Variante kann diese Liste zum Beispiel enthalten:

nur die Dateinamen
relative Pfade
vollständige Pfade
rekursive Dateilisten aus Ordnern

Die fertige Liste kann anschließend:

in eine Textdatei geschrieben werden
in die Zwischenablage kopiert werden
oder beides gleichzeitig

Das ist im Alltag sehr praktisch, wenn man schnell eine Liste von Dateien benötigt, zum Beispiel für Dokumentationen, Uploads, Projektübersichten, Webseiten oder weitere Verarbeitungsschritte.

Warum ist dieser Teil wichtig?

Dieser Teil ist besonders wichtig, weil hier ein zentraler Unterschied zwischen Batch und PowerShell sichtbar wird.

Batch arbeitet sehr stark mit Text.

PowerShell arbeitet dagegen sehr viel mit Objekten.

Wenn PowerShell Dateien findet, bekommen wir nicht nur Textzeilen zurück, sondern Dateiobjekte mit Eigenschaften.

Zum Beispiel:

Name
FullName
Extension
Length
LastWriteTime
CreationTime

Dadurch können wir später sehr gezielt auswählen, welche Information wir benötigen.

Zum Beispiel:

$datei.Name

für den Dateinamen oder:

$datei.FullName

für den vollständigen Pfad.

Hinweis zur Kursreihe

Diese PowerShell-7-Reihe ist Teil einer größeren Windows-Automatisierungsreihe.

Viele Aufgaben werden in mehreren Sprachen umgesetzt:

Batch
PowerShell 7
Python

Dadurch kann man sehr gut vergleichen, wie dieselbe Aufgabe in unterschiedlichen Sprachen gelöst wird.

In diesem Teil orientiert sich die PowerShell-Version bewusst am Aufbau der Batch-Version. Es gäbe natürlich auch andere Möglichkeiten mit Eingabemenüs, Parametern, Auswahlabfragen oder noch kompakterer Pipeline-Schreibweise.

Für den Grundkurs bleibt der Aufbau aber absichtlich gut vergleichbar und leicht nachvollziehbar.

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\003_Dateiliste_erstellen

01_Einfach
02_SendTo_Dateiliste_erstellen

Testumgebung zum Mitmachen

Für diese Tutorialreihe gibt es zusätzlich eine vorbereitete Testumgebung.

Die Testumgebung enthält vorbereitete Ordner und Beispieldateien, mit denen die Skripte gefahrlos ausprobiert werden können.

C:\TOPTORIALS_CODE\1000_TESTBEREICH

TOPTORIALS_Testdaten_Windows_Automatisierung_Powershell_7_V001

Ein möglicher Testpfad wäre dann:

C:\TOPTORIALS_CODE\1000_TESTBEREICH\TOPTORIALS_Testdaten_Windows_Automatisierung_Powershell_7_V001\003_Dateiliste_erstellen

Sicherheitshinweis

Enthaltene Dateien

Zu diesem Teil gehören zwei Varianten.

Variante 1: Einfach

01_Einfach
├── 003_dateiliste_erstellen.ps1
└── 003_dateiliste_erstellen_starter_batch.bat

Variante 2: SendTo-Dateiliste erstellen

02_SendTo_Dateiliste_erstellen
├── 003_sendto_dateiliste_erstellen.ps1
└── 003_sendto_dateiliste_erstellen_starter_batch.bat

Variante 1: Einfache Dateiliste erstellen

Die einfache Variante wird in den Ordner kopiert, aus dem eine Dateiliste erstellt werden soll.

Danach wird die Starter-Batchdatei gestartet.

Das PowerShell-Skript erstellt dann:

dateiliste.txt

und kopiert die Liste zusätzlich in die Zwischenablage.

Der komplette Code der einfachen PowerShell-Datei

Die Datei heißt:

003_dateiliste_erstellen.ps1

# ============================================================
# TOPTORIALS OFFICE - PowerShell 7 Grundkurs
# Script: 003_dateiliste_erstellen.ps1
# Beschreibung: Erstellt eine Dateiliste und kopiert sie zusaetzlich in die Zwischenablage.
# Autor: Chris
# YouTube: https://www.youtube.com/@TOPTORIALS-OFFICE
# Webseite: https://www.toptorials.com
# Version: 1.0
# Stand: 2026-07-24
#
# ============================================================

Write-Host ""
Write-Host "Dateiliste wird erstellt..."
Write-Host ""

$ausgabeDatei = "dateiliste.txt"

# ------------------------------------------------------------
# Welche Dateien sollen aufgelistet werden?
# ------------------------------------------------------------

# Dateien im aktuellen Ordner, nicht rekursiv:
$dateien = Get-ChildItem -File

# Alternative: Dateien im aktuellen Ordner und in allen Unterordnern:
# $dateien = Get-ChildItem -File -Recurse


# ------------------------------------------------------------
# Was soll in der Liste stehen?
# Wichtig: Immer nur EINE der folgenden Varianten aktiv lassen.
# ------------------------------------------------------------

# Variante 1: Nur Dateinamen
$liste = $dateien | ForEach-Object {
    $_.Name
}

# Variante 2: Relative Pfade
# $liste = $dateien | ForEach-Object {
#     Resolve-Path -Path $_.FullName -Relative
# }

# Variante 3: Absolute Pfade
# $liste = $dateien | ForEach-Object {
#     $_.FullName
# }


# ------------------------------------------------------------
# Ausgabe
# Wenn eine Ausgabe nicht gewuenscht ist, kann die passende Zeile
# einfach auskommentiert werden.
# ------------------------------------------------------------

# Liste in Textdatei schreiben:
$liste | Set-Content -Path $ausgabeDatei -Encoding UTF8

# Liste in die Zwischenablage kopieren:
$liste | Set-Clipboard


Write-Host "Fertig."
Write-Host "Die Datei $ausgabeDatei wurde erstellt."
Write-Host "Der Inhalt wurde zusaetzlich in die Zwischenablage kopiert."
Write-Host ""

Read-Host "Drücke Enter zum Beenden"

Code der einfachen PowerShell-Datei erklärt

Kommentarblock

Der Code beginnt mit einem Kommentarblock.

Kommentare beginnen in PowerShell mit:

#

Alles, was hinter diesem Zeichen steht, wird nicht als Befehl ausgeführt.

Der Kommentarblock enthält Informationen zum Skript:

# TOPTORIALS OFFICE - PowerShell 7 Grundkurs
# Script: 003_dateiliste_erstellen.ps1
# Beschreibung: Erstellt eine Dateiliste und kopiert sie zusaetzlich in die Zwischenablage.

Solche Informationen sind hilfreich, wenn man später mehrere Skripte gesammelt hat.

Ausgaben mit Write-Host

Am Anfang steht:

Write-Host ""
Write-Host "Dateiliste wird erstellt..."
Write-Host ""

Write-Host gibt Text im Konsolenfenster aus.

Mit:

Write-Host ""

wird eine leere Zeile ausgegeben.

Dadurch wird die Ausgabe im Fenster besser lesbar.

Name der Ausgabedatei

Diese Zeile legt den Namen der Textdatei fest:

$ausgabeDatei = "dateiliste.txt"

$ausgabeDatei ist eine Variable.

In dieser Variable steht der Dateiname:

dateiliste.txt

Später wird diese Variable bei Set-Content verwendet.

Dateien im aktuellen Ordner holen

Diese Zeile ist der erste wichtige Arbeitsschritt:

$dateien = Get-ChildItem -File

Das kann man so lesen:

Hole alle Dateien aus dem aktuellen Ordner
und speichere sie in der Variable $dateien.

Die Bestandteile:

$dateien
= Variable für die gefundenen Dateien

Get-ChildItem
= PowerShell-Befehl zum Auflisten von Dateien und Ordnern

-File
= nur Dateien auflisten, keine Ordner

Get-ChildItem ist in PowerShell ungefähr vergleichbar mit dir in Batch.

Der wichtige Unterschied ist:

PowerShell liefert hier Dateiobjekte, nicht nur Textzeilen.

Ein Dateiobjekt enthält verschiedene Eigenschaften.

Zum Beispiel:

Name
FullName
Extension
Length
DirectoryName
LastWriteTime
CreationTime

Deshalb können wir später schreiben:

$_.Name

oder:

$_.FullName

Rekursive Alternative

Im Skript steht außerdem diese auskommentierte Alternative:

# $dateien = Get-ChildItem -File -Recurse

-Recurse bedeutet:

Unterordner mit einbeziehen.

Wenn diese Zeile aktiviert wird, durchsucht PowerShell nicht nur den aktuellen Ordner, sondern auch alle Unterordner.

Wichtig ist: Es sollte immer nur eine dieser beiden Varianten aktiv sein.

Nicht rekursiv:

$dateien = Get-ChildItem -File

Rekursiv:

$dateien = Get-ChildItem -File -Recurse

Die Liste erstellen

Danach wird aus den gefundenen Dateien eine Liste erstellt.

Aktiv ist zuerst Variante 1:

$liste = $dateien | ForEach-Object {
    $_.Name
}

Diese Zeile kann man so lesen:

Nimm alle Dateiobjekte aus $dateien.
Gehe jedes Dateiobjekt einzeln durch.
Nimm von jedem Dateiobjekt nur den Namen.
Speichere alle Namen in $liste.

Die Bestandteile:

$liste
= Variable für die fertige Textliste

$dateien
= gefundene Dateiobjekte

|
= Pipeline

ForEach-Object
= jedes Objekt einzeln verarbeiten

$_
= aktuelles Objekt in der Pipeline

.Name
= Eigenschaft Name des aktuellen Objekts

$_ ist eine automatische Variable in der Pipeline.

Sie steht immer für das aktuelle Objekt.

Beispiel:

1. Durchlauf:
$_ = erste Datei
$_.Name = Name der ersten Datei

2. Durchlauf:
$_ = zweite Datei
$_.Name = Name der zweiten Datei

3. Durchlauf:
$_ = dritte Datei
$_.Name = Name der dritten Datei

Wenn im Ordner diese Dateien liegen:

bild_start.jpg
notiz.txt
protokoll.log

dann enthält $liste danach:

bild_start.jpg
notiz.txt
protokoll.log

Pipeline kurz erklärt

Das Zeichen:

|

ist die Pipeline.

Die Pipeline gibt das Ergebnis des linken Befehls an den rechten Befehl weiter.

In diesem Beispiel:

$dateien | ForEach-Object { ... }

bedeutet das:

Gib die gefundenen Dateiobjekte an ForEach-Object weiter.

PowerShell arbeitet sehr häufig mit solchen Verarbeitungsketten.

Alternative verständlichere Schreibweise

Die Pipeline-Variante ist typisch für PowerShell.

Für Einsteiger kann man sich dieselbe Logik aber auch so vorstellen:

$liste = foreach ($datei in $dateien) {
    $datei.Name
}

Das bedeutet:

Für jede Datei in $dateien:
    gib den Namen zurück.

Beide Varianten erzeugen im Prinzip dieselbe Liste.

Die verwendete Version mit ForEach-Object zeigt aber direkt die typische Pipeline-Schreibweise von PowerShell.

Variante 1: Nur Dateinamen

Aktiv ist zuerst:

$liste = $dateien | ForEach-Object {
    $_.Name
}

Diese Variante gibt nur die Dateinamen aus.

Beispiel:

archiv_test.zip
bild_start.jpg
notiz.txt
protokoll.log
rechnung_maerz.pdf

Variante 2: Relative Pfade

Die zweite Variante ist auskommentiert:

# $liste = $dateien | ForEach-Object {
#     Resolve-Path -Path $_.FullName -Relative
# }

Wenn diese Variante aktiviert wird, erstellt PowerShell relative Pfade.

Ein vollständiger Pfad könnte zum Beispiel so aussehen:

C:\TOPTORIALS_CODE\010_PowerShell_7_Grundkurs\003_Dateiliste_erstellen\01_Einfach\Bilder\bild01.png

Ein relativer Pfad ausgehend vom aktuellen Ordner wäre dann zum Beispiel:

.\Bilder\bild01.png

Der Punkt am Anfang bedeutet:

aktueller Ordner

Resolve-Path berechnet den relativen Pfad.

Diese Zeile:

Resolve-Path -Path $_.FullName -Relative

bedeutet:

Nimm den vollständigen Pfad der aktuellen Datei
und gib ihn relativ zum aktuellen Ordner aus.

Warum braucht man hier mehr Code als bei $_.FullName?

Weil FullName bereits als Eigenschaft im Dateiobjekt vorhanden ist.

Ein relativer Pfad muss dagegen erst berechnet werden.

Merksatz:

FullName ist schon vorhanden.
Relative Pfade müssen berechnet werden.

Variante 3: Absolute Pfade

Die dritte Variante ist ebenfalls auskommentiert:

# $liste = $dateien | ForEach-Object {
#     $_.FullName
# }

Diese Variante gibt den vollständigen Pfad aus.

Beispiel:

C:\TOPTORIALS_CODE\...\bild_start.jpg

Hier reicht:

$_.FullName

weil FullName eine vorhandene Eigenschaft des Dateiobjekts ist.

Wichtig: Nur eine Listenvariante aktiv lassen

Im Skript steht bewusst der Hinweis:

# Wichtig: Immer nur EINE der folgenden Varianten aktiv lassen.

Das ist wichtig, weil jede Variante die Variable $liste neu setzt.

Wenn mehrere Varianten gleichzeitig aktiv wären, würde die letzte aktive Variante die vorherige überschreiben.

Für den Grundkurs ist diese Arbeitsweise bewusst einfach gehalten:

gewünschte Variante aktiv lassen
andere Varianten auskommentieren

Liste in eine Textdatei schreiben

Diese Zeile schreibt die Liste in eine Textdatei:

$liste | Set-Content -Path $ausgabeDatei -Encoding UTF8

Gelesen:

Nimm $liste
und schreibe den Inhalt in die Datei $ausgabeDatei.

Die Bestandteile:

$liste
= fertige Textliste

|
= Pipeline

Set-Content
= Inhalt in eine Datei schreiben

-Path $ausgabeDatei
= Ziel-Datei

-Encoding UTF8
= als UTF-8 speichern

Set-Content schreibt den Inhalt neu.

Wenn die Datei bereits existiert, wird der bisherige Inhalt ersetzt.

Das ist hier sinnvoll, weil bei jedem Start eine neue aktuelle Dateiliste erstellt werden soll.

Unterschied zu Add-Content

Für später ist dieser Unterschied wichtig:

Set-Content
= Datei neu schreiben oder vorhandenen Inhalt ersetzen

Add-Content
= Inhalt an eine bestehende Datei anhängen

Für dieses Skript ist Set-Content die richtige Wahl.

Liste in die Zwischenablage kopieren

Diese Zeile kopiert die Liste in die Zwischenablage:

$liste | Set-Clipboard

Gelesen:

Nimm $liste
und kopiere den Inhalt in die Zwischenablage.

Danach kann die Liste mit Strg + V in ein anderes Programm eingefügt werden.

Zum Beispiel in:

Editor
WordPress
Excel
LibreOffice Calc
eine E-Mail
eine Dokumentation

Ausgabe deaktivieren

Im Skript sind beide Ausgabezeilen aktiv:

$liste | Set-Content -Path $ausgabeDatei -Encoding UTF8
$liste | Set-Clipboard

Wenn man die Textdatei nicht möchte, kann man diese Zeile auskommentieren:

# $liste | Set-Content -Path $ausgabeDatei -Encoding UTF8

Wenn man die Zwischenablage nicht möchte, kann man diese Zeile auskommentieren:

# $liste | Set-Clipboard

So bleibt das Skript für den Grundkurs übersichtlich, ohne dass direkt Auswahlmenüs oder zusätzliche Variablen nötig sind.

Starter-Batchdatei der einfachen Variante

Die Datei heißt:

003_dateiliste_erstellen_starter_batch.bat

@echo off
REM ============================================================
REM TOPTORIALS OFFICE - PowerShell 7 Grundkurs
REM Script: 003_dateiliste_erstellen_starter_batch.bat
REM Beschreibung: Startet das PowerShell-7-Skript 003_dateiliste_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-24
REM
REM ============================================================

chcp 65001 >nul
cd /d "%~dp0"

pwsh -ExecutionPolicy Bypass -File "003_dateiliste_erstellen.ps1"

Code der einfachen 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

chcp 65001 >nul

Diese Zeile setzt die Codepage der Eingabeaufforderung auf UTF-8.

65001 steht für UTF-8.

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

In den Ordner der Starter-Batchdatei wechseln

cd /d "%~dp0"

Diese Zeile wechselt in den Ordner, in dem die Starter-Batchdatei liegt.

%~dp0 steht für Laufwerk und Pfad der aktuellen Batchdatei.

Wichtig:

%~dp0 enthält bereits den abschließenden Backslash.

Deshalb wechseln wir zuerst mit cd /d "%~dp0" in diesen Ordner und starten danach die PowerShell-Datei nur noch über ihren Dateinamen.

Das ist sauberer und vermeidet doppelte Backslashes im Pfad.

Der Teil /d sorgt dafür, dass auch das Laufwerk gewechselt wird, falls die Batchdatei auf einem anderen Laufwerk liegt.

PowerShell 7 starten

pwsh -ExecutionPolicy Bypass -File "003_dateiliste_erstellen.ps1"

Diese Zeile startet PowerShell 7 und führt die angegebene Datei aus.

Die Bestandteile:

pwsh
= startet PowerShell 7

-ExecutionPolicy Bypass
= umgeht für diesen Start die Ausführungsrichtlinie

-File
= danach folgt die PowerShell-Datei, die gestartet werden soll

"003_dateiliste_erstellen.ps1"
= die auszuführende PowerShell-Datei

Variante 2: Dateiliste über SendTo erstellen

Die SendTo-Variante ist flexibler.

Damit können Dateien oder Ordner im Windows-Explorer markiert und an das Skript übergeben werden.

Der Ablauf ist:

Dateien oder Ordner im Explorer markieren
Rechtsklick
Senden an
PowerShell-Skript starten
Liste wird erstellt
Ausgabe in TXT und Zwischenablage

Der komplette Code der SendTo-PowerShell-Datei

Die Datei heißt:

003_sendto_dateiliste_erstellen.ps1

# ============================================================
# TOPTORIALS OFFICE - PowerShell 7 Grundkurs
# Script: 003_sendto_dateiliste_erstellen.ps1
# Beschreibung: Erstellt aus uebergebenen Dateien und Ordnern eine Liste und kopiert sie in die Zwischenablage.
# Autor: Chris
# YouTube: https://www.youtube.com/@TOPTORIALS-OFFICE
# Webseite: https://www.toptorials.com
# Version: 1.0
# Stand: 2026-07-24
#
# ============================================================

param (
    [Parameter(ValueFromRemainingArguments = $true)]
    [string[]]$Elemente
)

Write-Host ""

if (-not $Elemente -or $Elemente.Count -eq 0) {
    Write-Host "Bitte markiere Dateien oder Ordner und sende sie an dieses Skript."
    Write-Host ""
    Write-Host "Du kannst im Explorer Dateien oder Ordner markieren,"
    Write-Host "dann Rechtsklick - Senden an verwenden."
    Write-Host ""
    Read-Host "Drücke Enter zum Beenden"
    exit
}

Write-Host "Dateiliste wird erstellt..."
Write-Host ""

$ausgabeDatei = "dateiliste_sendto.txt"

# Uebergebene Elemente in PowerShell-Objekte umwandeln
$uebergebeneElemente = foreach ($element in $Elemente) {
    if (Test-Path -Path $element) {
        Get-Item -Path $element
    }
}


# ------------------------------------------------------------
# Was soll in der Liste stehen?
# Wichtig: Immer nur EINE der folgenden Varianten aktiv lassen.
# ------------------------------------------------------------

# Variante 1: Nur Namen der markierten Dateien und Ordner
$liste = $uebergebeneElemente | ForEach-Object {
   $_.Name
}

# Variante 2: Vollstaendige Pfade der markierten Dateien und Ordner
# $liste = $uebergebeneElemente | ForEach-Object {
#     $_.FullName
# }

# Variante 3: Rekursiv - absolute Pfade aller Dateien in uebergebenen Ordnern
# Einzelne Dateien werden direkt uebernommen.
# $liste = foreach ($element in $uebergebeneElemente) {
#    if ($element.PSIsContainer) {
#         Get-ChildItem -Path $element.FullName -File -Recurse | ForEach-Object {
#             $_.FullName
#         }
#     } else {
#         $element.FullName
#     }
# }

# Variante 4: Rekursiv - relative Pfade aller Dateien in uebergebenen Ordnern
# Einzelne Dateien werden mit relativem Pfad ausgegeben.
# $liste = foreach ($element in $uebergebeneElemente) {
#     if ($element.PSIsContainer) {
#         Get-ChildItem -Path $element.FullName -File -Recurse | ForEach-Object {
#             Resolve-Path -Path $_.FullName -Relative
#         }
#     } else {
#         Resolve-Path -Path $element.FullName -Relative
#     }
# }


# ------------------------------------------------------------
# Ausgabe
# Wenn eine Ausgabe nicht gewuenscht ist, kann die passende Zeile
# einfach auskommentiert werden.
# ------------------------------------------------------------

# Liste in Textdatei schreiben:
$liste | Set-Content -Path $ausgabeDatei -Encoding UTF8

# Liste in die Zwischenablage kopieren:
$liste | Set-Clipboard


Write-Host "Fertig."
Write-Host "Die Liste wurde erstellt."
Write-Host "Die Datei $ausgabeDatei wurde erstellt."
Write-Host "Der Inhalt wurde zusaetzlich in die Zwischenablage kopiert."
Write-Host ""

Read-Host "Drücke Enter zum Beenden"

Code der SendTo-PowerShell-Datei erklärt

Der param-Block

Die SendTo-Version beginnt nach dem Kommentarblock mit:

param (
    [Parameter(ValueFromRemainingArguments = $true)]
    [string[]]$Elemente
)

Dieser Block legt fest, welche Werte das Skript beim Start entgegennehmen kann.

$Elemente enthält später die übergebenen Dateien oder Ordner.

Der Teil:

[string[]]$Elemente

bedeutet:

$Elemente ist eine Liste aus Textwerten.

[string] wäre ein einzelner Textwert.

[string[]] bedeutet mehrere Textwerte als Liste.

Der zusätzliche Teil:

[Parameter(ValueFromRemainingArguments = $true)]

ist wichtig für die SendTo-Übergabe.

Er bedeutet:

Nimm alle übrigen übergebenen Argumente
und sammle sie in diesem Parameter.

Das ist besonders wichtig, wenn mehrere Dateien oder Ordner markiert und über Senden an übergeben werden.

Man kann sich merken:

[string[]]
= kann mehrere Textwerte speichern

ValueFromRemainingArguments
= sammelt alle restlichen übergebenen Werte ein

Prüfen, ob Elemente übergeben wurden

Danach kommt diese Bedingung:

if (-not $Elemente -or $Elemente.Count -eq 0) {

Sie prüft, ob überhaupt Dateien oder Ordner übergeben wurden.

Die Bestandteile:

-not $Elemente
= es gibt keinen brauchbaren Wert in $Elemente

-or
= oder

$Elemente.Count -eq 0
= die Anzahl der Elemente ist 0

Die Zeile bedeutet also:

Wenn keine Elemente übergeben wurden
oder die Anzahl der Elemente 0 ist,
dann zeige eine Meldung an und beende das Skript.

Noch klarer könnte man es auch mit zusätzlichen Klammern schreiben:

if ((-not $Elemente) -or ($Elemente.Count -eq 0)) {

Inhaltlich ist die Absicht gleich, aber die Klammern machen die Logik für Einsteiger etwas besser sichtbar.

Hinweis ausgeben und Skript beenden

Wenn keine Elemente übergeben wurden, zeigt das Skript eine Meldung an:

Write-Host "Bitte markiere Dateien oder Ordner und sende sie an dieses Skript."

Danach wartet es auf Enter:

Read-Host "Drücke Enter zum Beenden"

und beendet sich mit:

exit

Das ist wichtig, weil die SendTo-Variante nur sinnvoll funktioniert, wenn Dateien oder Ordner übergeben wurden.

Ausgabedatei für SendTo

Diese Zeile legt den Namen der SendTo-Ausgabedatei fest:

$ausgabeDatei = "dateiliste_sendto.txt"

Die Datei heißt hier anders als in der einfachen Variante, damit man beide Ausgaben leichter unterscheiden kann.

Übergebene Elemente in Objekte umwandeln

Jetzt kommt ein besonders wichtiger Teil:

$uebergebeneElemente = foreach ($element in $Elemente) {
    if (Test-Path -Path $element) {
        Get-Item -Path $element
    }
}

Die SendTo-Batchdatei übergibt die markierten Dateien und Ordner zuerst als Textwerte an PowerShell.

In $Elemente steht also zunächst eine Liste von Pfaden als Text.

Beispiel:

$Elemente[0] = C:\Test\bild01.png
$Elemente[1] = C:\Test\projektordner
$Elemente[2] = C:\Test\notiz.txt

Mit:

foreach ($element in $Elemente)

geht PowerShell jeden übergebenen Pfad einzeln durch.

$element enthält dabei immer den aktuellen Pfad.

Mit:

Test-Path -Path $element

prüfen wir, ob dieser Pfad wirklich existiert.

Wenn der Pfad existiert, wird diese Zeile ausgeführt:

Get-Item -Path $element

Get-Item holt zu diesem Textpfad das passende Datei- oder Ordnerobjekt.

Der Unterschied ist:

$element
= Textpfad

Get-Item -Path $element
= Datei- oder Ordnerobjekt zu diesem Pfad

Das Objekt hat danach Eigenschaften wie:

Name
FullName
Extension
Length
LastWriteTime
PSIsContainer

Warum wird das Ergebnis in $uebergebeneElemente gesammelt?

Die komplette Schleife steht rechts vom Gleichheitszeichen:

$uebergebeneElemente = foreach ($element in $Elemente) {
    if (Test-Path -Path $element) {
        Get-Item -Path $element
    }
}

PowerShell führt zuerst die Schleife aus.

Alles, was die Schleife ausgibt, wird gesammelt und danach in $uebergebeneElemente gespeichert.

Man kann sich das so vorstellen:

Für jeden übergebenen Pfad:
    Wenn der Pfad existiert:
        hole das passende Datei- oder Ordnerobjekt
        gib dieses Objekt aus

Am Ende:
    sammle alle ausgegebenen Objekte in $uebergebeneElemente

Eine ausführlichere Schreibweise wäre:

$uebergebeneElemente = @()

foreach ($element in $Elemente) {
    if (Test-Path -Path $element) {
        $uebergebeneElemente += Get-Item -Path $element
    }
}

Diese Schreibweise ist länger, zeigt aber deutlicher:

leere Liste anlegen
Objekte einzeln hinzufügen

Die verwendete PowerShell-Schreibweise ist kompakter und typisch für PowerShell.

Variante 1: Namen der markierten Dateien und Ordner

Aktiv ist zuerst:

$liste = $uebergebeneElemente | ForEach-Object {
   $_.Name
}

Diese Variante gibt nur die Namen der markierten Dateien und Ordner aus.

Beispiel:

archiv_test.zip
bild_start.jpg
notiz.txt
protokoll.log
rechnung_maerz.pdf

Wenn ein Ordner markiert wurde, wird nur der Name dieses Ordners ausgegeben. Es wird in dieser Variante nicht automatisch in den Ordner hineingeschaut.

Variante 2: Vollständige Pfade der markierten Dateien und Ordner

Die zweite Variante ist auskommentiert:

# $liste = $uebergebeneElemente | ForEach-Object {
#     $_.FullName
# }

Diese Variante gibt die vollständigen Pfade der markierten Elemente aus.

Beispiel:

C:\TOPTORIALS_CODE\...\archiv_test.zip
C:\TOPTORIALS_CODE\...\bild_start.jpg
C:\TOPTORIALS_CODE\...\notiz.txt

Hier reicht:

$_.FullName

weil FullName eine vorhandene Eigenschaft des Datei- oder Ordnerobjekts ist.

Variante 3: Rekursiv mit absoluten Pfaden

Die dritte Variante ist ebenfalls auskommentiert:

# $liste = foreach ($element in $uebergebeneElemente) {
#    if ($element.PSIsContainer) {
#         Get-ChildItem -Path $element.FullName -File -Recurse | ForEach-Object {
#             $_.FullName
#         }
#     } else {
#         $element.FullName
#     }
# }

Diese Variante ist für Ordner besonders interessant.

Sie prüft jedes übergebene Element:

Ist es ein Ordner?
Oder ist es eine Datei?

Das passiert mit:

$element.PSIsContainer

PSIsContainer bedeutet bei normalen Windows-Dateien und Ordnern praktisch:

Ordner = True
Datei  = False

Wenn das Element ein Ordner ist, wird dieser Ordner rekursiv durchsucht:

Get-ChildItem -Path $element.FullName -File -Recurse

Die Bestandteile:

Get-ChildItem
= Dateien und Ordner auflisten

-Path $element.FullName
= der zu durchsuchende Ordner

-File
= nur Dateien

-Recurse
= inklusive Unterordner

Von jeder gefundenen Datei wird dann der vollständige Pfad ausgegeben:

$_.FullName

Wenn das übergebene Element keine Ordner, sondern eine einzelne Datei ist, wird direkt ihr vollständiger Pfad übernommen:

$element.FullName

Variante 4: Rekursiv mit relativen Pfaden

Die vierte Variante ist ebenfalls auskommentiert:

# $liste = foreach ($element in $uebergebeneElemente) {
#     if ($element.PSIsContainer) {
#         Get-ChildItem -Path $element.FullName -File -Recurse | ForEach-Object {
#             Resolve-Path -Path $_.FullName -Relative
#         }
#     } else {
#         Resolve-Path -Path $element.FullName -Relative
#     }
# }

Diese Variante funktioniert ähnlich wie Variante 3, gibt aber relative Pfade aus.

Bei Dateien aus Ordnern wird verwendet:

Resolve-Path -Path $_.FullName -Relative

Bei einzeln übergebenen Dateien wird verwendet:

Resolve-Path -Path $element.FullName -Relative

Resolve-Path berechnet den relativen Pfad ausgehend vom aktuellen Arbeitsordner.

Beispiel:

Vollständiger Pfad:

C:\TOPTORIALS_CODE\010_PowerShell_7_Grundkurs\003_Dateiliste_erstellen\02_SendTo_Dateiliste_erstellen\Bilder\bild01.png

Relativer Pfad:

.\Bilder\bild01.png

Der Punkt bedeutet:

aktueller Ordner

Warum gibt es mehrere Varianten im gleichen Skript?

Für diesen Grundkurs ist das bewusst so aufgebaut.

Die Varianten können durch Kommentieren und Auskommentieren aktiviert oder deaktiviert werden.

Dadurch bleibt der Ablauf nah an der Batch-Version und die Unterschiede zwischen den Sprachen lassen sich besser vergleichen.

Wichtig ist:

Immer nur eine Listenvariante aktiv lassen.

Sonst wird $liste mehrfach gesetzt und die letzte aktive Variante überschreibt die vorherige.

Starter-Batchdatei der SendTo-Variante

Die Datei heißt:

003_sendto_dateiliste_erstellen_starter_batch.bat

@echo off
REM ============================================================
REM TOPTORIALS OFFICE - PowerShell 7 Grundkurs
REM Script: 003_sendto_dateiliste_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-24
REM
REM ============================================================

chcp 65001 >nul
cd /d "%~dp0"

pwsh -ExecutionPolicy Bypass -File "003_sendto_dateiliste_erstellen.ps1" %*

Code der SendTo-Starter-Batchdatei erklärt

Der Anfang ist wie bei der einfachen Variante:

@echo off
chcp 65001 >nul
cd /d "%~dp0"

Danach wird PowerShell 7 gestartet:

pwsh -ExecutionPolicy Bypass -File "003_sendto_dateiliste_erstellen.ps1" %*

Der wichtige Unterschied ist hier:

%*

%* steht in Batch für alle übergebenen Parameter.

Wenn im Explorer mehrere Dateien markiert und über Senden an an die Batchdatei übergeben werden, sollen diese Werte an PowerShell weitergereicht werden.

Deshalb verwenden wir hier:

%*

und nicht:

"%~1"

"%~1" wäre für einen einzelnen Parameter sinnvoll.

%* steht dagegen für alle Parameter.

Wichtig:

%*
= alle Parameter weitergeben

"%*"
= alles zu einem einzigen Parameter zusammenfassen

Deshalb wird %* hier nicht zusätzlich komplett in Anführungszeichen gesetzt.

Warum klappt die Mehrfachübergabe mit ValueFromRemainingArguments?

In der Batchdatei werden alle Parameter mit %* weitergegeben.

In PowerShell sorgt dieser Teil dafür, dass sie zuverlässig gesammelt werden:

[Parameter(ValueFromRemainingArguments = $true)]
[string[]]$Elemente

Das bedeutet:

Alle übrigen übergebenen Argumente
werden in $Elemente gesammelt.

Dadurch kann $Elemente mehrere markierte Dateien oder Ordner enthalten.

SendTo-Verknüpfung einrichten

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

Den SendTo-Ordner öffnet man mit:

Windows-Taste + R
shell:sendto
Enter

In diesen Ordner legt man eine Verknüpfung zu:

003_sendto_dateiliste_erstellen_starter_batch.bat

Danach kann man im Explorer Dateien oder Ordner markieren und über:

Rechtsklick
Senden an
003_sendto_dateiliste_erstellen_starter_batch

die Dateiliste erstellen lassen.

Typische Fehler

PowerShell 7 wurde nicht gefunden

Wenn pwsh nicht gefunden wird, ist PowerShell 7 wahrscheinlich nicht installiert oder nicht im Systempfad verfügbar.

Prüfen kann man das in der Eingabeaufforderung mit:

pwsh --version

Die .ps1-Datei kann nicht gestartet werden

Wenn PowerShell-Skripte nicht gestartet werden können, kann das an der Execution Policy liegen.

Die Starter-Batchdatei verwendet deshalb:

-ExecutionPolicy Bypass

Das gilt nur für diesen Start.

Es wurde nichts übergeben

Wenn die SendTo-Starter-Batchdatei direkt per Doppelklick gestartet wird, werden keine Dateien oder Ordner übergeben.

Dann zeigt das Skript eine Meldung an:

Bitte markiere Dateien oder Ordner und sende sie an dieses Skript.

Es wird nur ein Eintrag angezeigt

Wenn nur ein Eintrag ausgegeben wird, kann das mehrere Ursachen haben.

Wenn nur ein Ordner markiert wurde und Variante 1 aktiv ist, ist das korrekt. Variante 1 gibt nur den Namen des markierten Elements aus.

Wenn mehrere Dateien markiert wurden, muss in der Batchdatei %* verwendet werden und im PowerShell-Skript:

[Parameter(ValueFromRemainingArguments = $true)]
[string[]]$Elemente

Dadurch werden mehrere übergebene Dateien zuverlässig in $Elemente gesammelt.

Mehrere Listenvarianten sind aktiv

Wenn mehrere Varianten gleichzeitig aktiv sind, wird $liste mehrfach gesetzt.

Dann gilt am Ende die letzte aktive Variante.

Deshalb:

Immer nur eine Listenvariante aktiv lassen.

Relative Pfade sehen mit .\ aus

Relative Pfade können so aussehen:

.\Bilder\bild01.png

Das ist korrekt.

Der Punkt bedeutet:

aktueller Ordner

Umlaute oder Sonderzeichen werden falsch angezeigt

Die Starter-Batchdatei setzt die Codepage auf UTF-8:

chcp 65001 >nul

Außerdem schreibt Set-Content mit:

-Encoding UTF8

Die Skriptdateien sollten ebenfalls als UTF-8 gespeichert werden.

Nützliche PowerShell-Begriffe aus diesem Teil

Was haben wir gelernt?

In diesem Teil wurden mehrere wichtige Grundlagen gezeigt:

Get-ChildItem -File listet Dateien im aktuellen Ordner auf.
Get-ChildItem liefert Dateiobjekte, nicht nur Text.
.Name liest den Dateinamen aus.
.FullName liest den vollständigen Pfad aus.
-Recurse bezieht Unterordner mit ein.
ForEach-Object verarbeitet jedes Objekt aus der Pipeline.
$_ steht für das aktuelle Pipeline-Objekt.
Resolve-Path -Relative berechnet relative Pfade.
Set-Content schreibt die Liste in eine Textdatei.
Set-Clipboard kopiert die Liste in die Zwischenablage.
param kann übergebene Werte entgegennehmen.
[string[]] steht für mehrere Textwerte.
ValueFromRemainingArguments sammelt mehrere SendTo-Argumente.
Test-Path prüft, ob ein Pfad existiert.
Get-Item macht aus einem Textpfad ein Datei- oder Ordnerobjekt.
PSIsContainer unterscheidet Ordner und Dateien.
%* gibt in Batch alle übergebenen Parameter weiter.

Damit haben wir in diesem Teil eine einfache Dateiliste und eine praktische SendTo-Variante erstellt.

Die einfache Variante ist gut zum Lernen.

Die SendTo-Variante ist praktisch für den Alltag, weil Dateien und Ordner direkt aus dem Explorer heraus an das Skript übergeben werden können.

Video zu diesem Tutorial:

Das könnte Dich auch interessieren

Keine Einträge gefunden