# Linux find: Dateien suchen und finden [Linux](https://www.ionos.de/digitalguide/server/knowhow/linux-das-steckt-hinter-den-open-source-betriebssystemen/ "Linux: Das steckt hinter den Open-Source-Betriebssystemen") ist ein quelloffenes Betriebssystem, das als freie Alternative zu UNIX geschaffen wurde. Wie unter UNIX ist die **Kommandozeile ein grundlegendes Tool bei der Arbeit mit Linux**. Der Benutzer gibt auf der Kommandozeile [Linux-Befehle](https://www.ionos.de/digitalguide/server/konfiguration/linux-befehle-terminal-kommandos-im-ueberblick/ "Linux-Befehle | Terminal-Kommandos im Überblick") ein und führt diese aus. Um unter Linux eine Datei zu finden, bedient man sich des Linux-find-Befehls. Dieser startet eine **rekursive Suche**, bei der eine Verzeichnis-Hierarchie bestimmten Kriterien folgend durchsucht wird. Der Linux-find-Befehl ist ein präzises Tool zum Finden von Dateien und Verzeichnissen und wird auf so gut wie allen Linux-Distributionen von Hause aus unterstützt. ## Der Linux-find-Befehl im Überblick Um unter Linux den find-Befehl zu nutzen, begeben wir uns auf die **Kommandozeile**. Betrachten wir das generelle Schema des Linux-find-Befehls: ```none find ``` --- ### Hinweis Achtung: Seien Sie vorsichtig mit Befehlen auf der Kommandozeile. Wenn Sie unbedacht den falschen Befehl ausführen, können Sie u. U. Ihr System beschädigen! --- Zunächst steht der Befehl selbst, gefolgt von einem Verzeichnis-Pfad und einer variablen Anzahl von Suchparametern. Ein Suchparameter besteht aus einem Bindestrich, unmittelbar gefolgt vom Namen des Parameters. Dahinter folgen ein Leerzeichen und der Wert des Parameters. Hier eine Übersicht der am häufigsten zum Einsatz kommenden Suchparameter:
Suchparameter Erklärung
-name, -iname Nach Dateinamen filtern
-type Nach Dateityp filtern
-size, -empty Nach Dateigröße filtern
-ctime, -mtime, -atime Nach Zeitstempel filtern
-user, -group Nach Besitzer und Gruppe filtern
-perm Nach Dateirechten filtern
Mehrere **Suchparameter lassen sich kombinieren**. Dabei wird implizit von einer logischen UND-Verknüpfung ausgegangen. Diese lässt sich explizit ausschreiben; ferner kann eine ODER-Verknüpfung genutzt oder eine Bedingung negiert werden:
Suchparameter Erklärung
-and Suchergebnisse müssen beiden Bedingungen entsprechen
-or Suchergebnisse müssen mindestens einer der beiden Bedingungen entsprechen
-not Nachfolgende Bedingung negieren
Beachten Sie, dass Sie in den folgenden Code-Beispielen die **<platzhalter> durch tatsächliche Werte ersetzen </platzhalter>**müssen, um die Beispiele auszuführen. ### Suche auf bestimmtes Verzeichnis beschränken Schauen wir uns zunächst an, wie wir die Suche auf ein bestimmtes Verzeichnis begrenzen können. Um das **aktuelle Verzeichnis zu durchsuchen**, nutzen wir den Punkt '.' als Verzeichnis-Pfad: ```none find . ``` Um den **eigenen Benutzer-Ordner zu durchsuchen**, nutzen wir die Tilde '~' als Verzeichnis-Pfad: ```none find ~ ``` Sie können mit dem Linux-find-Befehl auch das gesamte System durchsuchen. Aufgrund der großen Menge an Dateien und der u. U. sehr tiefen Verzeichnis-Hierarchien kann dies jedoch sehr lange dauern. Um das **gesamte System zu durchsuchen**, nutzen wir einen Vorwärts-Schrägstrich '/' als Verzeichnis-Pfad: ```none find / ``` --- ### Hinweis Achtung: Seien Sie extrem vorsichtig, wenn Sie den Linux-find-Befehl in Kombination mit dem '-exec'-Parameter auf das gesamte System anwenden! --- ### Ausgabe der Suchergebnisse anpassen Die Suchergebnisse des Linux-find-Befehls können u. U. sehr umfangreich sein. Es ist daher oft nützlich, die **Darstellung der Ergebnisse zu beeinflussen**. Wir nutzen dafür keine eigenen Parameter des Befehls, sondern greifen auf sogenannte Pipes zurück. Diese dienen unter Linux dazu, die Ausgabe eines Befehls als Eingabe eines anderen Befehls zu nutzen. Um die **Ergebnisse seitenweise auszugeben**, leiten wir die Ausgabe des find-Befehls an den less-Befehl weiter: ```none find | less ``` Um die **Anzahl der Ergebnisse zu zählen**, leiten wir die Ausgabe des find-Befehls an den wc-Befehl mit dem Parameter '-l' weiter: ```none find | wc -l ``` Um uns nur **die ersten bzw. letzten *n* Suchergebnisse auszugeben**, leiten wir die Ausgabe des find-Befehls an die Befehle '[head](https://www.ionos.de/digitalguide/server/konfiguration/linux-head-befehl/ "Linux Head Befehl")' und '[tail](https://www.ionos.de/digitalguide/server/konfiguration/linux-tail-befehl/ "Linux-Tail-Befehl")' weiter. Dabei geben wir jeweils den Parameter '-n' gefolgt von der gewünschten Anzahl von Suchergebnissen an: ```none find | head -n ``` ```none find | tail -n ``` ## Unter Linux Dateien finden: einfache Anwendungsfälle Die folgenden Beispiele **beschränken die Suche auf das aktuelle Verzeichnis und etwaige Unterverzeichnisse**. Nutzen Sie den cd-Befehl auf der Kommandozeile, um zu einem beliebigen Verzeichnis zu wechseln. Um die Beispiele einfach auszuprobieren, wechseln Sie zunächst in Ihren Benutzerordner: ```none cd ~ ``` ### Mit dem Linux-find-Befehl nach Dateinamen filtern Um nach Dateinamen zu filtern, nutzen Sie den '-name'-Parameter. Dieser erwartet einen **exakten Dateinamen** und unterscheidet zwischen **Groß- und Kleinschreibung**: ```none find . -name ``` Hier suchen wir nach einer Datei mit dem exakten Namen '.gitignore': ```none find . -name .gitignore ``` Um **nicht nach Groß- und Kleinschreibung zu unterscheiden**, nutzen wir den Parameter '-iname'. Das 'i' steht hierbei für „insensitive”, von „case-insensitive“, d. h. ohne Beachtung der Groß- und Kleinschreibung: ```none find . -iname ``` Für gewöhnlich ist es **praktischer, zuerst case-insensitive zu suchen** und nur dann den '-name'-Parameter zu benutzen, wenn die Suche mit '-iname' zu viele Ergebnisse liefert. Möchten wir nicht nach einem exakten Dateinamen suchen, sondern ein Muster nutzen, verwenden wir das **Sternchen als „Wildcard“-Platzhalter** und schreiben das Suchmuster in Anführungszeichen (das Sternchen wird intern als „null bis beliebig viele weitere Zeichen“ interpretiert). Hier suchen wir nach Dateien und Verzeichnissen, deren Name den Text „git“ enthält: ```none find . -iname "*git*" ``` ### Mit dem Linux-find-Befehl nach Dateityp filtern Ein berühmter Aspekt der UNIX-Philosophie ist der Grundsatz „Alles ist eine Datei“; dies gilt auch unter Linux. Der Begriff „Datei“ ist hierbei weiter gefasst, als im umgangssprachlichen Gebrauch üblich. So werden auch Verzeichnisse unter Linux wie Dateien abgebildet – um Verwirrung vorzubeugen, kommt manchmal auch der präzisere Begriff „Dateideskriptor“ zum Einsatz. Sprechen wir unter Linux von „Dateityp“, dann meinen wir damit nicht, ob es sich bei einem Dokument um eine Excel-Datei oder ein JPEG-Bild handelt. Stattdessen unterscheiden wir die verschiedenen unter Linux existierenden Dateideskriptor-Typen. Der Linux-find-Befehl stellt uns den Suchparameter '-type' zur Verfügung, um nach Dateitypen zu filtern. So können wir z. B. **bei der Suche zwischen Dateien und Verzeichnissen unterscheiden**. Hier eine Übersicht der am häufigsten genutzten Dateitypen:
Dateityp Erklärung
f Datei („File“)
d Verzeichnis („Directory“)
l Symbolischer Link („Link“)
Um **nur Dateien in die Suchergebnisse aufzunehmen**, nutzen wir den '-type'-Parameter gefolgt vom Wert 'f': ```none find . -type f ``` Um **nur Verzeichnisse in die Suchergebnisse aufzunehmen**, nutzen wir den '-type'-Parameter gefolgt vom Wert 'd': ```none find . -type d ``` Um **nach der Dateiendung zu filtern**, bedienen wir uns des '-iname'-Parameters und nutzen das Sternchen als Wildcard-Platzhalter. Alle Dateien mit Erweiterung jpeg oder JPEG finden: ```none find . -type f -iname "*.jpeg" ``` Alle Dateien mit Erweiterung jpeg/JPEG oder jpg/JPG finden: ```none find . -type f -iname "*.jpeg" -or -iname "*.jpg" ``` ### Mit dem Linux-find-Befehl nach Größe filtern Das **Konzept der Datei unter Linux verknüpft mehrere Informationen**. Dazu gehören für gewöhnlich zumindest die folgenden: - Name - Dateityp - Dateigröße - Zeitstempel - Besitzer und Gruppe - Zugriffsrechte Nach all diesen lässt sich mit dem find-Befehl und den entsprechenden Parametern filtern. Um **nach der Größe einer Datei zu filtern**, nutzen wir den '-size'-Parameter gefolgt von einer Größenangabe. Der folgende find-Befehl liefert Dateien, die mindestens 700 Megabyte groß sind: ```none find . -size +700M ``` --- ### Hinweis Die Filterung nach Größe funktioniert nur für Dateien. Für Verzeichnisse ist im Dateisystem keine Größe hinterlegt. Stattdessen wird die Größe bei Bedarf rekursiv errechnet. --- Die **Größenangaben bestehen aus einer Zahl gefolgt von einer Einheit**. Hier eine Übersicht der zur Verfügung stehenden Einheiten:
Einheit Erklärung
c Bytes
k Kilobytes
M Megabytes
G Gigabytes
b 512-byte blocks
Die Größenangabe wird als exakte Dateigröße interpretiert. Dies ist selten praktikabel, da oft die genaue Größe einer gesuchten Datei nicht bekannt ist. Praktischer ist die **Beschränkung auf einen bestimmten Größenbereich**. Dafür wird der Zahl ein optionaler Modifikator vorangestellt:
Modifikator Erklärung
+ Datei ist größer als die angegebene Größe
- Datei ist kleiner als die angegebene Größe
Der folgende Befehl liefert Dateien, die kleiner als 500 Megabyte sind: ```none find . -size -500M ``` Der folgende Befehl liefert Dateien, deren Größe zwischen 400 und 500 Megabyte liegt: ```none find . -size +400M -and -size -500M ``` Neben der Angabe einer exakten Größe oder eines Größenbereichs gibt es mit '-empty' einen eigenen Parameter für die **Suche nach leeren Dateien**: ```none find . -type f -empty ``` Dies funktioniert **auch für Verzeichnisse**: ```none find . -type d -empty ``` ### Mit dem Linux-find-Befehl nach Zeitstempeln filtern Das Betriebssystem verwaltet das Dateisystem und protokolliert die auf Dateien stattfindenden Zugriffe. Dabei werden verschiedene Zeitstempel erzeugt. Linux legt **Zeitstempel für die Erzeugung, die letzte Änderung und den letzten Zugriff auf eine Datei** an. Mit dem find-Befehl können wir nach diesen Zeitstempeln filtern. Hier eine Übersicht der dabei am häufigsten zum Einsatz kommenden Suchparameter:
Suchparameter Erklärung
-ctime, -cmin Nach Datum der Erzeugung („Creation“) filtern
-mtime, -mmin Nach Datum der Änderung („Modification“) filtern
-atime, -amin Nach Datum des Zugriffs („Access“) filtern
Um Dateien zu finden, die **vor einem Tag verändert** wurden, nutzen wir den Suchparameter '-mtime', gefolgt vom Wert '1': ```none find . -type f -mtime 1 ``` Die dargestellten Suchparameter mit '**time**' im Namen interpretieren den nachfolgenden Wert als Anzahl von *Tagen*. Die Parameter mit '**min**' im Namen interpretieren den nachfolgenden Wert als Anzahl von *Minuten*. Analog zum Filtern nach Dateigröße können wir die **Anzahl der vergangenen Tage auf einen Bereich beschränken**. Dabei kommen wiederum das Plus- und Minuszeichen als Modifikatoren zum Einsatz:
Modifikator Erklärung
+ Zeitstempel liegt mehr Tage als angeben zurück
- Zeitstempel liegt weniger Tage als angeben zurück
Um Dateien zu finden, die **vor mehr als 100 Tagen erzeugt** wurden, nutzen wir den Suchparameter '-ctime', gefolgt vom Wert '+100': ```none find . -type f -ctime +100 ``` Wie beim Filtern nach Dateigröße lassen sich die Suchparameter kombinieren, um einen Bereich abzudecken. Um Dateien zu finden, deren **Zugriff zwischen drei und fünf Tage zurückliegt**, nutzen wir zweimal den Suchparameter '-atime', jeweils mit den Werten '+2' und '-6'. Die explizite Verknüpfung über den '-and'-Parameter ist optional: ```none find . -type f -atime +2 -and -atime -6 ``` Um Dateien zu finden, deren **Änderung weniger als fünf Minuten zurückliegt**, nutzen wir den Suchparameter '-mmin', mit dem Wert '-5': ```none find . -type f -mmin -5 ``` ### Mit dem Linux-find-Befehl nach Besitzer, Gruppe und Zugriffsrechten filtern Unter Linux ist **jeder Datei ein Benutzer als Besitzer zugeordnet**. Ferner gehört jede Datei einer bestimmten Nutzergruppe. Darauf aufbauend sind für jede Datei bestimmte Zugriffsrechte (engl. *permissions*) festgelegt. Nach all diesen Informationen können wir mit dem find-Befehl filtern, um unter Linux Dateien zu finden. Hier eine Übersicht der dabei zum Einsatz kommenden Suchparameter:
Suchparameter Erklärung
-user Nach Besitzer filtern
-group Nach Gruppe filtern
-perm Nach Dateirechten filtern
Um nach Dateien zu suchen, die dem **Root-Benutzer gehören**, nutzen wir den Suchparameter '-user' gefolgt vom Wert 'root': ```none find . -user root ``` Um nach Dateien zu suchen, die dem **eigenen Benutzer gehören**, nutzen wir den Suchparameter '-user' gefolgt vom Ausdruck '$(whoami)'. Letzterer wird zum Namen des angemeldeten Benutzers aufgelöst: ```none find . -user $(whoami) ``` Um nach Dateien zu suchen, die der **Admin-Gruppe zugehören**, nutzen wir den Suchparameter '-group' gefolgt vom Wert 'admin': ```none find . -group admin ``` Neben dem Filtern nach Besitzer und Gruppe ist es auch möglich, **nach Zugriffsrechten zu filtern**. Dabei kommt ein Triplet von Oktalzahlen zum Einsatz. Häufig benutzte Werte sind '644', '755' etc. Die erste Zahl definiert die Zugriffsrechte für den Besitzer, die zweite für die Gruppe, die dritte für andere Nutzer. Jede der drei Oktalzahlen wird durch Addition der einzelnen Rechte erzeugt. Wie das genau funktioniert, erklären wir in unserem Artikel zur [Vergabe von Verzeichnisrechten mit chmod](https://www.ionos.de/digitalguide/server/knowhow/die-vergabe-von-verzeichnisrechten-mit-chmod/ "Die Vergabe von Verzeichnisrechten mit chmod"). Um Dateien zu finden, die **für jeglichen Benutzer voll zugreifbar** sind, nutzen wir den Suchparameter '-perm' gefolgt vom Wert '777': ```none find . -perm 777 ``` Um Dateien zu finden, die **nur für den Besitzer voll zugreifbar** sind, nutzen wir den Suchparameter '-perm' gefolgt vom Wert '700': ```none find . -perm 700 ``` Wir können den find-Befehl auch nutzen, um unter Linux Dateien zu finden, die **mindestens die angegebenen Rechte aufweisen**. Dazu stellen wir der Oktalzahl unmittelbar ein Minuszeichen voran: ```none find . -perm -007 ``` ### Die Rekursionstiefe des Linux-find-Befehls beschränken Normalerweise durchläuft der Linux-find-Befehl rekursiv alle Unterverzeichnisse. Es ist jedoch oft nützlich, die **Tiefe der Rekursion zu beschränken**. Dazu nutzen wir die Suchparameter '-maxdepth' und -mindepth:
Suchparameter Erklärung
-maxdepth Maximale Rekursionstiefe
-mindepth Minimale Rekursionstiefe
Um unter Dateien zu finden, die mehr als 50 Megabyte groß sind und dabei nur Verzeichnisse einzuschließen, die nicht mehr als zwei Ebenen tiefer liegen als das derzeitige Verzeichnis, nutzen wir den folgenden Befehl: ```none find . -type f -maxdepth 2 -size +50M ``` Um unter Dateien zu finden, die mehr als 50 Megabyte groß sind und dabei nur Verzeichnisse einzuschließen, die mindestens drei Ebenen und nicht mehr als fünf Ebenen tiefer liegen als das derzeitige Verzeichnis, nutzen wir den folgenden Befehl: ```none find . -type f -mindepth 3 -and -maxdepth 5 -size +50M ``` ## Mit dem Linux-find-Befehl Dateien finden und verarbeiten Bisher haben wir uns darauf beschränkt, unter Linux Dateien zu finden. Viele Anwendungsfälle erfordern jedoch das **massenhafte Verarbeiten der gefundenen Dateien**. Übliche Szenarien sind das Reparieren von Zugriffsrechten für webbasierte Software wie WordPress oder das Löschen von Dateien nach einem Hack. Auch für diese Anwendungsfälle greifen wir auf den find-Befehl zurück. Betrachten wir das **generelle Muster für das Ausführen eines Kommandos für jede gefundene Datei**. Wir nutzen dazu den '-exec'-Parameter, gefolgt von einem Linux-Kommando und dessen Parametern. Abgeschlossen wird der gesamte Befehl vom immer gleich bleibenden Text '{} \\;': ```none find -exec {} \; ``` Beachten Sie, dass das **Ausführen des Kommandos ohne Nachfrage abläuft**! Je nach gewählten Suchparametern und dem gegebenen Kommando kann die Ausführung des find-Befehls mit dem '-exec'-Parameter schwere Schäden am System hervorrufen. Um das Risiko zu begrenzen, gibt es analog zum '-exec'-Parameter den '-ok'-Parameter. Dieser **erzwingt die interaktive Bestätigung der Verarbeitung** jeder einzelnen gefundenen Datei: ```none find -ok {} \; ``` Vorsichtshalber beschränken wir bei den nachfolgenden Beispielen die Rekursionstiefe per '-maxdepth 1' auf nur ein Unterverzeichnis. --- ### Hinweis Achtung: Seien Sie vorsichtig mit den folgenden Beispielen. Wir empfehlen Ihnen dringend, zum Ausprobieren einen eigenen Ordner anzulegen. Wechseln Sie vor dem Ausführen der Beispiele in diesen Ordner, um sicherzustellen, dass Sie Ihr System nicht beschädigen! --- ### Mit dem Linux-find-Befehl Besitzer und Gruppe anpassen Um Besitzer und Gruppe aller Dateien und Verzeichnisse auf den Wert 'www-data' zu setzen, nutzen wir den folgenden find-Befehl mit dem **chown-Kommando**: ```none find . -maxdepth 1 -exec chown www-data:www-data {} \; ``` ### Mit dem Linux-find-Befehl Dateirechte anpassen Um Dateien mit Rechten '777' zu finden und auf '664' zu setzen, nutzen wir den folgenden find-Befehl mit dem **chmod-Kommando**: ```none find . -type f -maxdepth 1 -perm 777 -exec chmod 664 {} \; ``` Um die Rechte aller Verzeichnisse auf '755' zu setzen, nutzen wir den folgenden find-Befehl mit dem chmod-Kommando: ```none find . -type d -maxdepth 1 -exec chmod 755 {} \; ``` ### Mit dem Linux-find-Befehl leere Verzeichnisse und Dateien löschen Sie können den find-Befehl auch nutzen, um **gefundene Dateien und Verzeichnisse zu löschen**. Vorsichtshalber zeigen wir dies hier nur für leere Dateien und Verzeichnisse. Ferner nutzen wir anstelle des '-exec'-Parameters den '-ok'-Parameter, um den Nutzer zu zwingen, dem Löschen explizit zuzustimmen. Um alle leeren [Linux-Verzeichnisse zu löschen](https://www.ionos.de/digitalguide/server/konfiguration/linux-verzeichnis-loeschen/ "Linux-Verzeichnis löschen"), nutzen wir den folgenden find-Befehl mit dem **rmdir-Kommando**: ```none find . -type d -maxdepth 1 -empty -ok rmdir {} \; ``` Um alle leeren [Linux-Dateien zu löschen](https://www.ionos.de/digitalguide/server/konfiguration/linux-datei-loeschen/ "Linux-Datei löschen"), nutzen wir den folgenden find-Befehl mit dem **rm-Kommando**: ```none find . -type f -maxdepth 1 -empty -ok rm {} \; ``` This is a markdown version of: [https://www.ionos.de/digitalguide/server/konfiguration/linux-datei-suchen/](https://www.ionos.de/digitalguide/server/konfiguration/linux-datei-suchen/) for AI/LLM consumption.