So finden Sie doppelte Zeilen
in einer Textdatei mit Windows-Bordmitteln

So prüfen Sie eine Textdatei unter Windows auf doppelte Zeilen

Die einfachste wiederverwendbare Methode ist das BAT-Skript aus Methode 1. Ziehen Sie eine TXT-Datei darauf, um sowohl einen Duplikatbericht als auch eine bereinigte Kopie ohne wiederholte Zeilen zu erstellen. Die Originaldatei wird nicht verändert. Für eine schnelle Prüfung ausschließlich in der Konsole verwenden Sie den folgenden PowerShell-Befehl:

Get-Content -LiteralPath ".\input.txt" -Encoding UTF8 |
Group-Object -CaseSensitive |
Where-Object Count -gt 1 |
Sort-Object Count -Descending |
Select-Object Count, Name

Ersetzen Sie input.txt durch den tatsächlichen Dateinamen. Dieser Befehl meldet nur Duplikate; er erstellt keine bereinigte Datei. Die Option -Encoding UTF8 ist in Windows PowerShell 5.1 wichtig, da eine UTF-8-Datei ohne Byte Order Mark andernfalls möglicherweise mit der Windows-ANSI-Codepage decodiert wird.

Was gilt in einer Windows-Textdatei als doppelte Zeile?

Eine doppelte Zeile ist eine Zeile, deren Vergleichswert in derselben Datei mehr als einmal vorkommt. Das Ergebnis hängt jedoch von den gewählten Vergleichsregeln ab.

Verwenden Sie für eine strikte Prüfung einen Vergleich unter Beachtung der Groß-/Kleinschreibung und entfernen Sie keine Leerzeichen. Bei Listen mit Namen, URLs, Domains oder Kennungen kann es sinnvoll sein, die Groß-/Kleinschreibung sowie versehentliche Leerzeichen am Anfang oder Ende einer Zeile zu ignorieren.

Doppelte Zeilen finden und mit einem BAT-Skript eine bereinigte Datei erstellen

Verwenden Sie für wiederholte Prüfungen find_duplicate_lines.bat als BAT-Skript. Ziehen Sie eine Textdatei darauf oder geben Sie den vollständigen Pfad ein. Das Skript erstellt im selben Ordner zwei UTF-8-Dateien:

• filename_duplicates.txt — ein Bericht mit jeder wiederholten Zeile und ihrer Gesamtanzahl.
• filename_without_duplicates.txt — eine bereinigte Kopie, in der nur das erste Vorkommen jeder Zeile erhalten bleibt.

find_duplicate_lines.bat erstellen

1. Öffnen Sie den Editor.
2. Kopieren Sie das unten vollständig angezeigte Skript.
3. Wählen Sie Datei → Speichern unter.
4. Geben Sie find_duplicate_lines.bat in das Feld für den Dateinamen ein.
5. Wählen Sie Alle Dateien als Dateityp aus und speichern Sie die BAT-Datei.

@echo off
setlocal EnableExtensions DisableDelayedExpansion
title Find and Remove Duplicate Lines in a Text File

set "INPUT_FILE=%~1"

if not defined INPUT_FILE (
  echo Drag a text file onto this BAT file, or enter its full path below.
  echo.
  set /p "INPUT_FILE=Text file path: "
)

if not defined INPUT_FILE (
  echo.
  echo No file was selected.
  pause
  exit /b 1
)

for %%I in ("%INPUT_FILE%") do set "INPUT_FILE=%%~fI"

if not exist "%INPUT_FILE%" (
  echo.
  echo File not found:
  echo %INPUT_FILE%
  pause
  exit /b 1
)

for %%I in ("%INPUT_FILE%") do (
  set "DUPLICATE_FILE=%%~dpnI_duplicates.txt"
  set "CLEAN_FILE=%%~dpnI_without_duplicates.txt"
)

echo.
echo Processing:
echo %INPUT_FILE%
echo.

set "FD_SCRIPT_FILE=%~f0"
set "FD_INPUT_FILE=%INPUT_FILE%"
set "FD_DUPLICATE_FILE=%DUPLICATE_FILE%"
set "FD_CLEAN_FILE=%CLEAN_FILE%"

powershell.exe -NoProfile -ExecutionPolicy Bypass -Command "$content=[IO.File]::ReadAllText($env:FD_SCRIPT_FILE); $marker=':'+'POWERSHELL'; $code=$content.Substring($content.IndexOf($marker)+$marker.Length); & ([ScriptBlock]::Create($code)) -Path $env:FD_INPUT_FILE -DuplicatePath $env:FD_DUPLICATE_FILE -CleanPath $env:FD_CLEAN_FILE"

set "RESULT=%ERRORLEVEL%"
echo.

if "%RESULT%"=="0" (
  echo Finished. Two files were created:
  echo Duplicate report:
  echo %DUPLICATE_FILE%
  echo.
  echo File without duplicate lines:
  echo %CLEAN_FILE%
) else if "%RESULT%"=="2" (
  echo Finished. No exact duplicate lines were found.
  echo The cleaned copy was still created:
  echo %CLEAN_FILE%
) else (
  echo The file could not be processed.
)

echo.
pause
exit /b %RESULT%

:POWERSHELL
param(
    [Parameter(Mandatory = $true)]
    [string]$Path,

    [Parameter(Mandatory = $true)]
    [string]$DuplicatePath,

    [Parameter(Mandatory = $true)]
    [string]$CleanPath
)

$ErrorActionPreference = 'Stop'

function Get-TextEncodingInfo {
    param([string]$FilePath)

    $stream = [System.IO.File]::OpenRead($FilePath)

    try {
        $bom = New-Object byte[] 4
        $read = $stream.Read($bom, 0, 4)
    }
    finally {
        $stream.Dispose()
    }

    if ($read -ge 4 -and
        $bom[0] -eq 0x00 -and $bom[1] -eq 0x00 -and
        $bom[2] -eq 0xFE -and $bom[3] -eq 0xFF) {
        return [PSCustomObject]@{
            Encoding = [System.Text.Encoding]::GetEncoding(12001)
            AllowAnsiFallback = $false
        }
    }

    if ($read -ge 4 -and
        $bom[0] -eq 0xFF -and $bom[1] -eq 0xFE -and
        $bom[2] -eq 0x00 -and $bom[3] -eq 0x00) {
        return [PSCustomObject]@{
            Encoding = [System.Text.Encoding]::UTF32
            AllowAnsiFallback = $false
        }
    }

    if ($read -ge 3 -and
        $bom[0] -eq 0xEF -and $bom[1] -eq 0xBB -and
        $bom[2] -eq 0xBF) {
        return [PSCustomObject]@{
            Encoding = New-Object System.Text.UTF8Encoding($true)
            AllowAnsiFallback = $false
        }
    }

    if ($read -ge 2 -and $bom[0] -eq 0xFF -and $bom[1] -eq 0xFE) {
        return [PSCustomObject]@{
            Encoding = [System.Text.Encoding]::Unicode
            AllowAnsiFallback = $false
        }
    }

    if ($read -ge 2 -and $bom[0] -eq 0xFE -and $bom[1] -eq 0xFF) {
        return [PSCustomObject]@{
            Encoding = [System.Text.Encoding]::BigEndianUnicode
            AllowAnsiFallback = $false
        }
    }

    return [PSCustomObject]@{
        Encoding = New-Object System.Text.UTF8Encoding($false, $true)
        AllowAnsiFallback = $true
    }
}

function Read-And-CleanTextFile {
    param(
        [string]$FilePath,
        [System.Text.Encoding]$Encoding,
        [string]$TemporaryCleanPath
    )

    $comparer = [System.StringComparer]::Ordinal
    $counts = New-Object 'System.Collections.Generic.Dictionary[string,int]' ($comparer)
    $seen = New-Object 'System.Collections.Generic.HashSet[string]' ($comparer)
    $utf8WithBom = New-Object System.Text.UTF8Encoding($true)
    $reader = New-Object System.IO.StreamReader($FilePath, $Encoding, $true)
    $writer = New-Object System.IO.StreamWriter($TemporaryCleanPath, $false, $utf8WithBom)
    $totalLines = 0

    try {
        while (($line = $reader.ReadLine()) -ne $null) {
            $totalLines++

            if ($seen.Add($line)) {
                $writer.WriteLine($line)
            }

            $count = 0

            if ($counts.TryGetValue($line, [ref]$count)) {
                $counts[$line] = $count + 1
            }
            else {
                $counts.Add($line, 1)
            }
        }
    }
    finally {
        $reader.Dispose()
        $writer.Dispose()
    }

    return [PSCustomObject]@{
        Counts = $counts
        TotalLines = $totalLines
        UniqueLines = $seen.Count
    }
}

$tempCleanPath = Join-Path ([System.IO.Path]::GetDirectoryName($CleanPath)) ([System.IO.Path]::GetRandomFileName())

try {
    $encodingInfo = Get-TextEncodingInfo -FilePath $Path

    try {
        $data = Read-And-CleanTextFile -FilePath $Path -Encoding $encodingInfo.Encoding -TemporaryCleanPath $tempCleanPath
    }
    catch [System.Text.DecoderFallbackException] {
        if (-not $encodingInfo.AllowAnsiFallback) {
            throw
        }

        if (Test-Path -LiteralPath $tempCleanPath) {
            Remove-Item -LiteralPath $tempCleanPath -Force
        }

        $data = Read-And-CleanTextFile -FilePath $Path -Encoding ([System.Text.Encoding]::Default) -TemporaryCleanPath $tempCleanPath
    }

    if (Test-Path -LiteralPath $CleanPath) {
        Remove-Item -LiteralPath $CleanPath -Force
    }

    Move-Item -LiteralPath $tempCleanPath -Destination $CleanPath

    $duplicates = @(
        $data.Counts.GetEnumerator() |
        Where-Object { $_.Value -gt 1 } |
        Sort-Object Key
    )

    if ($duplicates.Count -eq 0) {
        if (Test-Path -LiteralPath $DuplicatePath) {
            Remove-Item -LiteralPath $DuplicatePath -Force
        }

        Write-Host ("Lines read: {0}" -f $data.TotalLines)
        Write-Host ("Unique lines written: {0}" -f $data.UniqueLines)
        exit 2
    }

    $report = New-Object System.Collections.Generic.List[string]
    $report.Add("Count`tLine")

    foreach ($duplicate in $duplicates) {
        $report.Add(("{0}`t{1}" -f $duplicate.Value, $duplicate.Key))
    }

    $utf8WithBom = New-Object System.Text.UTF8Encoding($true)
    [System.IO.File]::WriteAllLines($DuplicatePath, $report, $utf8WithBom)

    Write-Host ("Lines read: {0}" -f $data.TotalLines)
    Write-Host ("Unique lines written: {0}" -f $data.UniqueLines)
    Write-Host ("Duplicate groups found: {0}" -f $duplicates.Count)
    exit 0
}
catch {
    if (Test-Path -LiteralPath $tempCleanPath) {
        Remove-Item -LiteralPath $tempCleanPath -Force
    }

    Write-Error $_.Exception.Message
    exit 1
}

So führen Sie das BAT-Skript aus

1. Ziehen Sie die TXT-Datei auf find_duplicate_lines.bat. Alternativ können Sie auf die BAT-Datei doppelklicken und den vollständigen Pfad zur Textdatei einfügen.
2. Warten Sie, während das Skript die Datei liest und exakt übereinstimmende Zeilen zählt.
3. Öffnen Sie filename_duplicates.txt , um wiederholte Zeilen und die Anzahl ihrer Vorkommen anzuzeigen.
4. Öffnen Sie filename_without_duplicates.txt , um die bereinigte Liste ohne zusätzliche Duplikatvorkommen zu erhalten.

So behandelt das Skript die Zeilenreihenfolge

Beispiel für einen Duplikatbericht

Count	Line
4	example.com
2	server-01

Vom Skript verwendete Vergleichsregeln

• Der Vergleich beachtet die Groß-/Kleinschreibung: Windows und windows werden als unterschiedliche Zeilen behandelt.
• Führende und nachgestellte Leerzeichen werden berücksichtigt.
• Leerzeilen werden wie jede andere Zeile behandelt und in der bereinigten Ausgabe auf eine einzige Leerzeile reduziert.
• UTF-8 mit oder ohne BOM wird automatisch erkannt. UTF-16 und UTF-32 werden unterstützt, wenn ein BOM vorhanden ist.
• Bei einer Datei ohne BOM, deren Bytes kein gültiges UTF-8 darstellen, wird auf die aktuelle Windows-ANSI-Codepage zurückgegriffen.
• Beide erzeugten Dateien werden für eine zuverlässige Darstellung in Windows-Anwendungen als UTF-8 mit BOM gespeichert.

So zeigen Sie doppelte Zeilen und ihre Anzahl mit PowerShell an

PowerShell liest die Datei als Sammlung einzelner Zeilen. -Encoding UTF8 weist Windows PowerShell 5.1 an, eine UTF-8-Datei korrekt zu decodieren, einschließlich UTF-8-Dateien ohne Byte Order Mark. Group-Object gruppiert identische Zeilen, und Where-Object behält nur Gruppen bei, die mehr als ein Element enthalten.

1. Speichern Sie die Textdatei in einem leicht auffindbaren Ordner.
2. Öffnen Sie diesen Ordner im Datei-Explorer.
3. Klicken Sie in die Adressleiste, geben Sie powershellein und drücken Sie Enter.
4. Führen Sie den folgenden Befehl aus, nachdem Sie input.txt durch Ihren Dateinamen ersetzt haben.

Get-Content -LiteralPath ".\input.txt" -Encoding UTF8 |
Group-Object -CaseSensitive |
Where-Object Count -gt 1 |
Sort-Object Count -Descending |
Select-Object Count, Name

Beispielausgabe

Count Name
----- ----
    4 example.com
    3 192.168.1.10
    2 Windows 11

Dieses Ergebnis bedeutet, dass example.com viermal vorkommt, 192.168.1.10 dreimal vorkommt und Windows 11 zweimal vorkommt.

Vollständigen Dateipfad verwenden

Sie können dieselbe Prüfung aus jedem Ordner ausführen, indem Sie den vollständigen Pfad angeben:

Get-Content -LiteralPath "C:\Users\User\Desktop\input.txt" -Encoding UTF8 |
Group-Object -CaseSensitive |
Where-Object Count -gt 1 |
Select-Object Count, Name

-LiteralPath ist vorzuziehen, wenn ein Dateiname Zeichen wie eckige Klammern enthält, da PowerShell den Pfad exakt wie angegeben behandelt. In den Beispielen wird -Encoding UTF8verwendet; ersetzen Sie diesen Parameter durch die passende Codierungsangabe, wenn die Quelldatei nicht in UTF-8 vorliegt.

So prüfen Sie, ob doppelte Zeilen vorhanden sind, und geben nur Ja oder Nein aus

Verwenden Sie diese Variante, wenn Sie nur wissen möchten, ob mindestens eine wiederholte Zeile vorhanden ist:

$duplicate = Get-Content -LiteralPath ".\input.txt" -Encoding UTF8 |
Group-Object -CaseSensitive |
Where-Object Count -gt 1 |
Select-Object -First 1

if ($null -ne $duplicate) {
    Write-Host "Duplicate lines found."
} else {
    Write-Host "No duplicate lines found."
}

Der Befehl gibt nur die erste Duplikatgruppe zurück. PowerShell muss die Datei dennoch vollständig lesen und gruppieren, bevor das Ergebnis ausgegeben werden kann. Dies ist in einem Skript, einer geplanten Aufgabe oder einem wiederholbaren Prüfablauf nützlich.

Einzeilige Variante

if (Get-Content -LiteralPath ".\input.txt" -Encoding UTF8 | Group-Object -CaseSensitive | Where-Object Count -gt 1 | Select-Object -First 1) { "Duplicate lines found" } else { "No duplicate lines found" }

So exportieren Sie doppelte Zeilen und ihre Anzahl als CSV

Um den Duplikatbericht zu speichern, statt ihn nur in der Konsole anzuzeigen, exportieren Sie die gruppierten Ergebnisse in eine CSV-Datei:

Get-Content -LiteralPath ".\input.txt" -Encoding UTF8 |
Group-Object -CaseSensitive |
Where-Object Count -gt 1 |
Sort-Object Count -Descending |
Select-Object Count, @{Name="Line"; Expression={$_.Name}} |
Export-Csv -LiteralPath ".\duplicate-report.csv" -NoTypeInformation -Encoding UTF8

Die Ausgabedatei duplicate-report.csv kann in Excel, LibreOffice Calc, im Editor oder in einem anderen Texteditor geöffnet werden.

Jeden doppelten Wert nur einmal speichern

Verwenden Sie den folgenden Befehl, wenn Sie eine einfache TXT-Datei benötigen, die jede zuvor doppelte Zeile nur einmal enthält:

Get-Content -LiteralPath ".\input.txt" -Encoding UTF8 |
Group-Object -CaseSensitive |
Where-Object Count -gt 1 |
ForEach-Object Name |
Set-Content -LiteralPath ".\duplicate-lines.txt" -Encoding UTF8

So ignorieren Sie Groß-/Kleinschreibung, zusätzliche Leerzeichen oder Leerzeilen

Groß-/Kleinschreibung ignorieren

Group-Object ignoriert standardmäßig die Groß-/Kleinschreibung. Entfernen Sie -CaseSensitive , damit PC, Pcund pc als derselbe Wert behandelt werden:

Get-Content -LiteralPath ".\input.txt" -Encoding UTF8 |
Group-Object |
Where-Object Count -gt 1 |
Select-Object Count, Name

Leerzeichen am Anfang und Ende ignorieren

Get-Content -LiteralPath ".\input.txt" -Encoding UTF8 |
ForEach-Object { $_.Trim() } |
Group-Object -CaseSensitive |
Where-Object Count -gt 1 |
Select-Object Count, Name

Dadurch werden example, exampleund example als gleichwertig behandelt. Leerzeichen innerhalb einer Zeile werden nicht entfernt.

Leere Zeilen und Zeilen nur aus Leerzeichen ignorieren

Get-Content -LiteralPath ".\input.txt" -Encoding UTF8 |
Where-Object { $_.Trim().Length -gt 0 } |
Group-Object -CaseSensitive |
Where-Object Count -gt 1 |
Select-Object Count, Name

Groß-/Kleinschreibung ignorieren, Leerzeichen entfernen und Leerzeilen überspringen

Get-Content -LiteralPath ".\input.txt" -Encoding UTF8 |
ForEach-Object { $_.Trim() } |
Where-Object { $_.Length -gt 0 } |
Group-Object |
Where-Object Count -gt 1 |
Sort-Object Count -Descending |
Select-Object Count, Name

So prüfen Sie doppelte Zeilen mit der Eingabeaufforderung und dem Befehl SORT

Der in Windows integrierte Befehl sort.exe kann identische Zeilen direkt untereinander anordnen. Dadurch lassen sich Duplikate leichter manuell erkennen, aber SORT erkennt, zählt oder entfernt wiederholte Zeilen nicht automatisch.

1. Öffnen Sie den Ordner, der die Textdatei enthält.
2. Klicken Sie in die Adressleiste des Datei-Explorers, geben Sie cmdein und drücken Sie Enter.
3. Führen Sie den folgenden Befehl aus:

sort "input.txt" /o "sorted.txt"

Öffnen Sie sorted.txt im Editor. Wiederholte Werte stehen anschließend direkt untereinander und können visuell geprüft werden.

Rufen Sie für eine automatische Prüfung aus der Eingabeaufforderung Windows PowerShell über CMD auf. In diesem Beispiel wird UTF-8 außerdem ausdrücklich angegeben, damit kyrillische Zeichen und Akzentzeichen in Windows PowerShell 5.1 nicht als ANSI decodiert werden:

powershell.exe -NoProfile -Command "Get-Content -LiteralPath '.\input.txt' -Encoding UTF8 | Group-Object -CaseSensitive | Where-Object Count -gt 1 | Select-Object Count, Name"

So prüfen Sie große Textdateien unter Windows auf doppelte Zeilen

Das BAT-Skript aus Methode 1 ist effizienter als die kurzen Group-Object -Beispiele, da es die vollständige Datei nicht in ein Array einliest und nicht jede Quellzeile alphabetisch sortiert. Es liest sequenziell, schreibt erste Vorkommen direkt in die bereinigte Ausgabe und speichert im Arbeitsspeicher nur die eindeutigen Schlüssel und ihre Zähler.

Die direkten PowerShell-Befehle bleiben praktisch, doch Group-Object kann bei einer großen Datei deutlich langsamer sein und viel Arbeitsspeicher belegen.

Beachten Sie bei großen Dateien folgende Hinweise:

• Schließen Sie speicherintensive Anwendungen, bevor Sie die Prüfung starten.
• Testen Sie den Befehl an einer Kopie der Datei.
• Exportieren Sie nur den Duplikatbericht, statt eine sehr große Ergebnismenge in der Konsole zu formatieren.
• Verwenden Sie unter 64-Bit-Windows einen 64-Bit-PowerShell-Prozess.
• Erwägen Sie bei Dateien mit mehreren Gigabyte ein Streaming-Skript oder einen datenbankgestützten Ablauf anstelle von Group-Object.

So beheben Sie fehlerhafte Zeichen bei der Prüfung auf doppelte Zeilen

Wenn PowerShell kyrillischen, akzentuierten oder anderen nicht englischen Text als Zeichenfolgen wie РіС...anzeigt, wird die Quelldatei normalerweise mit der falschen Zeichencodierung decodiert. Der Text selbst kann weiterhin intakt sein; das Problem liegt darin, wie Get-Content die Dateibytes interpretiert.

UTF-8-Datei korrekt lesen

Get-Content -LiteralPath ".\input.txt" -Encoding UTF8 |
Group-Object -CaseSensitive |
Where-Object Count -gt 1 |
Sort-Object Count -Descending |
Select-Object Count, Name

Dies funktioniert in Windows PowerShell 5.1 für UTF-8-Text mit oder ohne Byte Order Mark. In neueren PowerShell-Versionen ist UTF-8 bei vielen Textoperationen normalerweise die Standardeinstellung; eine ausdrückliche Angabe macht den Befehl jedoch eindeutig.

Passenden Parameter für die Datei auswählen

Ältere ANSI-Datei lesen

Get-Content -LiteralPath ".\input.txt" -Encoding Default |
Group-Object -CaseSensitive |
Where-Object Count -gt 1 |
Select-Object Count, Name

UTF-16-Little-Endian-Datei lesen

Get-Content -LiteralPath ".\input.txt" -Encoding Unicode |
Group-Object -CaseSensitive |
Where-Object Count -gt 1 |
Select-Object Count, Name

Das wiederverwendbare Skript find_duplicate_lines.bat in diesem Ratgeber erkennt UTF-8 mit oder ohne BOM, unterstützt UTF-16 und UTF-32 mit BOM und greift auf die Windows-ANSI-Codepage zurück, wenn eine Bytefolge ohne BOM kein gültiges UTF-8 ist. Es speichert sowohl den Duplikatbericht als auch die bereinigte Kopie als UTF-8 mit BOM.

FAQ: Doppelte Zeilen in TXT-Dateien unter Windows finden