PowerShell 7 Grundkurs Teil 008: Text in Dateinamen ersetzen

Worum geht es in diesem Teil?

In diesem Teil des PowerShell-7-Grundkurses ersetzen oder entfernen wir Text in mehreren Dateinamen. Suchtext und Ersatztext geben wir beim Start ein. Die Skripte ermitteln daraus zunächst die neuen Namen und zeigen uns die geplanten Änderungen an.

Aus einer Datei wie:

MeinBeispiel.txt

wird mit dem Suchtext Mein und dem Ersatztext Dein beispielsweise:

DeinBeispiel.txt

Lassen wir den Ersatztext leer, wird der Suchtext entfernt. Aus MeinBeispiel.txt wird dann Beispiel.txt – sofern dieser Zielname noch frei ist.

Ersetzungsbeispiel

Wir verwenden zwei Varianten:

1. Text in den Dateinamen des aktuellen Ordners ersetzen oder entfernen.
2. Dateien und Ordner über das Windows-Menü Senden an übergeben und deren Dateinamen bearbeiten.

Zuerst sehen wir uns die Anwendung der einfachen Variante an und erklären anschließend den Code. Danach folgt die SendTo-Version mit der Übergabe mehrerer Pfade aus dem Windows-Explorer.

Was ist das Ziel?

Wiederkehrende Namensbestandteile lassen sich mit einem Durchlauf ändern, ohne jede Datei einzeln umzubenennen. Das eignet sich beispielsweise für Projektbezeichnungen, überflüssige Zusätze oder Schreibweisen, die vereinheitlicht werden sollen.

Beide Varianten unterstützen einen Testmodus, zeigen Quelle und Ziel vor der Ausführung an und ergänzen bei Namenskonflikten automatisch Zusätze wie _001 und _002. Die Dateien bleiben dabei in ihren jeweiligen Ordnern.

Warum ist dieser Teil wichtig?

In diesem Tutorial verbinden wir bekannte Grundlagen mit einer praktischen Texteingabe:

• Read-Host fragt Suchtext und Ersatztext ab.
• .Replace() ersetzt Text ohne Regex-Ersetzung.
• OrdinalIgnoreCase ermöglicht einen Vergleich ohne Beachtung der Groß- und Kleinschreibung.
• Get-ChildItem -File ermittelt direkt enthaltene Dateien.
• Get-FreierZielpfad sucht bei Konflikten einen freien Zielnamen.
• Test-Path prüft vorhandene Pfade; ein HashSet berücksichtigt zusätzlich bereits geplante Ziele.
• [PSCustomObject] speichert Quelle und Ziel einer Umbenennung.
• Rename-Item führt die bestätigten Änderungen aus.
• [string[]]$Pfade übernimmt bei SendTo mehrere übergebene Pfade.

Hinweis zur Kursreihe

Dieses Tutorial gehört zum PowerShell-7-Grundkurs. Der Aufbau orientiert sich an den entsprechenden Aufgaben im Batch- und Python-Grundkurs. So lassen sich die unterschiedlichen Schreibweisen und Möglichkeiten der Sprachen miteinander vergleichen.

Wir verwenden hier die übersichtliche Grundkurs-Version mit Bildschirmausgabe. Eine zusätzliche Logdatei oder Ausgabe in die Zwischenablage ist in diesen beiden Skripten nicht enthalten.

Downloads zu diesem Teil

C:\TOPTORIALS_CODE\010_PowerShell_7_Grundkurs

C:\TOPTORIALS_CODE\010_PowerShell_7_Grundkurs\008_Text_in_Dateinamen_ersetzen

Testumgebung zum Mitmachen

Verwende für die ersten Durchläufe ausschließlich Kopien unwichtiger Dateien. Du kannst dafür die bekannte Testumgebung der Kursreihe nutzen und die unten gezeigten Beispieldateien in einem eigenen Testordner anlegen.

C:\TOPTORIALS_CODE\1000_TESTBEREICH

Sicherheitshinweis

Voraussetzungen

• Eine Windows-Umgebung für die Starter-Batchdateien und das Menü Senden an.
• PowerShell 7, erreichbar über den Befehl pwsh.
• Ausreichende Rechte zum Umbenennen der Dateien.
• PowerShell-Skript und passende Starter-Batchdatei liegen jeweils gemeinsam in einem Ordner.

Enthaltene Ordner und Dateien

Die beiden Varianten liegen in diesen Kursordnern:

C:\TOPTORIALS_CODE\010_PowerShell_7_Grundkurs\008_Text_in_Dateinamen_ersetzen\01_Einfach

C:\TOPTORIALS_CODE\010_PowerShell_7_Grundkurs\008_Text_in_Dateinamen_ersetzen\02_SendTo_Text_ersetzen

Für die ersten Tests verwenden wir folgende Dateinamen:

Für den Echtmodus wird nur _test aus dem Namen des jeweiligen Starters entfernt. Die Namen der PowerShell-Dateien bleiben unverändert, da die Batchdateien diese Namen beim Aufruf verwenden.

Wie funktionieren Suche und Ersetzung?

Suchtext und Ersatztext eingeben

Beide Skripte stellen dieselben Fragen:

Alter Text / Suchtext:
Neuer Text / Ersatztext:

Ein leerer Suchtext bricht den Durchlauf ab. Ein leerer Ersatztext ist dagegen erlaubt: Drücke bei der zweiten Frage einfach Enter, um den gefundenen Text zu entfernen.

Leerzeichen werden bei diesen Eingaben nicht automatisch entfernt. Ein eingegebenes Leerzeichen ist deshalb etwas anderes als eine vollständig leere Eingabe.

Alle passenden Textstellen ersetzen

Die Ersetzung betrifft alle Vorkommen des Suchtextes im Dateinamen. Sie ist nicht auf den Anfang begrenzt und ignoriert Groß- und Kleinschreibung.

Die Beispiele setzen voraus, dass der gewünschte Zielname noch frei ist.

Keine Regex-Ersetzung

Die eigentliche Ersetzung verwendet die Zeichenkettenmethode .Replace(), nicht den PowerShell-Operator -replace. Der Suchtext ist daher kein regulärer Ausdruck. Ein Punkt wird beispielsweise als Punkt gesucht.

Auch Dollarzeichen im eingegebenen Ersatztext bleiben wörtlicher Text. Es gibt hier keine besonderen Ersatzanweisungen wie $1 oder $&. Ein regulärer Ausdruck wird lediglich für die kurze Prüfung auf unzulässige Zeichen im Ersatztext verwendet.

Was passiert bei einem leeren Basisnamen?

Zusätzlich prüft das Skript die Ersetzung im Basisnamen, also im Namen ohne die letzte Dateiendung. Wird dieser Basisname vollständig entfernt, verwendet es Unbenannt mit der ursprünglichen Dateiendung.

Beispiel: Bei Beispiel.txt, Suchtext Beispiel und leerem Ersatztext lautet der gewünschte Zielname:

Unbenannt.txt

Ist dieser Name bereits belegt, greift auch hier die automatische Nummerierung.

Welche Dateien werden ausgelassen?

Diese ursprünglichen Dateiendungen sind ausgeschlossen:

.bat, .cmd, .ps1, .py, .log

Dadurch werden unter anderem die Starter und die PowerShell-Skripte selbst nicht umbenannt. Die Prüfung unterscheidet nicht zwischen Groß- und Kleinschreibung.

Dateien, deren Name durch die Ersetzung exakt gleich bleibt, werden ebenfalls übersprungen. Ordnernamen bleiben unverändert. Weil -Recurse fehlt, werden tiefere Unterordner nicht durchsucht. Die Ordnerabfragen verwenden außerdem kein -Force; versteckte Dateien werden dabei nicht mit einbezogen.

Namenskonflikte und automatische Nummerierung

Der gewünschte Zielname kann schon vorhanden sein. In diesem Fall sucht Get-FreierZielpfad nach einem freien Namen mit einer Nummer vor der Dateiendung.

Beispiel: MeinBeispiel.txt und Beispiel.txt

Im Ordner liegen:

MeinBeispiel.txt
Beispiel.txt

Wir suchen Mein und lassen den Ersatztext leer. Da Beispiel.txt bereits existiert, erhält die umzubenennende Datei den nächsten freien Namen:

MeinBeispiel.txt → Beispiel_001.txt

Beispiel: _001 entfernen

Ist nur Beispiel_001.txt vorhanden und Beispiel.txt noch frei, kann der Zusatz entfernt werden:

Beispiel_001.txt → Beispiel.txt

Existiert Beispiel.txt bereits, ist das gewünschte Ziel belegt. Auch Beispiel_001.txt zählt bei der anschließenden Nummerierung als belegt – es ist noch die Quelldatei. Deshalb wird der nächste freie Name verwendet:

Beispiel_001.txt → Beispiel_002.txt

Bereits geplante Ziele berücksichtigen

Während der Planung werden noch keine Dateien umbenannt. Ein geplanter Zielname ist deshalb möglicherweise noch nicht im Dateisystem vorhanden. Das HashSet $reservierteZiele reserviert solche Ziele trotzdem, damit nicht zwei Pläne denselben vollständigen Zielpfad bekommen.

Die Planung erfolgt nach vollständigem Dateipfad sortiert. Bereits vorhandene Quellen gelten dabei weiterhin als belegt, auch wenn sie in demselben Durchlauf später einen anderen Namen erhalten sollen.

Testmodus und Echtmodus

Der Ablauf ist in beiden Varianten gleich:

1. Der Starter erkennt anhand seines Dateinamens, ob -Test übergeben werden soll.
2. Das PowerShell-Skript zeigt Testmodus: JA oder Testmodus: NEIN an.
3. Suchtext und Ersatztext werden abgefragt.
4. Die Dateien werden gesammelt und die Umbenennungen geplant.
5. Die vollständige Vorschau mit Quelle und Ziel erscheint.
6. Im Testmodus endet der Durchlauf ohne Umbenennung.
7. Im Echtmodus werden die gespeicherten Pläne erst nach der Bestätigung mit JA ausgeführt.

Beim erneuten Start für den Echtmodus werden die Eingaben erneut abgefragt und die Pläne neu erstellt. Kontrolliere daher auch diese Vorschau, bevor du bestätigst.

Variante 1: Text im aktuellen Ordner ersetzen

So wird die Variante angewendet

Kopiere das PowerShell-Skript und die passende Starter-Batchdatei aus 01_Einfach gemeinsam in den Ordner mit deinen Testdateien. Diese Variante bearbeitet beim Start über die Batchdatei den Ordner, in dem der Starter liegt.

Starte zuerst:

008_text_in_dateinamen_ersetzen_starter_batch_test.bat

Prüfe die Anzeige Testmodus: JA. Gib anschließend Suchtext und Ersatztext ein und kontrolliere die Vorschau.

Für den Echtlauf entfernst du _test aus dem Namen der Batchdatei. Starte sie erneut und bestätige die geplanten Änderungen nur dann mit JA, wenn sie richtig sind.

Vollständiges PowerShell-7-Skript

Dateiname: 008_Text_in_Dateinamen_ersetzen.ps1

#requires -Version 7.0
# ============================================================
# TOPTORIALS OFFICE - PowerShell 7 Grundkurs
# Teil: 008 - Text in Dateinamen ersetzen
# Script: 008_Text_in_Dateinamen_ersetzen.ps1
# Beschreibung:
# Ersetzt oder entfernt Text in den Dateinamen des aktuellen Ordners.
# Die Ersetzung berücksichtigt auch die Dateiendung.
# Autor: Chris
# YouTube: https://www.youtube.com/@TOPTORIALS-OFFICE
# Webseite: https://www.toptorials.com
# Version: Grundkurs 1.0
# Stand: 2026-08-30
#
# Hinweise:
# - Benötigt PowerShell 7.
# - Mit -Test werden die geplanten Umbenennungen nur angezeigt.
# - Ohne -Test erfolgt die Ausführung nach Bestätigung mit JA.
# - Ein leerer Ersatztext entfernt alle gefundenen Textstellen.
# - Die Suche ignoriert Groß- und Kleinschreibung.
# - Unterordner werden nicht durchsucht oder umbenannt.
# - .bat, .cmd, .ps1, .py und .log werden ausgeschlossen.
# - Alle Umbenennungen werden vor der Ausführung geplant.
# - Namenskonflikte erhalten Zusätze wie _001, _002 usw.
# - Zuerst mit Testdateien arbeiten und wichtige Daten sichern.
# - Die Nutzung erfolgt auf eigene Verantwortung.
# ============================================================

param(
    [switch]$Test
)

# 1. Suchtext und Ersatztext abfragen
Write-Host "Text in Dateinamen ersetzen"
Write-Host "Ersetzt wird auch in der Dateiendung. Ein leerer Ersatztext entfernt den Suchtext."
Write-Host
Write-Host "Testmodus: $(if ($Test) { 'JA' } else { 'NEIN' })"
Write-Host
$alterText = Read-Host "Alter Text / Suchtext"
if ([string]::IsNullOrEmpty($alterText)) {
    Write-Host "Kein Suchtext eingegeben. Abgebrochen."
    exit
}
$neuerText = Read-Host "Neuer Text / Ersatztext"

Write-Host

# Kurze Prüfung: Der Ersatz darf keine ungültigen Zeichen/Pfadtrenner enthalten.
if ($neuerText -match '[<>:"/\\|?*\x00-\x1F]') {
    Write-Host "Der Ersatztext enthält unzulässige Zeichen. Es wurde nichts geändert."
    exit 1
}

$vergleich = [System.StringComparison]::OrdinalIgnoreCase
$ausgeschlosseneEndungen = @(".bat", ".cmd", ".ps1", ".py", ".log")
$plaene = @()
$anzahlUmbenannt = 0
$anzahlUebersprungen = 0
$anzahlFehler = 0
$reservierteZiele = [System.Collections.Generic.HashSet[string]]::new(
    [System.StringComparer]::OrdinalIgnoreCase
)

# 2. Bei Namenskonflikten _001, _002 usw. ergänzen
function Get-FreierZielpfad {
    param(
        [string]$Ordner,
        [string]$Dateiname,
        [string]$Quellpfad
    )

    $basis = [System.IO.Path]::GetFileNameWithoutExtension($Dateiname)
    $endung = [System.IO.Path]::GetExtension($Dateiname)
    $zielname = $Dateiname
    $nummer = 0

    while ($true) {
        $zielpfad = Join-Path -Path $Ordner -ChildPath $zielname -ErrorAction Stop
        $eigeneDatei = ($nummer -eq 0) -and [string]::Equals($zielpfad, $Quellpfad, $vergleich)
        $vorhanden = Test-Path -LiteralPath $zielpfad -ErrorAction Stop

        if (($eigeneDatei -or -not $vorhanden) -and -not $reservierteZiele.Contains($zielpfad)) {
            [void]$reservierteZiele.Add($zielpfad)
            return $zielpfad
        }

        $nummer++
        $nummerText = "{0:D3}" -f $nummer
        $zielname = $basis + "_" + $nummerText + $endung
    }
}

# 3. Dateien im aktuellen Ordner erfassen (nicht rekursiv)
try {
    $basisOrdner = (Get-Location).ProviderPath
    Write-Host "Ordner: $basisOrdner"
    $dateien = @(Get-ChildItem -LiteralPath $basisOrdner -File -ErrorAction Stop)
}
catch {
    Write-Host "FEHLER beim Lesen des Ordners: $($_.Exception.Message)"
    exit 1
}

Write-Host

# 4. Umbenennungen planen, noch keine Datei verändern
foreach ($datei in ($dateien | Sort-Object -Property FullName)) {
    if ($ausgeschlosseneEndungen -contains $datei.Extension) {
        Write-Host "ÜBERSPRUNGEN: $($datei.Name) - ausgeschlossene Endung"
        $anzahlUebersprungen++
        continue
    }

    # Normaler Textvergleich, keine Regex-Ersetzung: Auch $ bleibt wörtlich.
    $neuerName = $datei.Name.Replace($alterText, $neuerText, $vergleich)
    $neueBasis = $datei.BaseName.Replace($alterText, $neuerText, $vergleich)
    if ([string]::IsNullOrEmpty($neueBasis)) {
        $neuerName = "Unbenannt" + $datei.Extension
    }

    if ($neuerName -ceq $datei.Name) {
        Write-Host "ÜBERSPRUNGEN: $($datei.Name) - keine Änderung"
        $anzahlUebersprungen++
        continue
    }
    if ([string]::IsNullOrWhiteSpace($neuerName) -or $neuerName.EndsWith(".") -or $neuerName.EndsWith(" ")) {
        Write-Host "FEHLER: Ungültiger Zielname für $($datei.Name)"
        $anzahlFehler++
        continue
    }

    try {
        $zielpfad = Get-FreierZielpfad -Ordner $datei.DirectoryName -Dateiname $neuerName -Quellpfad $datei.FullName        
        $plaene += [PSCustomObject]@{
            Quelle = $datei.FullName
            Ziel   = $zielpfad
        }
    }
    catch {
        Write-Host "FEHLER beim Planen: $($_.Exception.Message)"
        $anzahlFehler++
    }
}

# 5. Vorschau anzeigen - auch vor einer echten Ausführung
Write-Host

foreach ($plan in $plaene) {
    Write-Host "QUELLE: $($plan.Quelle)"
    Write-Host "ZIEL:   $($plan.Ziel)"
}

Write-Host

Write-Host "Geplante Umbenennungen: $($plaene.Count)"
Write-Host "Bisherige Fehler: $anzahlFehler"

# 6. Im Echtmodus bestätigen und genau die gespeicherten Pläne ausführen
if (-not $Test -and $plaene.Count -gt 0) {
    Write-Host "ACHTUNG: Diese Dateien werden wirklich umbenannt.`n"
    $antwort = Read-Host "Zum Fortfahren JA eingeben"
    if ($antwort.Trim() -ine "JA") {
        Write-Host "Abgebrochen. Es wurde nichts umbenannt."
        exit
    }

    foreach ($plan in $plaene) {
        try {
            $eigeneDatei = [string]::Equals($plan.Quelle, $plan.Ziel, $vergleich)
            if (-not $eigeneDatei -and (Test-Path -LiteralPath $plan.Ziel -ErrorAction Stop)) {
                throw "Das geplante Ziel ist inzwischen belegt."
            }
            $zielname = [System.IO.Path]::GetFileName($plan.Ziel)
            Rename-Item -LiteralPath $plan.Quelle -NewName $zielname -ErrorAction Stop
            Write-Host "UMBENANNT: $($plan.Quelle) -> $($plan.Ziel)"
            $anzahlUmbenannt++
        }
        catch {
            Write-Host "FEHLER bei '$($plan.Quelle)': $($_.Exception.Message)"
            $anzahlFehler++
        }
    }
}

# 7. Ergebnis zusammenfassen
Write-Host
if ($Test) {
    Write-Host "Es wurde nichts umbenannt. Für den Echtmodus _test aus dem Starternamen entfernen."
}
else {
    Write-Host "Tatsächlich umbenannt: $anzahlUmbenannt"
}
Write-Host "Übersprungen: $anzahlUebersprungen"
Write-Host "Fehler: $anzahlFehler"
if ($anzahlFehler -gt 0) {
    exit 1
}

So funktioniert die einfache Variante

1. Eingaben übernehmen

$alterText = Read-Host "Alter Text / Suchtext"
$neuerText = Read-Host "Neuer Text / Ersatztext"

Read-Host liefert die eingegebenen Texte. Die Prüfung mit [string]::IsNullOrEmpty($alterText) beendet das Skript bei einer leeren Suche. Der Ersatz darf leer bleiben.

2. Vergleich und Sammlungen vorbereiten

$vergleich = [System.StringComparison]::OrdinalIgnoreCase
$plaene = @()
$reservierteZiele = [System.Collections.Generic.HashSet[string]]::new(
    [System.StringComparer]::OrdinalIgnoreCase
)

$vergleich legt die Vergleichsart für die Textersetzung und die Pfadprüfung fest. Das HashSet erhält mit StringComparer ein passendes Vergleichsobjekt für seine Einträge. Beide ignorieren Groß- und Kleinschreibung, haben aber unterschiedliche Aufgaben und Datentypen.

$plaene nimmt die Umbenennungspläne auf. Das HashSet speichert die bereits reservierten Zielpfade.

3. Dateien erfassen

$basisOrdner = (Get-Location).ProviderPath
$dateien = @(Get-ChildItem -LiteralPath $basisOrdner -File -ErrorAction Stop)

Get-Location liefert den aktuellen Arbeitsordner. Die Starter-Batchdatei wechselt vorher in ihren eigenen Ordner. -File beschränkt die Abfrage auf Dateien; ohne -Recurse werden keine tieferen Ordner durchsucht.

Ein direkter Aufruf der PowerShell-Datei verwendet dagegen den aktuellen Arbeitsordner dieser PowerShell-Sitzung. Das muss nicht der Speicherort des Skripts sein.

4. Den neuen Dateinamen berechnen

$neuerName = $datei.Name.Replace($alterText, $neuerText, $vergleich)
$neueBasis = $datei.BaseName.Replace($alterText, $neuerText, $vergleich)

Name enthält den vollständigen Dateinamen einschließlich Endung. BaseName dient der zusätzlichen Prüfung auf einen leeren Basisnamen. Nur in diesem Sonderfall wird auf Unbenannt mit der ursprünglichen Endung zurückgegriffen.

Mit -ceq prüft das Skript anschließend, ob neuer und alter Dateiname auch hinsichtlich der Groß- und Kleinschreibung exakt gleich sind. Dadurch können reine Änderungen der Schreibweise, beispielsweise von bericht.txt zu Bericht.txt, weiterhin geplant werden.

5. Einen freien Zielpfad suchen

Die Funktion zerlegt den gewünschten Namen in Basis und Endung. Sie prüft zuerst den Namen ohne zusätzlichen Zähler und ergänzt bei Bedarf fortlaufende Nummern:

$nummer++
$nummerText = "{0:D3}" -f $nummer
$zielname = $basis + "_" + $nummerText + $endung

D3 steht für mindestens drei Ziffern mit führenden Nullen: 001, 002 und so weiter. Größere Zahlen werden nicht abgeschnitten.

Diese Zeile behandelt den eigenen Quellpfad nur beim ersten Kandidaten als Ausnahme:

$eigeneDatei = ($nummer -eq 0) -and [string]::Equals($zielpfad, $Quellpfad, $vergleich)

Solange noch keine Nummer angehängt wurde, kann dadurch eine reine Änderung der Groß- und Kleinschreibung zugelassen werden. Sobald die Nummerierung beginnt, gilt auch der eigene Quellname als belegt. Das verhindert den scheinbaren Erfolg mit identischer Quelle und identischem Ziel beim Entfernen von _001.

Die Funktion verwendet außerdem die zuvor angelegten Variablen $vergleich und $reservierteZiele aus dem umgebenden Skript.

6. Quelle und Ziel als Plan speichern

$plaene += [PSCustomObject]@{
    Quelle = $datei.FullName
    Ziel   = $zielpfad
}

Das Objekt speichert die beiden vollständigen Pfade. Die Datei selbst bleibt zunächst unverändert. Nach Abschluss der Planung wird jeder Plan angezeigt.

7. Bestätigen und umbenennen

Nur wenn der Testmodus ausgeschaltet ist und mindestens ein Plan existiert, fragt das Skript nach JA. Danach wird jeweils der Dateiname aus dem Zielpfad entnommen:

$zielname = [System.IO.Path]::GetFileName($plan.Ziel)
Rename-Item -LiteralPath $plan.Quelle -NewName $zielname -ErrorAction Stop

Rename-Item benennt die Quelle im selben Ordner um. Ein inzwischen belegtes anderes Ziel wird vor dem Aufruf als Fehler gemeldet; das Skript berechnet in diesem Schritt keinen neuen Ersatznamen.

try und catch fangen Fehler für die jeweilige Aktion ab. Der Schlussbericht unterscheidet tatsächlich umbenannte Dateien, übersprungene Dateien und Fehler. Einzelne Fehler machen bereits erfolgreiche Umbenennungen nicht rückgängig.

Starter-Batchdatei für Variante 1

Für den Testlauf speichern als 008_text_in_dateinamen_ersetzen_starter_batch_test.bat:

@echo off
REM ============================================================
REM TOPTORIALS OFFICE - PowerShell 7 Grundkurs
REM Teil: 008 - Text in Dateinamen ersetzen
REM Script: 008_text_in_dateinamen_ersetzen_starter_batch_test.bat
REM Beschreibung:
REM Startet das PowerShell-Skript zum Ersetzen oder Entfernen
REM von Text in Dateinamen im Ordner dieser Starter-Batchdatei.
REM Autor: Chris
REM YouTube: https://www.youtube.com/@TOPTORIALS-OFFICE
REM Webseite: https://www.toptorials.com
REM Version: Grundkurs 1.0
REM Stand: 2026-08-30
REM
REM Hinweise:
REM - Benoetigt PowerShell 7, erreichbar ueber den Befehl pwsh.
REM - Starter und PowerShell-Datei muessen im gleichen Ordner liegen.
REM - Solange _test im Starternamen steht, wird -Test uebergeben.
REM - Im Testmodus werden keine Dateien umbenannt.
REM - Fuer den Echtmodus _test aus dem Starternamen entfernen.
REM - Das PowerShell-Skript verlangt dann die Bestaetigung mit JA.
REM - pause haelt das Fenster nach der Ausfuehrung offen.
REM - Zuerst mit Testdateien arbeiten und wichtige Daten sichern.
REM - Die Nutzung erfolgt auf eigene Verantwortung.
REM ============================================================

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

echo("%~n0" | find /i "_test" >nul

if not errorlevel 1 (
    pwsh -NoProfile -ExecutionPolicy Bypass -File "008_Text_in_Dateinamen_ersetzen.ps1" -Test
) else (
    pwsh -NoProfile -ExecutionPolicy Bypass -File "008_Text_in_Dateinamen_ersetzen.ps1"
)

pause

So funktioniert der Starter

chcp 65001 >nul stellt die Konsolen-Codepage auf UTF-8 um und unterdrückt die Statusausgabe dieses Befehls. cd /d "%~dp0" wechselt zu Laufwerk und Ordner der Batchdatei.

echo("%~n0" | find /i "_test" >nul

%~n0 liefert den tatsächlichen Namen der Batchdatei ohne Pfad und Endung. find /i sucht darin ohne Beachtung der Groß- und Kleinschreibung nach _test. Bei einem Treffer wird der erste Aufruf mit -Test ausgeführt.

pwsh startet PowerShell 7, -NoProfile lässt persönliche PowerShell-Profildateien beim Start weg und -File benennt das auszuführende Skript. -ExecutionPolicy Bypass betrifft die Ausführungsrichtlinie dieser gestarteten Sitzung; es erteilt keine zusätzlichen Datei- oder Administratorrechte. pause hält das Fenster nach dem Skriptlauf offen.

Variante 2: Text über „Senden an“ ersetzen

SendTo-Verknüpfung einrichten

Bei dieser Variante bleiben das PowerShell-Skript und der Starter gemeinsam in ihrem Kursordner:

C:\TOPTORIALS_CODE\010_PowerShell_7_Grundkurs\008_Text_in_Dateinamen_ersetzen\02_SendTo_Text_ersetzen

1. Prüfe, dass die Starter-Batchdatei für den Probelauf 008_sendto_text_in_dateinamen_ersetzen_starter_batch_test.bat heißt.
2. Öffne mit Windows + R den Dialog Ausführen.
3. Gib shell:sendto ein und bestätige mit Enter.
4. Lege dort eine Verknüpfung zur Starter-Batchdatei an.
5. Nenne die Verknüpfung beispielsweise Text in Dateinamen ersetzen - TEST.

So wird die Variante angewendet

Markiere im Windows-Explorer einzelne Dateien, mehrere Ordner oder eine Mischung daraus. Wähle über das Kontextmenü Senden an → Text in Dateinamen ersetzen – TEST.

Eine direkt übergebene Datei wird einzeln berücksichtigt. Bei einem übergebenen Ordner werden die direkt enthaltenen Dateien erfasst. Die Ordnernamen selbst und tiefere Unterordner bleiben unverändert.

Gib Suchtext und Ersatztext ein und kontrolliere die Vorschau. Wenn eine Datei sowohl direkt als auch über ihren Ordner erfasst wurde, wird sie nur einmal geplant.

Vollständiges PowerShell-7-Skript

Dateiname: 008_SendTo_Text_in_Dateinamen_ersetzen.ps1

#requires -Version 7.0
# ============================================================
# TOPTORIALS OFFICE - PowerShell 7 Grundkurs
# Teil: 008 - Text in Dateinamen ersetzen
# Script: 008_SendTo_Text_in_Dateinamen_ersetzen.ps1
# Beschreibung:
# Ersetzt oder entfernt Text in den Dateinamen übergebener Dateien
# sowie in den Dateinamen direkt enthaltener Dateien übergebener Ordner.
# Die Ersetzung berücksichtigt auch die Dateiendung.
# Autor: Chris
# YouTube: https://www.youtube.com/@TOPTORIALS-OFFICE
# Webseite: https://www.toptorials.com
# Version: Grundkurs 1.0
# Stand: 2026-08-30
#
# Hinweise:
# - Benötigt PowerShell 7.
# - Dateien und Ordner werden über "Senden an" übergeben.
# - Mit -Test werden die geplanten Umbenennungen nur angezeigt.
# - Ohne -Test erfolgt die Ausführung nach Bestätigung mit JA.
# - Ein leerer Ersatztext entfernt alle gefundenen Textstellen.
# - Die Suche ignoriert Groß- und Kleinschreibung.
# - Ordnernamen bleiben unverändert; keine rekursive Verarbeitung.
# - .bat, .cmd, .ps1, .py und .log werden ausgeschlossen.
# - Doppelt erfasste Dateipfade werden nur einmal verarbeitet.
# - Alle Umbenennungen werden vor der Ausführung geplant.
# - Namenskonflikte erhalten Zusätze wie _001, _002 usw.
# - Zuerst mit Testdateien arbeiten und wichtige Daten sichern.
# - Die Nutzung erfolgt auf eigene Verantwortung.
# ============================================================

param(
    [switch]$Test,
    [Parameter(ValueFromRemainingArguments = $true)]
    [string[]]$Pfade
)

if (-not $Pfade) {
    Write-Host "Bitte Dateien oder Ordner über 'Senden an' übergeben."
    exit 1
}

# 1. Suchtext und Ersatztext abfragen
Write-Host "Text in Dateinamen ersetzen"
Write-Host "Ersetzt wird auch in der Dateiendung. Ein leerer Ersatztext entfernt den Suchtext."
Write-Host
Write-Host "Testmodus: $(if ($Test) { 'JA' } else { 'NEIN' })"
Write-Host

$alterText = Read-Host "Alter Text / Suchtext"
if ([string]::IsNullOrEmpty($alterText)) {
    Write-Host "Kein Suchtext eingegeben. Abgebrochen."
    exit
}
$neuerText = Read-Host "Neuer Text / Ersatztext"

Write-Host

# Kurze Prüfung: Der Ersatz darf keine ungültigen Zeichen/Pfadtrenner enthalten.
if ($neuerText -match '[<>:"/\\|?*\x00-\x1F]') {
    Write-Host "Der Ersatztext enthält unzulässige Zeichen. Es wurde nichts geändert."
    exit 1
}

$vergleich = [System.StringComparison]::OrdinalIgnoreCase
$ausgeschlosseneEndungen = @(".bat", ".cmd", ".ps1", ".py", ".log")
$plaene = @()
$anzahlUmbenannt = 0
$anzahlUebersprungen = 0
$anzahlFehler = 0
$reservierteZiele = [System.Collections.Generic.HashSet[string]]::new(
    [System.StringComparer]::OrdinalIgnoreCase
)

# 2. Bei Namenskonflikten _001, _002 usw. ergänzen
function Get-FreierZielpfad {
    param(
        [string]$Ordner,
        [string]$Dateiname,
        [string]$Quellpfad
    )

    $basis = [System.IO.Path]::GetFileNameWithoutExtension($Dateiname)
    $endung = [System.IO.Path]::GetExtension($Dateiname)
    $zielname = $Dateiname
    $nummer = 0

    while ($true) {
        $zielpfad = Join-Path -Path $Ordner -ChildPath $zielname -ErrorAction Stop
        $eigeneDatei = ($nummer -eq 0) -and [string]::Equals($zielpfad, $Quellpfad, $vergleich)
        $vorhanden = Test-Path -LiteralPath $zielpfad -ErrorAction Stop

        if (($eigeneDatei -or -not $vorhanden) -and -not $reservierteZiele.Contains($zielpfad)) {
            [void]$reservierteZiele.Add($zielpfad)
            return $zielpfad
        }

        $nummer++
        $nummerText = "{0:D3}" -f $nummer
        $zielname = $basis + "_" + $nummerText + $endung
    }
}

# 3. Alle übergebenen Dateien und direkten Ordnerinhalte zuerst sammeln
$dateien = @()
foreach ($pfad in $Pfade) {
    try {
        $element = Get-Item -LiteralPath $pfad -ErrorAction Stop
        if ($element.PSIsContainer) {
            $dateien += @(Get-ChildItem -LiteralPath $element.FullName -File -ErrorAction Stop)
        }
        else {
            $dateien += $element
        }
    }
    catch {
        Write-Host "FEHLER bei '$pfad': $($_.Exception.Message)"
        $anzahlFehler++
    }
}

$bereitsErfassteDateien = [System.Collections.Generic.HashSet[string]]::new(
    [System.StringComparer]::OrdinalIgnoreCase
)

# 4. Umbenennungen planen, noch keine Datei verändern
foreach ($datei in ($dateien | Sort-Object -Property FullName)) {
    # Eine einzeln und über ihren Ordner erfasste Datei nur einmal bearbeiten.
    if (-not $bereitsErfassteDateien.Add($datei.FullName)) {
        continue
    }

    if ($ausgeschlosseneEndungen -contains $datei.Extension) {
        Write-Host "ÜBERSPRUNGEN: $($datei.Name) - ausgeschlossene Endung"
        $anzahlUebersprungen++
        continue
    }

    # Normaler Textvergleich, keine Regex-Ersetzung: Auch $ bleibt wörtlich.
    $neuerName = $datei.Name.Replace($alterText, $neuerText, $vergleich)
    $neueBasis = $datei.BaseName.Replace($alterText, $neuerText, $vergleich)
    if ([string]::IsNullOrEmpty($neueBasis)) {
        $neuerName = "Unbenannt" + $datei.Extension
    }

    if ($neuerName -ceq $datei.Name) {
        Write-Host "ÜBERSPRUNGEN: $($datei.Name) - keine Änderung"
        $anzahlUebersprungen++
        continue
    }
    if ([string]::IsNullOrWhiteSpace($neuerName) -or $neuerName.EndsWith(".") -or $neuerName.EndsWith(" ")) {
        Write-Host "FEHLER: Ungültiger Zielname für $($datei.Name)"
        $anzahlFehler++
        continue
    }

    try {
        $zielpfad = Get-FreierZielpfad -Ordner $datei.DirectoryName -Dateiname $neuerName -Quellpfad $datei.FullName
        $plaene += [PSCustomObject]@{
            Quelle = $datei.FullName
            Ziel   = $zielpfad
        }
    }
    catch {
        Write-Host "FEHLER beim Planen: $($_.Exception.Message)"
        $anzahlFehler++
    }
}

# 5. Vorschau anzeigen - auch vor einer echten Ausführung
Write-Host
foreach ($plan in $plaene) {
    Write-Host "QUELLE: $($plan.Quelle)"
    Write-Host "ZIEL:   $($plan.Ziel)"
}
Write-Host
Write-Host "Geplante Umbenennungen: $($plaene.Count)"
Write-Host "Bisherige Fehler: $anzahlFehler"

# 6. Im Echtmodus bestätigen und genau die gespeicherten Pläne ausführen
if (-not $Test -and $plaene.Count -gt 0) {
    Write-Host "ACHTUNG: Diese Dateien werden wirklich umbenannt."
    $antwort = Read-Host "Zum Fortfahren JA eingeben"
    if ($antwort.Trim() -ine "JA") {
        Write-Host "Abgebrochen. Es wurde nichts umbenannt."
        exit
    }

    foreach ($plan in $plaene) {
        try {
            $eigeneDatei = [string]::Equals($plan.Quelle, $plan.Ziel, $vergleich)
            if (-not $eigeneDatei -and (Test-Path -LiteralPath $plan.Ziel -ErrorAction Stop)) {
                throw "Das geplante Ziel ist inzwischen belegt."
            }
            $zielname = [System.IO.Path]::GetFileName($plan.Ziel)
            Rename-Item -LiteralPath $plan.Quelle -NewName $zielname -ErrorAction Stop
            Write-Host "UMBENANNT: $($plan.Quelle) -> $($plan.Ziel)"
            $anzahlUmbenannt++
        }
        catch {
            Write-Host "FEHLER bei '$($plan.Quelle)': $($_.Exception.Message)"
            $anzahlFehler++
        }
    }
}

# 7. Ergebnis zusammenfassen

Write-Host

if ($Test) {
    Write-Host "Es wurde nichts umbenannt. Für den Echtmodus _test aus dem Starternamen entfernen."
}
else {
    Write-Host "Tatsächlich umbenannt: $anzahlUmbenannt"
}

Write-Host "Übersprungen: $anzahlUebersprungen"
Write-Host "Fehler: $anzahlFehler"

if ($anzahlFehler -gt 0) {
    exit 1
}

So funktioniert die SendTo-Variante

Mehrere Pfade entgegennehmen

param(
    [switch]$Test,
    [Parameter(ValueFromRemainingArguments = $true)]
    [string[]]$Pfade
)

[string[]] kennzeichnet ein Array von Zeichenketten. ValueFromRemainingArguments sammelt die übrigen, noch nicht zugeordneten Argumente in diesem Parameter. Damit kann das Skript mehrere übergebene Datei- und Ordnerpfade verarbeiten.

Wenn keine Pfade übergeben wurden, erscheint ein Hinweis zur Verwendung von Senden an, und das Skript wird beendet.

Dateien und Ordner unterscheiden

$element = Get-Item -LiteralPath $pfad -ErrorAction Stop
if ($element.PSIsContainer) {
    $dateien += @(Get-ChildItem -LiteralPath $element.FullName -File -ErrorAction Stop)
}
else {
    $dateien += $element
}

Get-Item liest das übergebene Element ein. PSIsContainer kennzeichnet hier einen Ordner. Bei einem Ordner werden dessen direkte Dateien hinzugefügt, ansonsten das einzelne Element.

Das Skript sammelt zuerst alle Dateien. Erst danach beginnt die gemeinsame Planung. Für den Zielpfad wird immer $datei.DirectoryName, also der Ordner der jeweiligen Datei, verwendet.

Doppelte Erfassung verhindern

if (-not $bereitsErfassteDateien.Add($datei.FullName)) {
    continue
}

.Add() liefert beim ersten Eintrag $true. Ist ein gleichwertiger Pfad schon enthalten, liefert die Methode $false, und die Schleife fährt mit dem nächsten Eintrag fort.

Das HashSet $bereitsErfassteDateien verhindert doppelte Quelldateien. Das zweite HashSet $reservierteZiele verhindert dagegen doppelte geplante Zielpfade. Die beiden Sammlungen erfüllen also unterschiedliche Aufgaben.

Textersetzung, Namenskonflikte, Vorschau, Sicherheitsabfrage und Umbenennung funktionieren anschließend genauso wie in der einfachen Variante.

Starter-Batchdatei für Variante 2

Für den Testlauf speichern als 008_sendto_text_in_dateinamen_ersetzen_starter_batch_test.bat:

@echo off
REM ============================================================
REM TOPTORIALS OFFICE - PowerShell 7 Grundkurs
REM Teil: 008 - Text in Dateinamen ersetzen
REM Script: 008_sendto_text_in_dateinamen_ersetzen_starter_batch_test.bat
REM Beschreibung:
REM Startet die SendTo-Variante zum Ersetzen oder Entfernen von
REM Text in Dateinamen und reicht die uebergebenen Pfade weiter.
REM Autor: Chris
REM YouTube: https://www.youtube.com/@TOPTORIALS-OFFICE
REM Webseite: https://www.toptorials.com
REM Version: Grundkurs 1.0
REM Stand: 2026-08-30
REM
REM Hinweise:
REM - Benoetigt PowerShell 7, erreichbar ueber den Befehl pwsh.
REM - Starter und PowerShell-Datei muessen im gleichen Ordner liegen.
REM - Eine Verknuepfung zu diesem Starter in "Senden an" ablegen.
REM - Dateien und Ordner im Explorer markieren und dorthin senden.
REM - Solange _test im Starternamen steht, wird -Test uebergeben.
REM - Der Anzeigename der Verknuepfung steuert den Testmodus nicht.
REM - Fuer den Echtmodus _test aus dem Starternamen entfernen.
REM - Die SendTo-Verknuepfung danach gegebenenfalls aktualisieren.
REM - Das PowerShell-Skript verlangt dann die Bestaetigung mit JA.
REM - pause haelt das Fenster nach der Ausfuehrung offen.
REM - Zuerst mit Testdateien arbeiten und wichtige Daten sichern.
REM - Die Nutzung erfolgt auf eigene Verantwortung.
REM ============================================================

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

echo("%~n0" | find /i "_test" >nul

if not errorlevel 1 (
    pwsh -NoProfile -ExecutionPolicy Bypass -File "008_SendTo_Text_in_Dateinamen_ersetzen.ps1" -Test %*
) else (
    pwsh -NoProfile -ExecutionPolicy Bypass -File "008_SendTo_Text_in_Dateinamen_ersetzen.ps1" %*
)

pause

Der zusätzliche Ausdruck %* reicht die an den Starter übergebenen Argumente an PowerShell weiter. Im Testzweig wird außerdem -Test angehängt. Die übergebenen Pfade landen anschließend in $Pfade.

Typische Meldungen

Vorschau einer geplanten Umbenennung

QUELLE: C:\Test\MeinBeispiel.txt
ZIEL:   C:\Test\Beispiel_001.txt

Diese Vorschau erscheint sowohl im Testmodus als auch vor der Bestätigung im Echtmodus. In diesem Beispiel ist Beispiel.txt bereits belegt.

Datei wurde umbenannt

UMBENANNT: C:\Test\MeinBeispiel.txt -> C:\Test\Beispiel_001.txt

Dateiname bleibt unverändert

ÜBERSPRUNGEN: Beispiel.txt - keine Änderung

Dateiendung ist ausgeschlossen

ÜBERSPRUNGEN: Hilfsskript.ps1 - ausgeschlossene Endung

Leerer Suchtext

Kein Suchtext eingegeben. Abgebrochen.

Unzulässige Zeichen im Ersatztext

Der Ersatztext enthält unzulässige Zeichen. Es wurde nichts geändert.

Typische Fehler und mögliche Ursachen

PowerShell 7 wurde nicht gefunden

Die Starter verwenden pwsh. Ist PowerShell 7 nicht installiert oder nicht über PATH erreichbar, kann der Aufruf nicht funktionieren. powershell.exe ist kein gleichwertiger Ersatz für dieses PowerShell-7-Skript.

Das PowerShell-Skript wird nicht gefunden

Prüfe den gemeinsamen Speicherort von Starter und PowerShell-Datei sowie den genauen Dateinamen im -File-Aufruf. Zusätze wie (1) oder (2), die beim Herunterladen entstehen können, gehören nicht zu den vorgesehenen Skriptnamen.

Der Starter zeigt Testmodus: NEIN

Im tatsächlichen Namen der Batchdatei fehlt _test. Beende den Durchlauf und ergänze den Zusatz für einen Testlauf. Eine Kommentarzeile oder der Name einer SendTo-Verknüpfung genügt dafür nicht.

Nach dem Entfernen von _001 erscheint _002

Der Name ohne Nummer ist bereits belegt. Der bisherige Quellname mit _001 ist während der Planung ebenfalls noch vorhanden. Deshalb sucht die Funktion weiter. Dieses Verhalten verhindert, dass dieselbe Datei scheinbar auf ihren unveränderten Namen umbenannt wird.

Es werden weniger Dateien bearbeitet als erwartet

Prüfe die ausgeschlossenen Endungen und die Lage der Dateien. Unterordner werden nicht rekursiv durchsucht, und versteckte Dateien fehlen in der Ordnerabfrage ohne -Force. Ein Dateiname ohne passende Änderung wird übersprungen. Doppelte SendTo-Erfassungen werden nur einmal verarbeitet.

Ein Zielname ist ungültig

Der Ersatztext darf keine der geprüften unzulässigen Zeichen enthalten, beispielsweise \, /, :, * oder ?. Auch ein leerer beziehungsweise ausschließlich aus Leerzeichen bestehender Zielname sowie ein abschließender Punkt oder ein abschließendes Leerzeichen werden zurückgewiesen.

Diese Grundkurs-Version bildet nicht sämtliche Windows-Namensregeln vorab ab. Weitere Einschränkungen, etwa reservierte Gerätenamen oder zu lange Pfade, können erst bei der tatsächlichen Umbenennung zu einem Fehler führen. Eine Testvorschau ist deshalb keine Garantie für die spätere Ausführung.

Eine Datei kann nicht umbenannt werden

Mögliche Ursachen sind fehlende Rechte, eine Dateisperre durch ein anderes Programm oder ein inzwischen belegter Zielpfad. Das Skript meldet den Fehler und verarbeitet anschließend die weiteren Pläne. Bereits erfolgte Umbenennungen bleiben bestehen.

Wichtige PowerShell-Begriffe aus diesem Tutorial

Read-Host

Liest eine Benutzereingabe als Text ein.

[switch]$Test

Definiert einen Schalter, der beim Aufruf mit -Test aktiviert wird.

.Replace()

Ersetzt hier alle Vorkommen eines wörtlichen Suchtextes durch den Ersatztext.

OrdinalIgnoreCase

Ermöglicht einen sprachunabhängigen Vergleich ohne Beachtung der Groß- und Kleinschreibung. Der gespeicherte Text wird dadurch nicht automatisch umgeschrieben.

Name, BaseName und Extension

Liefern den vollständigen Dateinamen, den Basisnamen ohne letzte Endung und die Endung einschließlich Punkt.

-contains

Prüft hier, ob die ursprüngliche Dateiendung in der Ausschlussliste vorkommt.

-ceq

Vergleicht Texte unter Beachtung der Groß- und Kleinschreibung.

continue

Überspringt den restlichen Schleifendurchlauf und fährt mit dem nächsten Element fort.

Join-Path

Verbindet einen Ordnerpfad mit dem gewünschten Dateinamen.

Test-Path -LiteralPath

Prüft die Existenz eines wörtlich behandelten Pfades, ohne Pfadzeichen als Platzhalter auszuwerten.

HashSet[string]

Speichert eindeutige Zeichenketten. Hier werden damit Quellen dedupliziert oder Ziele reserviert.

[void]

Unterdrückt einen Rückgabewert. Beim Reservieren muss das Ergebnis von .Add() nicht ausgegeben werden.

"{0:D3}" -f $nummer

Formatiert eine ganze Zahl mit mindestens drei Ziffern und führenden Nullen.

[PSCustomObject]

Erstellt ein Objekt mit selbst festgelegten Eigenschaften, hier Quelle und Ziel.

Sort-Object -Property FullName

Sortiert die erfassten Dateien nach ihrem vollständigen Pfad vor der Planung.

try, catch und -ErrorAction Stop

Ermöglichen die kontrollierte Behandlung von Fehlern bei den betreffenden Befehlen.

Rename-Item

Führt die eigentliche Umbenennung aus.

ValueFromRemainingArguments

Ordnet die übrigen Argumente dem entsprechend markierten Parameter zu.

[string[]]

Kennzeichnet ein Array aus Zeichenketten, hier für mehrere Pfade.

PSIsContainer

Zeigt bei den eingelesenen Dateisystemelementen an, ob es sich um einen Ordner handelt.

Wichtige Batch-Begriffe aus diesem Tutorial

%~dp0

Liefert Laufwerk und Ordner der ausgeführten Batchdatei.

cd /d

Wechselt den aktuellen Ordner und bei Bedarf auch das Laufwerk.

%~n0

Liefert den Dateinamen der Batchdatei ohne Pfad und Dateiendung.

find /i

Sucht ohne Beachtung der Groß- und Kleinschreibung nach einem Text.

if not errorlevel 1

Prüft hier nach find, ob die Suche erfolgreich war und damit _test gefunden wurde.

%*

Reicht die Argumente des Starters an den PowerShell-Aufruf weiter.

pause

Wartet auf einen Tastendruck, damit die Ausgabe nach dem Skriptlauf gelesen werden kann.

Was haben wir in diesem Teil gelernt?

Mit Read-Host fragen wir Suchtext und Ersatztext ab. .Replace() ersetzt die gefundenen Stellen im Dateinamen ohne Regex-Ersetzung und ohne Beachtung der Groß- und Kleinschreibung.

Ein leerer Ersatztext entfernt die Treffer. Wird dabei der Basisname vollständig entfernt, verwenden die Skripte Unbenannt mit der ursprünglichen Endung. Die normale Ersetzung kann dagegen auch die Dateiendung verändern.

Get-FreierZielpfad sucht bei Namenskonflikten einen freien Namen mit _001, _002 und weiteren Nummern. Ein HashSet reserviert zusätzlich die Ziele, die im selben Durchlauf bereits geplant wurden.

Die einfache Variante arbeitet beim Start über ihre Batchdatei im Ordner des Starters. Die SendTo-Variante übernimmt Dateien und Ordner aus dem Windows-Explorer und verhindert doppelte Erfassungen.

Beide Varianten arbeiten nicht rekursiv und lassen die festgelegten Skript- und Protokollendungen aus. Zuerst werden alle Änderungen geplant und angezeigt. Im Testmodus bleibt es bei dieser Vorschau; im Echtmodus führt Rename-Item die gespeicherten Pläne nach der Bestätigung mit JA aus.

Video zu diesem Tutorial:

Das könnte Dich auch interessieren

Keine Einträge gefunden