Find: Unterschied zwischen den Versionen

Aus Foxwiki
Subpages:
Versionsgeschichte interaktiv durchsuchen
← Zum vorherigen Versionsunterschied
VisuellWikitext
Keine Bearbeitungszusammenfassung
K Textersetzung - „== Syntax ==“ durch „== Aufruf ==“
 
(247 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 1: Zeile 1:
V.31 (11.11.2020)
'''find''' - Dateien nach Eigenschaften suchen


= {{anchor|RefHeading339881143486078}} Linux- GNU Find =
== Beschreibung ==
; Werkzeug für die Suche nach Dateien
* kann auf vielfältige Weise die Suche filtern
* Etwa Dateiname, -alter oder -größe
* Formatierung der Ergebnisliste
* Suchergebnisse können weiterverarbeiten werden


find ist ein Kommandozeilenprogramm für die Dateisuche. Dabei kann man auf vielfältige Weise die Suche filtern, z.B. nach Dateiname, -alter, -größe und die Suchergebnisse weiterverarbeiten und/oder formatiert ausgeben.
=== Implementierungen ===
; Nicht alle Implementierungen von ''find'' sind gleich
* Der Befehl ''find'' ist unter Linux etwas anders als auf BSDs, Solaris oder Mac OS X.
* Ein Großteil der Syntax von ''find'' ist gleich und kann auf allen Systemen verwendet werden, aber nicht vollständig.


<div style="margin-left:0cm;margin-right:0cm;">find [PFAD...] [AUSDRUCK...]</div>
Bei Schwierigkeiten prüfen Sie die [[man]]-Page des Systems.
<syntaxhighlight lang="bash" highlight="1" line>
find --version
find (GNU findutils) 4.4.2
</syntaxhighlight>


find ist ein äußerst mächtiges Instrument zum Suchen von Dateien.
=== Abgrenzung ===
 
{| class="wikitable sortable options"
Mit PFAD kann dem Kommando ein beliebiges Startverzeichnis für die Suche angegeben werden. Fehlt die Angabe, startet das Kommando im aktuellen Verzeichnis.
 
Allerdings ist der Verzicht auf die Pfadangabe nur bei der GNU-Version (also unter Linux) des Kommandos gestattet, deswegen empfiehlt es sich, die Angabe immer vorzunehmen.
 
find durchsucht in der Voreinstellung rekursiv alle Unterverzeichnisse.
 
Deshalb lassen sich die Anzahl der Ebenen (Option --maxdepth Anzahl) beschränken.
 
»Anzahl=1« bedeutet dabei die Suche einzig im angegebenen Verzeichnis.
 
Die gebräuchlichste Methode wird die Suche nach Dateien mit einem bestimmten Namen sein.
 
Die Option -name Dateiname ermöglicht dies. Dateiname kann dabei die Shell-Metazeichen zur Dateinamenserweiterung enthalten, in dem Falle muss der Name vor der Auswertung durch die Shell geschützt werden, indem er in Anführungsstriche (doppelt/einfach) eingeschlossen wird.
 
<div style="margin-left:0cm;margin-right:0cm;">'''find /usr -maxdepth 3 -name "XF*"'''
/usr/X11R6/bin/XF86_Mach64
/usr/X11R6/bin/XF86Setup
/usr/X11R6/bin/XF86_VGA16
/usr/X11R6/bin/XFCom_Cyrix
/usr/X11R6/bin/XFCom_Matrox
/usr/X11R6/bin/XFCom_Trident </div>
 
Dateien verfügen über viele Eigenschaften. Sie haben einen Besitzer, Rechte, mehrere Zeitstempel, einen Typ, usw. Für jede dieser Eigenschaften existieren Optionen, mit denen sich gezielt Dateien bestimmter Charakteristik herausfischen lassen.
 
Da unter unixoiden Systemen der Leitsatz ''"Alles ist eine Datei"'' gilt, werden auch Verzeichnisse gefunden. Eine Alternative zu find (mit Vor- und Nachteilen) bietet der Befehl [http://wiki.ubuntuusers.de/locate locate].
 
==== {{anchor|RefHeading13006977924429}} Implementierungen ====
 
Nicht alle Implementierungen von <tt>find</tt> sind gleich. Der Befehl <tt>find</tt> ist unter Linux etwas anders als auf BSDs, Solaris oder Mac OS X. Ein Großteil der Syntax von <tt>find</tt> ist gleich und kann auf allen Systemen verwendet werden, aber nicht vollständig.
 
Bei Schwierigkeiten prüfen Sie die mab-Page Ihres Systems.
 
Version of find:
 
<div style="margin-left:0cm;margin-right:0cm;">'''$ find --version'''
find (GNU findutils) 4.4.2</div>
 
==== Alternativen ====
 
find ist fast immer das Mittel der Wahl, wenn es darum geht, auch Unterverzeichnisse zu durchsuchen.
 
===== locate =====
 
Wenn man den Dateinamen genau kennt, kann [http://wiki.ubuntuusers.de/locate locate] eine bessere Wahl sein. locate arbeitet allerdings mit einem Index, der 1x täglich aktualisiert wird, und findet daher ganz frische Dateien nicht.
 
===== Suche nach Programmen  =====
 
wird man <tt>whereis</tt> benutzen.
 
===== Im aktuellen Verzeichnis, ohne Unterverzeichnisse  =====
 
zu berücksichtigen, kommt man mit [http://wiki.ubuntuusers.de/Terminal#Vervollstaendigen-lassen-nicht-tippen automatischer Vervollständigung] und den Jokerzeichen <tt><nowiki>*</nowiki></tt> und <tt>?</tt> oft weiter, wenn man Namensbestandteile kennt.
 
Manche Programme bieten auch von sich aus an, Unterverzeichnisse zu berücksichtigen, siehe [http://wiki.ubuntuusers.de/ls ls] und [http://wiki.ubuntuusers.de/Shell/grep Shell/grep].
 
== {{anchor|RefHeading7019539995267}} Grundlegende Verwendung ==
 
find - sucht in einer Verzeichnishierarchie nach Dateien
 
<div style="margin-left:0cm;margin-right:0cm;">find [-H] [-L] [-P] [Verzeichnis...] [Ausdruck] </div>
 
GNU find durchsucht eine oder mehrere Verzeichnishierarchien und bewertet dabei den Ausdruck von links nach rechts entsprechend den Regeln der Priorität (siehe Abschnitt OPERATOREN) bis das Ergebnis bekannt ist (die linke Seite ist falsch für UND Operatoren, wahr für ODER Operatoren).
 
Anschließend führt find die Suche mit der nächsten Datei fort.
 
Beginnen wir mit dem Grundlagen. Wenn du eine Datei suchst und kennst den Namen der Datei - nur nicht den Ort wo du sie abgelegt hast - dann ist die Syntax einfach. Lass <tt>find</tt> einfach nach dem speziellem Namen suchen:
 
<div style="margin-left:0cm;margin-right:0cm;">find -name filename</div>
 
Angenommen ''filename'' existiert, dann wird <tt>find</tt> den Speicherort der Datei/Dateien anzeigen.
 
Wie etwa hier:
 
<div style="margin-left:0cm;margin-right:0cm;">'''find -name filename'''
./projects/filename</div>
 
find ist ein traditionelles Unix-Programm. Es dient zum rekursiven Suchen von Dateien nach bestimmten Kriterien in einem oder mehreren Verzeichnissen. Es ist wirklich nützlich, die Syntax verlangt allerdings etwas Übung:
 
<div style="margin-left:0cm;margin-right:0cm;">find [Optionen] [Verzeichnisse] [Kriterium] [Handlung]</div>
 
Geben Sie kein Verzeichnis an, durchsucht find das aktuelle Verzeichnis. Geben Sie das Kriterium nicht an, gilt sein Wert als ,,wahr`` und alle Dateien werden gefunden.
 
Die Optionen, Kriterien und Aktionen sind so mannigfaltig, dass hier nur wenige erwähnt werden können.
 
The <tt>find</tt> command is used to locate files on a Unix or Linux system. <tt>find</tt> will search any set of directories you specify for files that match the supplied ''search criteria''.
 
You can search for files by name, owner, group, type, permissions, date, and other criteria. The search is recursive in that it will search all subdirectories too.&nbsp;
 
The syntax looks like this:
 
<div style="margin-left:0cm;margin-right:0cm;">find ''where-to-look criteria what-to-do''</div>
 
All arguments to <tt>find</tt> are optional, and there are defaults for all parts.
 
This may depend on which version of <tt>find</tt> is used. Here we discuss the freely available Gnu version of <tt>find</tt>, which is the version available on <tt>YborStudent</tt>.)
 
For example, ''where-to-look'' defaults to <tt>.</tt>(that is, the current working directory), ''criteria'' defaults to none (that is, select all files), and ''what-to-do'' (known as the <tt>find</tt> ''action'') defaults to <tt>‑print</tt> (that is, display the names of found files to standard output).
 
Technically, the criteria and actions are all known as <tt>find</tt> ''primaries''.
 
For example:
 
<div style="margin-left:0cm;margin-right:0cm;">find</div>
 
will display the pathnames of all files in the current directory and all subdirectories.&nbsp; The commands
 
<div style="margin-left:0cm;margin-right:0cm;">find . -print
find -print
find .</div>
 
do the exact same thing.&nbsp; Here's an example <tt>find</tt> command using a search criterion and the default action:
 
<div style="margin-left:0cm;margin-right:0cm;">find / -name foo</div>
 
This will search the whole system for any files named <tt>foo</tt> and display their pathnames.
 
Here we are using the criterion <tt>‑name</tt> with the argument <tt>foo</tt> to tell <tt>find</tt> to perform a name search for the filename <tt>foo</tt>.&nbsp; The output might look like this:
 
<div style="margin-left:0cm;margin-right:0cm;">/home/wpollock/foo
/home/ua02/foo
/tmp/foo</div>
 
If <tt>find</tt> doesn't locate any matching files, it produces no output. The above example said to search the whole system, by specifying the root directory (“<tt>/</tt>”) to search.
 
If you don't run this command as root, <tt>find</tt> will display a error message for each directory on which you don't have read permission.
 
This can be a lot of messages, and the matching files that are found may scroll right off your screen.
 
A good way to deal with this problem is to redirect the error messages so you don't have to see them at all:
 
<div style="margin-left:0cm;margin-right:0cm;">find / -name foo '''2>/dev/null'''</div>
 
You can specify as many places to search as you wish:
 
<div style="margin-left:0cm;margin-right:0cm;">find /tmp /var/tmp . $HOME -name foo</div>
 
=== {{anchor|RefHeading5688100347735}} Ausdrücke  ===
 
Ein Ausdruck besteht aus Optionen (welche das allgemeine Verhalten der Kommandos bestimmen und immer wahr zurückgeben), Tests (welche wahr oder falsch zurückgeben) und Aktionen (welche wahr oder falsch zurückgeben).
 
Optionen, Tests und Aktionen werden über Operatoren verknüpft. Wenn kein Operator explizit angeben ist, wird der UND Operator -and verwendet.
 
Wenn der Ausdruck keine andere Aktion als -prune enthält, wird mit allen Dateien, für welche der Ausdruck wahr ergibt, die Aktion -print durchgeführt.
 
=== {{anchor|RefHeading18714469115403}} Exit Status ===
 
Der Status von find ist Null, wenn alle Aktionen erfolgreich waren, im Fehlerfall ist der Status größer als Null.
 
=== {{anchor|RefHeading4342100347735}} Tests ===
 
Ein Kriterium kann einen oder mehrere atomare Tests umfassen.
 
==== {{anchor|RefHeadingToc5430498221824}} -true  ====
 
ist immer wahr
 
==== {{anchor|RefHeadingToc5392498221824}} -false  ====
 
ist immer falsch
 
=== {{anchor|RefHeading18704469115403}} Optionen ===
 
'''Sollten am Anfang des Ausdrucks stehen'''
 
Alle Optionen geben immer logisch wahr zurück.
 
Mit der Ausnahme von -follow und -daystart haben sie immer Auswirkungen und werden nicht erst dann verarbeitet, wenn ihre Position im Ausdruck erreicht wird.
 
Daher sollten ist es für bessere Lesbarkeit besser, sie an den Anfang des Ausdrucks zu stellen.
 
Eine Warnung wird ausgegeben, wenn Sie das nicht machen.
 
==== {{anchor|RefHeadingToc5374498221824}} -noleaf  ====
 
erzwingt die Bearbeitung aller Verzeichniseinträge
 
Normalerweise kann davon ausgegangen werden, dass jedes Linuxverzeichnis wenigstens zwei (harte) Links enthält: * das Verzeichnis . ist ein Link auf das Verzeichnis selbst, und jedes Unterverzeichnis enthält den Eintrag
* .. als Link auf das Oberverzeichnis
 
 
 
Wenn find bei der Untersuchung eines Verzeichnisses zwei Unterverzeichnisse weniger untersucht hat, als das Verzeichnis Links zählt, kann deshalb normalerweise die weitere Suche beendet werden
 
==== {{anchor|RefHeading529831158963051}} Suche abbrechen ====
 
Es besteht aber die Möglichkeit, eine Suche abzubrechen, sobald im Verzeichnis- oder Dateinamen ein bestimmtes Textmuster enthalten ist.
 
Dem jeweiligen Suchkriterium ("-name" oder "-path") ist die Option -prune hinten an zu stellen:
 
<div style="margin-left:0cm;margin-right:0cm;"><nowiki># Anzeige alle Dateien "-print", deren Name nicht mit einem Punkt beginnt</nowiki>
find . -path './.*' -prune -o -print
.
./nsmail
./iglinux.tgz
./linuxbuch </div>
 
=== {{anchor|RefHeading7158315101596}} Suchkriterien ===
 
Alle numerischen Argumente können auf drei Arten angegeben werden:
 
 
{| style="border-spacing:0;margin:auto;width:17.51cm;"
|-
|-
| style="border-top:0.05pt solid #000000;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding-top:0.15cm;padding-bottom:0.15cm;padding-left:0.349cm;padding-right:0.349cm;" | '''+ N '''
! Programm !! Beschreibung
| style="border:0.05pt solid #000000;padding-top:0.15cm;padding-bottom:0.15cm;padding-left:0.349cm;padding-right:0.349cm;" | steht für alle Zahlen größer als N
|-
|-
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding-top:0.15cm;padding-bottom:0.15cm;padding-left:0.349cm;padding-right:0.349cm;" | '''- N '''
| [[locate]] || Suche nur nach Dateinamen
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:0.05pt solid #000000;padding-top:0.15cm;padding-bottom:0.15cm;padding-left:0.349cm;padding-right:0.349cm;" | steht für alle Zahlen kleiner als N
* Sehr schnell, da Indexbasiert, der täglich aktualisiert wird
* Findet jedoch nur Dateien, die im Index enthalten sind
|-
|-
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding-top:0.15cm;padding-bottom:0.15cm;padding-left:0.349cm;padding-right:0.349cm;" | '''N '''
| [[whereis]] || Suche nach Programmen
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:0.05pt solid #000000;padding-top:0.15cm;padding-bottom:0.15cm;padding-left:0.349cm;padding-right:0.349cm;" | steht für genau N
|-
|-
|}
| Aktuelles Verzeichnis ||
* Alle Tests werden auf die Dateien in den angegebenen Verzeichnissen einzeln angewendet.
* [http://wiki.ubuntuusers.de/Terminal#Vervollstaendigen-lassen-nicht-tippen automatischer Vervollständigung]
* Die Tests liefern einen Wahrheitswert von 0 (Wahr), wenn der Test erfolgreich war.
* Jokerzeichen zum Beispiel ''*'' und ''?''
* Die Tests auf die erweiterten Zeitmarken (Zugriff und Erstellung) werden nur in solchen Verzeichnissen korrekt behandelt, die auf einem der neuen Linuxdateisysteme angesiedelt sind (e2fs, xiafs, new minix).
* Auf den anderen Dateisystemen wird nur das Datum der letzten Änderung zuverlässig getestet.
* Das Ergebnis der anderen Tests hängt davon ab, ob der letzte Zugriff bzw. die letzte Änderung so kurz zurückliegen, dass die veränderte I-Node noch im Arbeitsspeicher (Cache) ist.
* Dann können auch für die Dateien der alten Dateisysteme alle drei Zeitmarken unterschieden werden.
 
 
 
=== {{anchor|RefHeadingToc5811201713809}} Suchbereich ===
 
==== {{anchor|RefHeading7164315101596}} Startverzeichnis(se) ====
 
Suche nach allen Dateien und allen Unterverzeichnissen im aktuellen Verzeichnis:
 
<div style="margin-left:0cm;margin-right:0cm;">find </div>
 
Suche nach allen Dateien und Verzeichnissen im Unterverzeichnis '''foo''' des aktuellen Verzeichnisses:
 
<div style="margin-left:0cm;margin-right:0cm;">find foo </div>
 
Suche alle Dateien und Verzeichnisse im übergeordneten Verzeichnis:
 
<div style="margin-left:0cm;margin-right:0cm;">find ../  </div>
 
Suche in einem ganz anderen Verzeichnis beginnen (im absoluten Pfad '''/tmp'''):
 
<div style="margin-left:0cm;margin-right:0cm;">find /tmp  </div>
 
Suche in zwei Verzeichnissen (sucht sowohl in '''/tmp''' als auch in '''/boot'''):
 
<div style="margin-left:0cm;margin-right:0cm;">find /tmp /boot </div>
 
Suche überall (Sucht im Wurzelverzeichnis alle Dateien und alle Unterverzeichnisse - das kann dauern!):
 
<div style="margin-left:0cm;margin-right:0cm;">find / </div>
 
==== {{anchor|RefHeading11792977924429}} Verzeichnistiefe  ====
 
<div style="margin-left:0cm;margin-right:0cm;">find -maxdepth 3 </div>
 
steigt bei der Suche nur 3 Verzeichnisebenen herab.
 
===== {{anchor|RefHeading7021139995267}} Limit Searches =====
 
Sometimes <tt>find</tt> provides more results than you need, or want. You can limit <tt>find</tt> results by using the '''-maxdepth''' option. For example, if you wanted to find every JavaScript file in your wordpress directory, you would use this:
 
<div style="margin-left:0cm;margin-right:0cm;">find wordpress -name '*js'</div>
 
But what if you only want to see if there are any JavaScript files in the top-level directory? You can limit that with '''-maxdepth''':
 
<div style="margin-left:0cm;margin-right:0cm;">find wordpress -maxdepth 1 -name '*js'
    </div>
 
That will only search the '''wordpress''' directory, but not any of the subdirectories. Changing the '''-maxdepth''' to 2 would search subdirectories in the wordpress directory, but it would exclude their subdirectories.
 
===== {{anchor|RefHeadingToc5366498221824}} -depth  =====
 
bearbeitet den Inhalt jedes Verzeichnisses vor dem Verzeichnis selbst.
 
===== {{anchor|RefHeadingToc5370498221824}} -maxdepth Ebenen  =====
 
steigt bis zu der gegebenen Zahl von Ebenen im Verzeichnisbaum auf (in der Hierarchie ab); bei 0 Ebenen werden die Tests nur auf die in der Kommandozeile übergebenen Dateien und Verzeichnisnamen angewendet
 
===== -maxdepth <n> =====
 
Suche nach Dateien, die sich maximal n Verzeichnisebenen unter dem angegebenen Verzeichnis befinden.
 
===== {{anchor|RefHeadingToc5372498221824}} -mindepth Ebenen  =====
 
steigt mindestens die gegebene Zahl von Ebenen im Verzeichnisbaum auf (in der Hierarchie ab); bei einer Ebene werden die in der Kommandozeile genannten Dateien und Verzeichnisnamen nicht bearbeitet
 
===== -mindepth <n> =====
 
Gehe mindestens <n> Verzeichnisebenen unter das angegebene Verzeichnis zurück, bevor die Suche gestartet wird.
 
==== {{anchor|RefHeading48441884156278}} Verzeichnisse ausschließen ====
 
Use the prune switch, for example if you want to exclude the misc directory just add a -path ./misc -prune -o to your find command:
 
<div style="margin-left:0cm;margin-right:0cm;">find . -path ./misc -prune -o -name '*.txt' -print</div>
 
Here is an example with multiple directories:
 
<div style="margin-left:0cm;margin-right:0cm;">find . -type d \( -path dir1 -o -path dir2 -o -path dir3 \) -prune -o -print</div>
<div style="margin-left:0cm;margin-right:0cm;">find / \( -path /etc -o -path /dev -o -path /proc -o -path /sys \) -prune -o -name fstab -print </div>
 
Here we exclude dir1, dir2 and dir3, since in find expressions it is an action, that acts on the criteria -path dir1 -o -path dir2 -o -path dir3 (if dir1 or dir2 or dir3), ANDed with type -d. Further action is -o print, just print.* shouldn't find . -name ./misc ... be find . -path ./misc ...?
* Hmm. This doesn't work for me either as it will include the ignored directory "./misc" in the output.
* Try to use misc instead of ./misc, that worked for me
* It probably didn't work for you because you didn't add a -print (or any other action) explicitly after -name. In that case, both "sides" of -o end up printing, whereas if you use -print, only that side prints.
 
 
 
===== All answers using -prune are wrong. The right way is: =====
 
<div style="margin-left:0cm;margin-right:0cm;">find -name "*.js" -not -path "./directory/*"</div>* One of the comments in the accepted answer points out the problem. -prune does not exclude the directory itself, it exclude its content, which means you are going to get an unwanted line in the output with the excluded directory. –
* Great answer. I'd add to this that you can exclude a directory at ANY level by changing the first . to *. so find -name "*.js" -not -path "*/omitme/*" would omit files from a directory named "omitme" at any level of depth.
* It still traverses all of the unwanted directory, though. I'm adding my own answer. :-)
* Note, however, that the prune option only doesn't work if you don't use -print explicitly.
* It would be better to say "This is an alternative to using -prune". The answers suggesting -prune are clearly not wrong, they just aren't the way you would do it.
 
 
 
==== {{anchor|RefHeading5686100347735}} Umgang mit symbolischen Links ====
 
Die Optionen -H, -L und -P bestimmen den Umgang mit symbolischen Links* Darauf folgende Kommandozeilenparamter müssen die Datei- oder Verzeichnisnamen sein, die untersucht werden sollen.
* Das erste Argument, das mit einem -, einer Klammer (, ), einem Komma , oder einem Ausrufezeichen ! beginnt, wird als Anfang eines Ausdrucks interpretiert, der bestimmt, wonach gesucht wird.
* Alle Argumente davor werden als Verzeichnisnamen angesehen.
* Wenn kein Verzeichnis angegeben ist, wird das aktuelle Verzeichnis genommen.
* Wenn keine Aktion angegeben ist, wird die Aktion -print ausgeführt (es wird stattdessen empfohlen -print0 zu verwenden).
 
 
 
===== -P  =====
 
Keinen symbolischen Links folgen* Dies ist das Standardverhalten.
* Wenn find eine Datei untersucht oder Informationen über diese ausgibt, und die Datei ein symbolischer Link ist, dann werden die Informationen von dem symbolischen Link selbst verwendet.
 
 
 
===== -L  =====
 
Symbolischen Links folgen* Wenn find eine Datei untersucht oder Informationen über diese ausgibt, dann werden die Informationen von der Datei verwendet, auf die der symbolische Link verweist (es sei denn, der Link ist kaputt oder find nicht in der Lage ist, die Datei zu untersuchen, auf die der Link zeigt).
* Die Verwendung dieser Option impliziert die Option -noleaf.
* Wenn Sie später die Option -P verwenden, wird -noleaf immer noch Auswirkungen zeigen. Wenn -L aktiv ist und find einen symbolischen Link zu einem Unterverzeichnis während seiner Suche findet, wird das Unterverzeichnis durchsucht, auf das der symbolische Link zeigt.
* Wenn die Option -type immer auf den Typ der Datei angewendet, auf die ein symbolischer Link zeigt, anstatt auf den Link selbst (es sei denn, der symbolische Link ist kaputt).
* Die Verwendung von -L bewirkt, dass die Prädikate -lname und -ilname immer logisch falsch zurückliefern.
 
 
 
===== -H  =====
 
Keinen symbolischen Links folgen, es sei denn …* ...die Parameter in der Kommandozeile werden ausgewertet.
* Wenn find Dateien auswertet oder Informationen über diese ausgibt, werden die verwendeten Informationen vom symbolischen Link selbst benutzt werden.
* Die einzige Ausnahme dieses Verhaltens ist, wenn eine in der Kommandozeile angegebene Datei ein symbolischer Link ist und dem Link gefolgt werden kann.
* In dieser Situation werden die Informationen der Datei genommen, auf die der symbolische Link verweist.
* Die Informationen über den Link selbst dienen als Fall-Back für den Fall, dass die Datei, auf die der Link zeigt, nicht untersucht werden kann.
* Wenn -H aktiv ist und einer der Pfade in der Kommandozeile ein symbolischer Link zu einem Verzeichnis ist, werden die Inhalte dieses Verzeichnisses untersucht (wobei natürlich -maxdepth 0 das verhindern kann).
 
 
 
 
 
===== {{anchor|RefHeadingToc5368498221824}} -follow  =====
 
Veraltet. Verwenden Sie die Option -L stattdessen. Dereferenziert symbolische Links. Impliziert -noleaf. Wenn die Option -H oder -L nicht angegeben wird, ändert die Position von -follow das Verhalten des Prädikats -newer.
 
Alle Dateien, die als Argumente von -newer aufgeszählt sind, werden dereferenziert, wenn es sich bei ihnen um symbolische Links handelt. Das gleiche gilt für -anewer und -cnewer. Genauso wird das Prädikat -type immer auf den Typ der Datei angewendet, auf den der symbolische Link zeigt und nicht auf den Link selbst. Die Verwendung von -follow hat zur Folge, dass die Prädikate -lname und -ilname immer logisch falsch zurückliefern.
 
==== Dateisysteme ====
 
===== {{anchor|RefHeadingToc5376498221824}} -xdev  =====
 
durchsucht keine Verzeichnisse in anderen Dateisystemen/Partitionen
 
===== {{anchor|RefHeadingToc5394498221824}} -fstype Typ  =====
 
die Datei ist in einem Dateisystem vom angegebenen Typ; unter anderem werden minix, msdos, ext und proc erkannt
 
=== {{anchor|RefHeading7168315101596}} Name ===
 
Mit vollständigem Namen
 
<div style="margin-left:0cm;margin-right:0cm;">find -name hausarbeit.odt</div>
 
Sucht die Datei '''hausarbeit.odt''' im aktuellen Verzeichnis und allen Unterverzeichnissen. Sind mehrere Dateien dieses Namens vorhanden, werden alle Fundstellen aufgelistet. Jokerzeichen, [http://de.wikipedia.org/wiki/Wildcard_%28Informatik%29 Wildcards], wie der <tt><nowiki>*</nowiki></tt> oder das <tt>?</tt> müssen maskiert werden, sonst interpretiert sie schon die Shell.
 
<div style="margin-left:0cm;margin-right:0cm;">find -name "*.pdf"  </div>
 
Sucht im aktuellen Verzeichnis nach PDF-Dateien. <tt>-name</tt> berücksichtigt die Groß-/Kleinschreibung bei der Suche, findet also mit obigen Beispiel keine Datei(en) mit Endung '''<nowiki>*.PDF</nowiki>'''. Das <tt><nowiki>*</nowiki></tt> steht für eine beliebige Anzahl Zeichen.
 
<div style="margin-left:0cm;margin-right:0cm;">find -iname "a*.pdf"  </div>
 
Sucht im aktuellen Verzeichnis nach '''.pdf'''- und '''.PDF'''-Dateien, die mit <tt>a</tt> oder <tt>A</tt> beginnen.
 
<div style="margin-left:0cm;margin-right:0cm;">find -name "katze.*"  </div>
 
findet '''katze.jpg''', '''katze.png''', '''katze.txt''' usw.
 
<div style="margin-left:0cm;margin-right:0cm;">find -name "katze.??g"  </div>
 
findet '''katze.jpg''', '''katze.png''' usw. Jedes Fragezeichen steht für ein einzelnes Zeichen.
 
<div style="margin-left:0cm;margin-right:0cm;">find -name "*foo*.*x*"  </div>
 
findet '''foo.x''', '''afoo.x''', '''foob.txt''' usw.
 
==== -name <Muster> ====
 
Finde Dateien, deren Name <tt><Muster></tt> entspricht. Mit dieser Option wird <tt><Muster></tt> wie ein Suchmuster behandelt (siehe Kapitel [http://www.murnauer.de/mandrakeref/glob-regex.html Suchmuster und Reguläre Ausdrücke]).
 
==== -iname <Muster> ====
 
Findet Dateien mit Name, wie <tt>-name</tt>, ignoriert jedoch Groß- und Kleinschreibung.
 
==== {{anchor|RefHeading4354100347735}} -path Name ====
 
Findet Dateien mit Name, wobei Name auch Pfadangaben enthalten kann ("*/include/*.h")
 
Sucht man mit Verzeichnisnamen, in denen ein Schrägstrich '/' vorkommt, kommt man mit '-name' nicht weiter.
 
Der Parameter '-path' ist hier die Lösung, denn er erlaubt die Interpretation des Zeichens '/'.
 
<div style="margin-left:0cm;margin-right:0cm;">find -path "*2013/J*" </div>
 
findet '''~/fotos/2013/Juni''' und '''~/musik/2013/Juli''', aber nicht '''~/dokumente/2013-Juni'''
 
==== {{anchor|RefHeading11798977924429}} Reguläre Ausdrücke ====
 
<tt>find</tt> hat nicht nur einfach RegEx-Support, es beherrscht auch mehrere unterschiedliche Arten der RegEx-Syntax.
 
Mit <tt>-regextype</tt> und eine der unterstützten Arten wie ''posix-awk'', ''posix-egrep'', kannst du den Typ wählen. Lies unter <tt>man find</tt> nach, welche Arten unterstüzt werden.
 
Ein kurze Beispiel. Sagen wir ich suche alle Dateien die entweder eine .php oder .js Endung. Ich könnte das folgende laufen lassen:
 
<div style="margin-left:0cm;margin-right:0cm;">find -regextype posix-egrep -regex '.*(php|js)$'</div>* die egrep-Syntax <tt>-regextype posix-egrep</tt> zu benutzen und hinten kommt der Reguläre Ausdruck nach dem gesucht wird.
* Der Ausdruck beginnt und endet mit einem Hochkomma, damit die Shell nicht versucht die RegEx auszuwerten.
* Der Ausdruck <tt>.*</tt> ist ein Joker und bedeute „ein oder mehr beliebige Zeichen“. <tt>(php|js)</tt> weist an nach ''php'' oder ''js'' zu suchen.
* Die Pipe (|) steht hier für "oder".
* Das Dollarzeichen "$" hinten weist an, den Ausdruck am Ende eines Strings zu suchen.
* Also trifft etwa eine Datei namens ''js.txt'' nicht auf die Abfrage zu.
 
 
 
===== {{anchor|RefHeading4396100347735}} -regex Muster =====
 
Wie "-name", nur kann das Muster reguläre Ausdrücke enthalten
 
===== {{anchor|RefHeadingToc5426498221824}} -regex Muster  =====
 
der Pfadname passt zu dem regulären Ausdruck Muster
 
===== -regex <Muster>:  =====
 
Wie <tt>-name</tt>, jedoch wird hier <tt>Muster</tt> als re­gulärer Ausdruck behandelt.
 
===== {{anchor|RefHeading4398100347735}} -iregex Muster =====
 
Wie „-regex“ jedoch ohne Groß-/keinschreibung zu beachten
 
===== -iregex <Muster>:  =====
 
Wie <tt>-regex</tt>, ignoriert aber Groß- und Kleinschreibung.
 
===== {{anchor|RefHeading4400100347735}} -regextype type =====
 
Ändert die Syntax der regulären Ausdrücke, die von -regex und -iregex verstanden werden. Folgende Typen sind implementiert: emacs (Standard), posix-awk, posix-basic, posix-egrep und posix-extende
 
=== {{anchor|RefHeading7166315101596}} Dateitypen ===
 
==== {{anchor|RefHeading4348100347735}} -type Typ ====
 
Findet Dateien eines bestimmten Types
 
 
{| style="border-spacing:0;width:17.494cm;"
|-
| style="border-top:0.05pt solid #000000;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding:0.097cm;" | b
| style="border-top:0.05pt solid #000000;border-bottom:0.05pt solid #000000;border-left:none;border-right:none;padding:0.097cm;" |
|-
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding:0.097cm;" | c
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:none;border-right:none;padding:0.097cm;" |
|-
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding:0.097cm;" | d
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:none;border-right:none;padding:0.097cm;" |
|-
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding:0.097cm;" | p
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:none;border-right:none;padding:0.097cm;" |
|-
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding:0.097cm;" | f
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:none;border-right:none;padding:0.097cm;" |
|-
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding:0.097cm;" | l
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:none;border-right:none;padding:0.097cm;" |
|-
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding:0.097cm;" | s
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:none;border-right:none;padding:0.097cm;" |
 
 
|-
|-
| Weitere || Manche Programme an, Unterverzeichnisse zu berücksichtigen
* [[ls]]
* [[grep]]
|}
|}
===== Finde nur Dateien  =====
<div style="margin-left:0cm;margin-right:0cm;">find -type f  </div>
Das <tt>f</tt> steht für 'files'. Findet keine Verzeichnisse, aber alle herkömmlichen Dateien in allen Unterverzeichnissen.
===== Finde nur Verzeichnisse  =====
<div style="margin-left:0cm;margin-right:0cm;">find -type d  </div>
Das <tt>d</tt> steht für 'directories'. Findet alle Unterverzeichnisse, aber keine sonstigen Dateien.
==== {{anchor|RefHeadingToc5432498221824}} -type C  ====
die Datei ist vom Typ C; folgende Typen werden unterschieden:
b gepufferte Gerätedatei für ein blockorientiertes Gerät c ungepufferte Gerätedatei für ein zeichenorientiertes Gerät d Verzeichnis p benannte Pipeline (FiFo) f normale Datei l symbolischer Link s Socket
==== {{anchor|RefHeadingToc5440498221824}} -xtype C  ====
das gleiche wie -type für alle Dateien, die keine symbolischen Links sind; wenn die Datei ein symbolischer Link ist und die Option -follow nicht gesetzt ist, wird die Datei, auf die der Link zeigt, auf den Typ C geprüft; wenn die Option -follow gesetzt ist, ist der Test wahr, wenn C = l ist
==== -type <Typ>:  ====
Suche nach einem bestimmten Dateityp. <tt><Typ></tt> kann folgende Werte annehmen: <tt>f</tt> (reguläre Datei), <tt>d</tt> (Verzeichnis), <tt>l</tt> (symbolischer Verweis), <tt>s</tt> (Socket), <tt>b</tt> (Blockdatei), <tt>c</tt> (Zeichendatei) oder <tt>p</tt> (benannte Umleitung).
=== {{anchor|RefHeading7174315101596}} Datum/Zeit ===
==== Zeitstempel von Dateien ====
Die Zeitstempel der Dateien sind in Linux in den [http://wiki.linux-club.de/opensuse/Inode Inodes] abgelegt.
Dort stehen jeweils 4 Zeitstempel, wovon jedoch einer für den Anwender nicht sichtbar und auch nicht von Interesse ist, den verwendet Linux im Filesystem zum Verwalten der gelöschten Inode, er enthält die Zeit, zu der die Datei gelöscht worden ist, und somit der Inode für eine neue Verwendung frei geworden ist.
Derzeit kommt im ext3/4 Filesystem noch ein weiterer Zeitstempel hinzu, auf den wohl so mach ein ehemaliger Windowsuser schon lange gewartet hat, und der die wirkliche Entstehungszeit der Datei dokumentiert.
Dazukommen bedeutet, in aktuellen Systemen ist er intern schon da, allerdings war dies das geringste Problem. Das Hauptproblem jetzt, es müssen sehr viele, zum Teil auch zentrale Librarys und Programme, auf eine mögliche Benutzung dieses Zeitstempels noch angepasst werden.
Solche weitreichenden Änderungen könnten nur durch eine gezielte Koordinierung von zahlreichen Projekten schnell eingebracht werden.
Es wird also durchaus noch einiges Wasser die Flüsse herunterfließen, bis Otto der Normalanwender letztlich diesen Zeitstempel irgendwann einmal zu Gesicht bekommt, bzw. bis er wirklich auch damit arbeiten kann.
===== Access Time (atime) =====
Diese Zeit wird jedes mal neu gesetzt, wenn der Inhalt der Datei geöffnet worden ist. In ihm wird also der letzte Zugriff auf den Inhalt der Datei angezeigt.
Dabei ist es für diesen Zeitstempel von Bedeutung, ob die Datei vor einem schreiben erst gelesen wird oder nur an das Ende weitergeschrieben wird.
Ansonsten gilt, egal ob die Datei gelesen oder ausgeführt wird oder ob eine Kopie von dieser Datei gemacht wird, oder die Datei durchsucht wird, oder die Datei in ein Backuparchiv aufgenommen wird - immer wird dieser Zeitstempel neu auf die aktuelle Zeit gesetzt.
Durch die Auswertung dieses Zeitstempels könnten wir also z.B. feststellen, das wir eine Datei schon einen längeren Zeitraum nicht mehr angefasst haben.
Das kann unter Anderem dabei helfen alte temporäre User- oder Systemdateien zu löschen.
Das ständige setzen der Access Time von Dateien und Verzeichnissen kann bei sehr vielen Zugriffen in einem Filesystem eine nicht unbedeutende Last verursachen, in bestimmten Situationen ist dieses aus Performancegründen nicht gewünscht, und kann deshalb z.B. mit Mountoptionen des Filesystems für alle Dateien oder alle Verzeichnisse abgeschaltet werden.
Einige Filesysteme erlauben auch ein gezieltes Abschalten dieser ständigen atime Aktualisierungen für ausgewählte Dateien oder Verzeichnisse.
===== Modify Time (mtime) =====
Diese Zeit wird gesetzt, wenn der Inhalt der Datei verändert wird. In diesem Zeitstempel steht also die Zeit der letzten Veränderung der Dateidaten.
Es ist der Zeitstempel der für uns die meiste Bedeutung hat. Können wir doch damit feststellen, wie aktuell die Dateidaten sind. Diese Zeit wird z.B. bei ls -l in der default Einstellung angezeigt.
===== Change Time (ctime) =====
Fälschlicher Weise wird ctime oftmals mit Create Time übersetzt und somit herrscht über diesen Zeitstempel oftmals eine ganz falsche Vorstellung.
Mit diesem Zeitstempel wird die Zeit gespeichert, zu welcher das letzte Mal die Daten innerhalb des Inodes geändert worden sind.
Wenn man sich anschaut, welche Daten im [http://wiki.linux-club.de/opensuse/Inode Inode] enthalten sind, kann man schon erahnen, wann diese Zeit neu gesetzt wird.
Bei einem Ändern des Dateiinhaltes werden die Dateigröße sowie die Datenblöcke neu gesetzt, beim Ändern der Zugriffsrechte, der UserID oder GruppenID, beim Anlegen eines neuen Hardlinks immer wird auch der Inhalt des Inodes geändert und damit auch die ctime neu gesetzt.
Aber auch bei einem Umbenennen der Datei, wird die ctime neu gesetzt, (man muss sich dabei vorstellen, das beim Umbenennen die Anzahl der "Links" zuerst um 1 erhöht wird, dann wird der neue Name angelegt, und dann anschließend der alte Name gelöscht und die "Links" wieder um 1 verringert).
Es gibt eine einzige Ausnahme bei der die ctime nicht gesetzt wird: wenn durch das Auslesen der Datei nur die Access Time im Inode neu gesetzt wird, also die Datei z.B. ausgelesen wird, dann wird die Change Time nicht neu gesetzt.
Dieser Zeitstempel hat z.B. eine große Bedeutung fürs Backup, da damit nicht nur festgestellt werden kann, ob sich der Inhalt der Datei sondern z.B. auch der Name oder die Eigentums- oder Zugriffsrechte einer Datei seit dem letzten Backup geändert haben.
Während sich die anderen beiden Zeitstempel durch Befehle auf eine bestimmte Zeit manipulieren lassen, ist es nicht möglich die ctime auf diese Art zu setzen.
What if you want to find files by their age? This is something that can be useful if you're trying to find a file that you know you created within a certain timeframe, or if you want to look for older files to delete. Lots of good reasons, actually.
The <tt>find</tt> utility is all about finding by time. You can search by access time ('''-atime''') or the last time a file was modified ('''-mtime''') or by the last time it was changed ('''-ctime''').
For example, let's look for any files that have not been modified in the last two days:
<div style="margin-left:0cm;margin-right:0cm;">find -mtime +2</div>
The options take a number that is interpreted as "n times 24 hours ago" and actually encompass a range. If you say +1, <tt>find</tt> will interpret that as "at least 24 hours ago, but not more than 48 hours ago."
You can combine the options, if you want to look for files within a specific range. So '''find -mtime +2 -mtime -5''' would be "two or more days ago, but not more than five days ago."
===== Unterschiede bei Dateitypen =====
Bei der Interpretation der Zeitstempel müssen wir weiterhin unterscheiden, ob es sich um eine "normale" Datei oder z.B. um ein [http://wiki.linux-club.de/opensuse/Directory Verzeichnis] handelt.
Die Funktion der Zeitstempel ist bei allen Dateitypen prinzipiell gleich, allerdings durch den speziellen Aufbau und die Funktion einzelner Dateitypen ergibt sich eine etwas andere Betrachtungsweise.
Bei den Verzeichnissen bedeutet die atime, das Verzeichnis wurde gelesen z.B. mit ls, die mtime bedeutet es wurde in diesem Verzeichnis an den Namen der Dateien etwas geändert, oder Dateien sind in diesem Verzeichnis dazu gekommen oder entfernt worden.
Pipes und Geräteknoten zeigen prinzipiell analoges Verhalten wie normale Dateien, es gibt jedoch einige Besonderheiten bei Symbolischen Links.
Die atime wird hier immer dann gesetzt, wenn über diesen Weg auf die verlinkte Datei zugegriffen wird. Die ctime wird gesetzt bei Eigentumswechsel oder Umbenennen der Datei.
Da der eigentliche Inhalt des Softlinks, der Verweis auf die Datei nicht geändert werden kann, wird die mtime nur bei der Erstellung des Softlinks gesetzt.
Beim Versuch mittels chmod oder touch auf den Inode des Softlinks zuzugreifen, wird statt dessen dem Link gefolgt und der Zugriff erfolgt dort auf den Inode der verlinkten Datei.
==== {{anchor|RefHeading4370100347735}} Tage ====
<div style="margin-left:0cm;margin-right:0cm;">find -mtime -365 </div>
Sucht nach Dateien, deren Inhalt innerhalb der letzten 365 Tage geändert wurde (<tt>mtime</tt> = modification time). Weitere Optionen sind * <tt>ctime</tt> (change time): Zeitpunkt, an dem der Status der Datei geändert wurde (Name, Rechte)
* <tt>atime</tt> (access time): Zeitpunkt an dem auf die Datei zugegriffen wurde.
Ein Dateilisting selbst ist damit nicht gemeint. Bei Bilddateien zählt die Vorschaufunktion eines grafischen Dateimanagers aber bereits als Zugriff.
Auch hier gibt es, ähnlich wie bei der [http://wiki.ubuntuusers.de/find#Nach-Dateigroesse-suchen Größe], Mindestalter (<tt>+</tt>), Höchstalter (<tt>-</tt>) und genaues Alter.
==== {{anchor|RefHeadingToc5412498221824}} -newer Referenzdatei  ====
die Datei ist später verändert worden als die Referenzdatei; zusammen mit -follow tritt -newer nur in Effekt, wenn -follow vor -newer in der Kommandozeile steht
==== {{anchor|RefHeadingToc5436498221824}} -used N  ====
auf die Datei ist N Tage nach der letzten Änderung zugegriffen worden
==== {{anchor|RefHeading4378100347735}} -atime Tage ====


Findet Dateien, auf die vor Tagen zugegriffen wurden (zur Angabe von Bereichen siehe Option "amin")
== Installation ==
<syntaxhighlight lang="bash" highlight="1" line>
apt install findutils
</syntaxhighlight>


==== -atime <n>, -amin <n> ====
== Aufruf ==
<syntaxhighlight lang="bash" highlight="1" line>
find [-H] [-L] [-P] [-D Fehlersuchoptionen] [-OStufe] [Startpunkt …] [Ausdruck]
</syntaxhighlight>


Finde Dateien, auf die zuletzt vor <tt><n></tt> Tagen (<tt>-atime</tt>) oder <tt><n></tt> Minuten (<tt>-amin</tt>) zugegriffen wurde. Sie können auch <tt>+<n></tt> oder <tt>-<n></tt> spezifizieren. Dann wird nach Dateien gesucht, auf die vor höchstens, bzw. mindestens <tt><n></tt> Tagen, bzw. Minuten zugegriffen wurde.
=== Optionen ===
 
{| class="wikitable sortable options"
==== {{anchor|RefHeadingToc5382498221824}} -atime N  ====
 
auf die Datei ist vor N*24 Stunden zugegriffen worden
 
==== {{anchor|RefHeadingToc5380498221824}} -anewer Referenzdatei  ====
 
auf die Datei ist vor weniger Zeit zugegriffen worden, als seit der letzten Veränderung der Referenzdatei vergangen ist; im Zusammenhang mit -follow tritt -anewer nur in Effekt, wenn -follow vor -anewer in der Kommandozeile steht
 
==== -anewer <Datei> ====
 
Findet Dateien auf die später zugegriffen wurde als auf Datei <tt><Datei></tt>
 
==== {{anchor|RefHeading4380100347735}} -amin Minuten ====
 
Findet Dateien, auf die vor Minuten zugegriffen wurden. Um bspw. alle Dateien zu finden, deren Zugriff vor 2 bis 8 Minuten geschah, können die Angaben kombiniert werden: "-amin +2 -amin -8".
 
==== {{anchor|RefHeadingToc5378498221824}} -amin N  ====
 
auf die Datei ist vor N Minuten zugegriffen worden
 
==== Minuten  ====
 
Sometimes you need to look for files modified in the last day or so, and the previous options are a bit too broad for that.
 
The good news is that <tt>find</tt> also has the '''-amin''', '''-cmin''', and '''-mmin''', which are similar to the other options but they work with minutes rather than days.
 
So if you want to look for something that was changed or accessed in the last day, you can use those options.
 
<div style="margin-left:0cm;margin-right:0cm;">find -amin -5 </div>
 
nach Dateien suchen, auf die in den letzten 5 Minuten zugegriffen wurde. Analog: <tt>-cmin</tt>, <tt>-mmin</tt>.
 
==== {{anchor|RefHeading4376100347735}} Alle Dateien, auf die in der letzten Minute zugegriffen wurde ====
 
Um die nachfolgende Suche erfolgreich enden zu lassen, manipulieren wir mit Hilfe von "touch" die Zugriffszeiten einiger Dateien
 
<div style="margin-left:0cm;margin-right:0cm;">'''touch sax*
find . -amin 1
.'''
./saxsys.tgz
./sax_logo.gif</div>
 
==== -ctime <n>, -cmin <n>, -cnewer <Datei> ====
 
Genau wie <tt>-atime</tt>, <tt>-amin</tt> und <tt>-anewer</tt>, doch in Bezug auf die letzte Inhaltsänderung der Datei.
 
==== {{anchor|RefHeadingToc5388498221824}} -ctime N  ====
 
der Dateistatus wurde vor N*24 Stunden geändert
 
==== {{anchor|RefHeadingToc5384498221824}} -cmin N  ====
 
der Status der Datei wurde vor N Minuten geändert
 
==== {{anchor|RefHeadingToc5386498221824}} -cnewer Referenzdatei  ====
 
der Status der Datei wurde vor weniger Zeit verändert, als seit der letzten Veränderung der Referenzdatei vergangen ist; zusammen mit -follow tritt -cnewer nur in Effekt, wenn -follow vor -cnewer in der Kommandozeile steht
 
===== {{anchor|RefHeading4374100347735}} Vergleich  =====
 
<div style="margin-left:0cm;margin-right:0cm;">find -cnewer /tmp/referenz </div>
 
Nach Dateien suchen, die nach der Referenzdatei geändert wurden. Mit <tt>touch --date='15:00' /tmp/referenz</tt> erstellt man sich eine Referenzdatei, wenn man keine hat.
 
==== {{anchor|RefHeading4382100347735}} -mtime Tage ====
 
Findet Dateien, die vor Tagen geändert wurden (zur Angabe von Bereichen siehe Option »amin«)
 
==== {{anchor|RefHeadingToc5408498221824}} -mtime N  ====
 
der Inhalt der Datei wurde vor IN*24 Stunden verändert
 
==== {{anchor|RefHeadingToc5406498221824}} -mmin N  ====
 
der Inhalt der Datei wurde vor N Minuten verändert
 
==== {{anchor|RefHeadingToc5364498221824}} -daystart  ====
 
mißt die Zeiten für die -amin, -atime, -cmin, -ctime, -mmin und -mtime Eigenschaften vom Beginn des aktuellen Tages anstelle der letzten 24 Stunden.
 
Diese Option betrifft nur die Tests, die weiter hinten in der Kommandozeile geschrieben sind.
 
Werden zeit-bezogene Tests durchgeführt (siehe unten), wird der Beginn des aktuellen Tages als Zeitstempel genommen (und nicht der Zeitpunkt vor 24 Stunden, was der Standard-Einstellung entspricht).
 
=== {{anchor|RefHeading7172315101596}} Größe ===
 
Manchmal ist es nützlich, andere Attribute zur Suche zu verwenden. Etwa Dateien nach Größe zu finden. Ein gutes Beispiel: du arbeitest mit einem Server und stellst fest, dass eine der Partitionen beginnt, voll zu werden.
 
Um welche Datei, oder Dateien, handelt es sich? Mit <tt>find</tt> suchst du Dateien nach Größe und kannst dich dann darum kümmern, Platz zu schaffen.
 
Die Option um nach Größe zu prüfen ist <tt>-size</tt>, gefolgt von der Größenangabe, nach der du suchst.
 
Du kannst alle möglichen Einheiten angeben, von Blöcken (b) bis Gigabytes (G). Um Dateien der Größe 100 kB zu finden, gibst du ein:
 
<div style="margin-left:0cm;margin-right:0cm;">find -size 100k</div>
 
Damit werden alle Dateien der Größe 100 kB gefunden. Das ist ziemlich speziell.
 
Um größere oder kleinere Dateien einer bestimmten Größe zu finden, verwendest du <tt>+</tt> oder <tt>-</tt> zusätzlich zur Zahl.
 
Also sollte <tt>find -size +100k</tt> alle Dateien größer als 100 kB zurückgeben. Und <tt>find -size -100k</tt> alles was kleiner ist.
 
Mit dem <tt>-empty</tt>-Parameter kannst du auch leere Dateien finden:
 
<div style="margin-left:0cm;margin-right:0cm;">find -empty -type -f </div>
 
Beachte, dass ich eine zusätzliche Prüfung für den Typ der Datei verwende. Ohne diese Option wird <tt>find</tt> Verzeichnisse als „leere Dateien“ anzeigen.
 
==== {{anchor|RefHeading4368100347735}} -size Number[Einheit] ====
 
Findet Dateien einer bestimmten Dateigröße. In der Voreinstellung ist die »Einheit« 512 Byte große Blöcke, d.h. bei Number=1 werden alle Dateien mit einer Größe zwischen 1 und 512 Bytes gefunden.
 
Als Einheit kann stehen: b für 512 Byte-Blöcke (Voreinstellung), c für 1 Byte-Blöcke, k für Kilobyte-Blöcke und w für 2 Byte-Blöcke.
 
==== {{anchor|RefHeading4356100347735}} Maximale Größe  ====
 
<div style="margin-left:0cm;margin-right:0cm;">find -size -100c -ls </div>
 
Nach Dateien suchen, die bis zu 100 Bytes belegen. Das <tt>-</tt> vor der Zahl bedeutet "bis zu". Das <tt>c</tt> hinter der Zahl bedeutet <tt>character</tt>, welche früher 1 Byte belegten, aber <tt>b</tt> ist schon für die Maßeinheit Block (= 512 Bytes) vergeben. Mittels <tt>-ls</tt> läßt sich die Größe der gefundenen Dateien überprüfen.
 
Deswegen wird es hier, vor den anderen Aktionen, erwähnt.
 
==== {{anchor|RefHeading4358100347735}} Exakte Größe  ====
 
<div style="margin-left:0cm;margin-right:0cm;">find -size 100c -ls </div>
 
nach Dateien suchen, die genau 100 Bytes groß sind (kein Vorzeichen).
 
==== {{anchor|RefHeading4360100347735}} Mindestgröße  ====
 
<div style="margin-left:0cm;margin-right:0cm;">find -size +100M </div>
 
Nach Dateien suchen, die 100 Megabytes oder größer sind (Vorzeichen <tt>+</tt>). Statt <tt>M</tt> kann man auch <tt>k</tt> und <tt>G</tt> für Kilobytes und Gigabytes angeben.
 
==== {{anchor|RefHeading4362100347735}} Zwischen Mindest- und Maximalgröße  ====
 
<div style="margin-left:0cm;margin-right:0cm;">find -type f -size +64c -size -4096c | wc -l </div>
 
Nur nach Dateien suchen, die zwischen 64 und 4096 Bytes groß sind, und per Pipe an [http://wiki.ubuntuusers.de/wc wc] übergeben, um die Anzahl der gefundenen Dateien zu bestimmen.
 
==== {{anchor|RefHeading4364100347735}} Blockgröße  ====
 
<div style="margin-left:0cm;margin-right:0cm;">find -size 10 </div>
 
Ohne Angabe zur Maßeinheit wird die Zahl als Anzahl Blöcke interpretiert, hier also nach 10 Blöcken à 512 Bytes. Die Angabe <tt>b</tt> ist gleich bedeutend. Wenn es Probleme mit der Größe gibt, dann wahrscheinlich, weil man <tt>c</tt> oder <tt>k</tt> oder <tt>M</tt> vergessen hast.
 
==== {{anchor|RefHeading4366100347735}} Leeren Dateien  ====
 
Leere Verzeichnisse und Dateien der Größe 0
 
<div style="margin-left:0cm;margin-right:0cm;">find -empty </div>
 
==== {{anchor|RefHeadingToc5390498221824}} -empty  ====
 
die reguläre Datei oder das Verzeichnis ist leer
 
==== {{anchor|RefHeadingToc5428498221824}} "size N[{c,k}]" ====
 
die Datei belegt N Datenblöcke zu 512 Bytes, bzw. N Bytes und N Kilobytes mit nachgestelltem c oder k
 
=== {{anchor|RefHeading11794977924429}} Besitzer und Gruppe ===
 
<div style="margin-left:0cm;margin-right:0cm;">find / -user BENUTZERNAME </div>
 
==== {{anchor|RefHeading7019939995267}} Dateien nach Benutzer suchen ====
 
Ein weiterer nützlicher Einsatz von <tt>find</tt> ist es, Dateien nach Besitzerstatus zu lokalisieren, sogar Dateien mit fehlendem Besitzer. Schauen wir uns das mal an.
 
Wenn du Dateien zwischen Systemen verschoben hast, oder wenn du Benutzer entfernt hast, hast du möglicherweise verwaiste Dateien. Um solche zu finden nimmst du:
 
<div style="margin-left:0cm;margin-right:0cm;">find -nouser</div>
 
Um Dateien, die tatsächlich im Besitz eines bestimmten Benutzers sind, zu finden, nimmst du die <tt>-user</tt> oder <tt>-uid</tt> Optionen. Die <tt>-uid</tt> Option erlaubt dir nach der nummerischen User-ID (UID) zu suchen und <tt>-user</tt> erlaubt dir nach Name oder UID zu suchen.
 
Also wenn ich alle meine Dateien in einem Verzeichnis finden will benutze ich <tt>find -user jzb</tt>. Oder ich könnte <tt>find -user 1000</tt> oder <tt>find -uid 1000</tt> eingeben.
 
Vielleicht suchst du die Dateien die Benutzer A ''oder'' B gehören. Das kannst du erreichen indem du den Operator <tt>-o</tt> hinzufügst:
 
<div style="margin-left:0cm;margin-right:0cm;">find -user root -o -user www-data</div>
 
Damit werden alle Dateien gefunden die Benutzer ''root'' oder ''www-data'' gehören. Wenn du umgekehrt alle Dateien finden möchtest die ''nicht'' dem bestimmten Benutzer gehören, nimmst du den <tt>-not</tt>-Operator:
 
<div style="margin-left:0cm;margin-right:0cm;">find -not -user www-data</div>
 
Natürlich funktioniert <tt>-not</tt> auch zusammen mit anderen Optionen. Du könntest nach allen Dateien suchen die einem Benutzer gehören, die nicht mehr als eine bestimmte Größe haben. Beispiel:
 
<div style="margin-left:0cm;margin-right:0cm;">find -user www-data -not -size +100k</div>
 
==== {{anchor|RefHeading4384100347735}} -user Nutzer ====
 
Findet Dateien des "Nutzers" (UID oder Nutzername)
 
===== {{anchor|RefHeading4386100347735}} Alle Dateien im Verzeichnis /tmp, die »user« gehören =====
 
<div style="margin-left:0cm;margin-right:0cm;">'''find /tmp/ -user user 2>/dev/null'''
/tmp/kfm-cache-500
/tmp/kfm-cache-500/index.html
/tmp/kfm-cache-500/index.txt
/tmp/acout.1364.NHKnJh
/tmp/acin.1364.c36auh</div>
 
==== {{anchor|RefHeading7020139995267}} Dateien nach Gruppen suchen (-group) ====
 
Eine weitere Möglichkeit, nach Dateien zu suchen ist nach Gruppe, mit der <tt>-group</tt>-Option.
 
Diese Option arbeitet mit einem Gruppennamen oder einer Gruppen-ID (GID).
 
Die grundlegende Syntax ist
 
<tt>find -group groupname</tt>.
 
Können mit anderen Operatoren kombiniert werden, um z.B. Dateien eines Benutzers zu finden, die auch zu einer bestimmten Gruppe gehören.s
 
==== {{anchor|RefHeadingToc5438498221824}} -user Name  ====
 
die Datei gehört dem Anwender Name
 
==== {{anchor|RefHeadingToc5434498221824}} -uid N  ====
 
die Kennziffer des Eigentümers ist N
 
==== {{anchor|RefHeadingToc5396498221824}} -gid N  ====
 
die Datei gehört der Gruppe mit der Kennzahl N
 
==== {{anchor|RefHeadingToc5398498221824}} -group Name  ====
 
die Datei gehört der Gruppe Name
 
==== {{anchor|RefHeadingToc5414498221824}} -nouser  ====
 
die Datei gehört keinem im System eingetragenen Benutzer
 
==== {{anchor|RefHeadingToc5416498221824}} -nogroup  ====
 
die Datei gehört keiner im System angemeldeten Gruppe
 
=== {{anchor|RefHeading11796977924429}} Zugriffsrechte ===
 
Gelegentlich möchtest du dein Dateisystem nach Dateien überprüfen, die global beschreibbar sind, oder sonstige „falsche“ Berechtigungen haben.
 
Das <tt>find</tt>-Werkzeug unterstützt dies mit mehreren verschiedenen Optionen.
 
Am einfachsten sind die Operatoren <tt>-readable</tt>, <tt>-writable</tt>, und <tt>-executable</tt>.
 
Diese prüfen die Berechtigungen des ''aktuell angemeldeten'' Benutzers, der <tt>find</tt> aufruft.
 
Beachte, dass diese Optionen in älteren Versionen von ''find'' nicht verfügbar sind.
 
Also wenn deine Distribution etwas älter ist hast du diese Optionen eventuell noch nicht.
 
Ein andere Option nach der Dateiberechtigung zu suchen ist die Benutzung von <tt>-perm</tt>, was nach dem aktuellen Dateistatus schaut.
 
Auf diese Art kannst du sehen ob eine Datei mit einer bestimmten Kombination von Berechtigungen übereinstimmt.
 
Zum Beispiel wenn du sehen willst welche Dateien von Benutzer und Gruppe ausführbar sind, nimmst du:
 
<div style="margin-left:0cm;margin-right:0cm;">find -type f -perm -110</div>
 
Die <tt>110</tt> sagt <tt>find</tt> „Schau nach Dateien das Ausführen-Bit für Benutzer und Gruppe gesetzt haben!“ und das - sagt ''find'' die anderen Bits zu ignorieren.
 
Das heißt, es spielt keine Rolle, wenn die Datei auch beschreibbar oder lesbar ist, solange die Bits gesetzt sind, die sie ausführbar machen.
 
Um die Suche auf Dateien einzuschränken, die ''exakt'' dem angegeben Staus entsprechen, benutzt du nicht den - -Operator.
 
Was, wenn du nach Dateien suchst die das Ausführen-Bit für Benutzer ''oder'' Gruppe haben? Dann nimmst du / statt - :
 
<div style="margin-left:0cm;margin-right:0cm;">find -type f -perm /110</div>
 
Jede Datei, die die Gruppen- oder Eigentümer-Berechtigung hat, wird gefunden.
 
Suchen nach Berechtigung kann überaus hilfreich sein, aber auch komplex.
 
Es kann etwas dauern um die Syntax zu verstehen, besonders für die, die noch nicht mit dem Eigentümer/Berechtigung-Konzept vertraut sind.
 
In diesem Fall ist das Lesen der <tt>man</tt>-Seiten nicht nur empfehlenswert, sondern unerlässlich.
 
==== {{anchor|RefHeading4390100347735}} -perm Modus ====
 
Findet Dateien, deren Rechte exakt dem angegebenem Modus entsprechen (Angabe numerisch oder symbolisch)
 
die Zugriffsrechte auf die Datei entsprechen exakt dem Modus; der Modus kann als Oktalzahl oder mit den bei chmod(1) beschriebenen Kennungen beschrieben werden, die Kennungen werden auf Modus 000bezogen
 
==== {{anchor|RefHeading4392100347735}} -perm –Modus ====
 
Findet Dateien, bei denen mindestens die durch Modus angegebenen Rechteflags gesetzt sind
 
(mindestens) die Zugriffsrechte für den Modus sind gesetzt
 
==== {{anchor|RefHeading4394100347735}} -perm +Modus ====
 
Findet Dateien, bei denen mindestens eines der durch Modus angegebenen Rechteflags gesetzt ist
 
die Zugriffsrechte entsprechen höchstens dem Modus (oder sind weiter eingeschränkt)
 
=== {{anchor|RefHeading17244469115403}} Links ===
 
==== {{anchor|RefHeading4402100347735}} -links Anzahl ====
 
Findet Dateien, auf die Anzahl fester Links zeigen
 
===== Dateien im Verzeichnis /usr mit 43 harten Links =====
 
<div style="margin-left:0cm;margin-right:0cm;">'''find /usr/ -links 43 2>/dev/null'''
/usr/include
/usr/share </div>
 
In den Ausgaben wurden die Fehler nach "/dev/null" verschoben, da find natürlich nur Verzeichnisse unter die Lupe nimmt, zu dessen Zugang der Benutzer berechtigt ist.
 
==== {{anchor|RefHeadingToc5404498221824}} -lname Muster  ====
 
die Datei ist ein symbolischer Link auf eine Datei oder ein Verzeichnis mit einem zum Muster passenden Namen
 
==== {{anchor|RefHeadingToc5400498221824}} -inum IN  ====
 
die Datei belegt die Inode mit der Nummer N
 
===== find all the hard links =====
 
A common request is a way to find all the hard links to some file. Using “<tt>ls ‑li </tt>''file''” will tell you how many hard links the file has, and the ''inode number''. You can locate all pathnames to this file with:
 
<div style="margin-left:0cm;margin-right:0cm;">find ''mount-point'' -xdev -inum ''inode-number''</div>
 
Since hard links are restricted to a single filesystem, you need to search that whole filesystem so you start the search at the filesystem's ''mount point''. (This is likely to be either “<tt>/home</tt>” or “<tt>/</tt>” for files in your home directory.)
 
The “<tt>‑xdev</tt>” option tells <tt>find</tt> to not search (descend into) any other filesystems.
 
While most Unix and all Linux systems have a <tt>find</tt> command that supports the “<tt>‑inum</tt>” criterion, this isn't POSIX standard.
 
Older Unix systems provided the “<tt>ncheck</tt>” utility instead that could be used for this.
 
== {{anchor|RefHeading2306761082722535}} Bedingungen verknüpfen ==
 
find hält logische Operatoren bereit, um verschiedene Kriterien miteinander zu verknüpfen.
 
==== {{anchor|RefHeading4344100347735}} Tests kombinieren ====
 
* <tt><c1></tt> -a <c2>: Wahr, wenn beide, <tt><c1></tt> und <tt><c2></tt>, wahr sind. <tt>-a</tt> wird bereits implizit aktiviert, daher brauchen Sie nur <tt><c1> <c2> <c3></tt>... eingeben, wenn Sie alle Tests <tt><c1></tt>, <tt><c2></tt>,... durchführen möchten.
* <tt><c1> -o <c2></tt>: Wahr, wenn entweder <tt><c1></tt>, <tt><c2></tt> oder beide wahr sind. <tt>-o</tt> hat eine geringere Wertigkeit als <tt>-a</tt>. Wenn Sie also Dateien möchten, die Kriterium <tt><c1></tt> oder <tt><c2></tt> und Kriterium <tt><c3></tt> entsprechen, müssen Sie Klammern verwenden: <tt>( <c1>-o <c2> ) -a <c3></tt>. Damit die hier verwendeten Klammern nicht von Ihrer Shell interpretiert werden, müssen Sie sie durch Voranstellen eines Rückstriches (\) schützen.
* <tt>-not <c1></tt>: Invertiert den Test <tt><c1></tt>. Also ist <tt>-not <c1></tt> wahr, wenn <tt><c1></tt> falsch ist.
 
 
 
=== {{anchor|RefHeading18710469115403}} Operatoren ===
 
Die Optionen, Tests und Aktionen können mit Operatoren verknüpft werden.
 
Die Bearbeitung erfolgt von links nach rechts.
 
 
{| style="border-spacing:0;margin:auto;width:17.501cm;"
|-
|-
| style="background-color:transparent;border-top:0.05pt solid #000000;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding-top:0.101cm;padding-bottom:0.101cm;padding-left:0.3cm;padding-right:0.3cm;" | '''( Ausdruck ) '''
! Option !! Beschreibung
| style="background-color:transparent;border:0.05pt solid #000000;padding-top:0.101cm;padding-bottom:0.101cm;padding-left:0.3cm;padding-right:0.3cm;" | die Klammern fassen den Ausdruck zu einer Operation zusammen
|-
|-
| style="background-color:transparent;border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding-top:0.101cm;padding-bottom:0.101cm;padding-left:0.3cm;padding-right:0.3cm;" | '''! Ausdruck '''
| -name || Sucht Dateien nach Dateinamen
| style="background-color:transparent;border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:0.05pt solid #000000;padding-top:0.101cm;padding-bottom:0.101cm;padding-left:0.3cm;padding-right:0.3cm;" | ist wahr, wenn der Ausdruck falsch ist
|-
|-
| style="background-color:transparent;border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding-top:0.101cm;padding-bottom:0.101cm;padding-left:0.3cm;padding-right:0.3cm;" | '''-not Ausdruck '''
| -iname || Sucht nach Dateinamen und ignoriert Groß- und Kleinschreibung
| style="background-color:transparent;border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:0.05pt solid #000000;padding-top:0.101cm;padding-bottom:0.101cm;padding-left:0.3cm;padding-right:0.3cm;" | ist ebenfalls wahr, wenn der Ausdruck falsch ist
|-
|-
| style="background-color:transparent;border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding-top:0.101cm;padding-bottom:0.101cm;padding-left:0.3cm;padding-right:0.3cm;" | '''Ausdruck1 Ausdruck2 '''
| -size || Sucht Dateien, die größer oder kleiner als größer sind
| style="background-color:transparent;border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:0.05pt solid #000000;padding-top:0.101cm;padding-bottom:0.101cm;padding-left:0.3cm;padding-right:0.3cm;" | UND Verknüpfung; wenn Ausdruck1 wahr ist, wird Ausdruck2 bewertet (ausgeführt)
|-
|-
| style="background-color:transparent;border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding-top:0.101cm;padding-bottom:0.101cm;padding-left:0.3cm;padding-right:0.3cm;" | '''Ausdruck1 -a Ausdruck2 '''
| -type || Sucht Dateien eines bestimmten Typs
| style="background-color:transparent;border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:0.05pt solid #000000;padding-top:0.101cm;padding-bottom:0.101cm;padding-left:0.3cm;padding-right:0.3cm;" | auch eine UND Verknüpfung
|-
|-
| style="background-color:transparent;border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding-top:0.101cm;padding-bottom:0.101cm;padding-left:0.3cm;padding-right:0.3cm;" | '''Ausdruck1 -and Ausdruck2 '''
| -atime || Sucht Dateien, auf die seit mehr oder weniger als X Tagen nicht mehr zugegriffen wurde
| style="background-color:transparent;border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:0.05pt solid #000000;padding-top:0.101cm;padding-bottom:0.101cm;padding-left:0.3cm;padding-right:0.3cm;" | auch eine UND Verknüpfung
|-
|-
| style="background-color:transparent;border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding-top:0.101cm;padding-bottom:0.101cm;padding-left:0.3cm;padding-right:0.3cm;" | '''Ausdruck1 -o Ausdruck2 '''
| -amin || Sucht Dateien, auf die seit mehr oder weniger als X Minuten nicht mehr zugegriffen wurde
| style="background-color:transparent;border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:0.05pt solid #000000;padding-top:0.101cm;padding-bottom:0.101cm;padding-left:0.3cm;padding-right:0.3cm;" | ODER Verknüpfung; Ausdruck2 wird bewertet (ausgeführt), wenn Ausdruck1 falsch ist
|-
|-
| style="background-color:transparent;border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding-top:0.101cm;padding-bottom:0.101cm;padding-left:0.3cm;padding-right:0.3cm;" | '''Ausdruck1 -or Ausdruck2 '''
| -mtime || Sucht Dateien, die seit mehr oder weniger als X Tagen nicht mehr verändert wurden
| style="background-color:transparent;border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:0.05pt solid #000000;padding-top:0.101cm;padding-bottom:0.101cm;padding-left:0.3cm;padding-right:0.3cm;" | auch eine ODER Verknüpfung
|-
|-
| style="background-color:transparent;border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding-top:0.101cm;padding-bottom:0.101cm;padding-left:0.3cm;padding-right:0.3cm;" | '''Ausdruck1 , Ausdruck2 '''
| -mmin || Sucht Dateien, die seit mehr oder weniger als X Minuten nicht mehr verändert wurden
| style="background-color:transparent;border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:0.05pt solid #000000;padding-top:0.101cm;padding-bottom:0.101cm;padding-left:0.3cm;padding-right:0.3cm;" | Liste; beide Ausdrücke werden immer bewertet (ausgeführt); der Wahrheitswert des gesamten Ausdrucks entspricht dem von Ausdruck2
 
 
|-
|-
|}
| -perm || Sucht Dateien nach Zugriffsrechten
=== {{anchor|RefHeading4406100347735}} Und-Kombination ===
 
Treffer müssen alle Kriterien erfüllen
 
<div style="margin-left:0cm;margin-right:0cm;">find -mindepth 3 -maxdepth 5</div>
 
Finde ab Unterverzeichnis(se) 3 (<tt>mindepth 3</tt>) UND bis Unterverzeichnis(se) 5 (<tt>-maxdepth 5</tt>).
 
Weiters Beispiel der UND-Kombination:
 
<div style="margin-left:0cm;margin-right:0cm;">find -mindepth 3 -type f -name "*.avi" -size +5M</div>
 
Beginnt die Suche ab Unterverzeichnis(se) 3 (<tt>-mindepth 3</tt>), UND findet nur gewöhnliche Dateien (‑<tt>type f</tt>), die die Endung '''.avi''' besitzen UND mindestens 5 MB groß sind (<tt>-size +5M</tt>).
 
=== {{anchor|RefHeading4410100347735}} Oder-Kombination  ===
 
<div style="margin-left:0cm;margin-right:0cm;">find -name "susi.*" -or -name "susanne.*" </div>
 
Sucht alle Dateien die mit "susi." ODER "susanne." beginnen.
 
=== {{anchor|RefHeading4408100347735}} ODER bzw. NICHT-Kombination ===
 
Man kann die Suchoptionen aber auch per ODER bzw. NICHT verknüpfen:
 
Negation
 
<div style="margin-left:0cm;margin-right:0cm;">find ! -name "*.avi" -not -name "*.mp*g" </div>
 
Sucht Dateien die von der Dateiendung weder '''avi''', noch '''mpg''' oder '''mpeg''' sind. Ausrufezeichen und <tt>-not</tt> sind gleichbedeutend.
 
=== {{anchor|RefHeading4412100347735}} Klammerung ===
 
Bei umfangreichen Kombinationen kann eine Klammerung erforderlich sein, um das gewünschte Resultat zu erhalten.
 
==== ohne Klammern  ====
 
<div style="margin-left:0cm;margin-right:0cm;">find -name "susi.*" -or -name "susanne.*" -name "*.txt"  </div>
 
Ohne Klammern wird erst die UND-Verbindung gebildet, also "susanne.*" und "*.txt", danach erst ODER "susi". '''susi.png''' würde also gefunden.
 
==== mit Klammern  ====
 
<div style="margin-left:0cm;margin-right:0cm;">find \( -name "susi.*" -or -name "susanne.*" \) -name "*.txt"  </div>
 
Klammern müssen maskiert werden. Hier wird jetzt für alle Dateien erfordert, dass diese auf .txt enden.
 
=== {{anchor|RefHeading80071942887705}} Beispiel ===
 
Suche nach ausführbaren Dateien (keine Verzeichnisse), die »user« gehören
 
<div style="margin-left:0cm;margin-right:0cm;">'''find . -maxdepth 1 \! -type d -a -perm +111 -a -user user'''
./.xinitrc
./.xsession
./dialog
./selfeditor.pl </div>
 
'''Erläuterung'''* Die Suche wurde auf das aktuelle Verzeichnis beschränkt "-maxdepth 1"
* Verzeichnisse ausgeschlossen "\! -type d" (das "!" ist ein Sonderzeichen der Shell, deswegen muss die Auswertung durch die Shell verhindert werden).
* Es sollen alle Dateien gefunden werden, bei denen mindestens in einer [../../../F:%5Cebooks%5CLinux%5CEinführungen%5Clinuxfibel%5Ceigentum.htm Rechtegruppe] das x-Flag gesetzt ist "-perm +111" und die »user» gehören "-user user". Die Suchkriterien sind jeweils per UND zu verknüpfen.
* Da find rekursiv alle Unterverzeichnisse (eventuell bis zu einer bestimmten Tiefe) durchsucht, kann die Ausführung sehr langwierig werden.
 
 
 
== {{anchor|RefHeading149241942887705}} Aktionen  ==
 
=== {{anchor|RefHeadingToc5170498221824}} -ls  ===
 
zeigt das Verzeichnis in dem die getestete Datei gefunden wurde mit ls -dils an
 
=== {{anchor|RefHeadingToc190371025091341}} -delete  ===
 
Löscht die gefundenen Dateien
 
==== {{anchor|RefHeading7182315101596}} Achtung! ====
 
Da find auch Unterverzeichnisse durchsucht, sollte mit dieser Option vorsichtig umgegangen werden.
 
Mit find gelöschte Dateien landen nicht im Papierkorb und können nicht wieder hergestellt werden. Siehe auch [http://wiki.ubuntuusers.de/find#Die-Aktion-delete-steht-an-der-falschen-Stelle Die Aktion -delete steht an der falschen Stelle]
 
Vor der Verwendung sollte ein Test ohne <tt>-delete</tt> voraus gehen, um sicher zu gehen, nicht zu viele Dateien zu löschen.
 
Die <tt>-delete</tt>-Option impliziert <tt>-depth</tt>, d.h. man muss zum Testen auch <tt>-depth</tt> setzen, um keine Überraschung zu erleben. Es ist auch sorgfältig darauf zu achten, an welcher Position <tt>-delete</tt> steht.
 
<div style="margin-left:0cm;margin-right:0cm;">find test/ -name "c*" -delete  </div>
 
Löscht im Verzeichnis '''test''' und dessen Unterverzeichnissen alle Dateien, die mit "c" beginnen.
 
Der Befehl löscht auch Verzeichnisse selbst, die mit "c" beginnen, diese jedoch nur, wenn sie leer sind, wie allgemein üblich bei Linux.
 
Das ist der Grund, weshalb <tt>-delete</tt> ein <tt>-depth</tt> impliziert:
 
Wenn erst in den Unterverzeichnissen gelöscht wird kann ein leeres Oberverzeichnis auch gelöscht werden, umgekehrt nicht.
 
=== {{anchor|RefHeading7021339995267}} Find und anderen Kommandos  ===
 
Now that you've found the files you're looking for, what are you going to do with them?
 
You can use <tt>find</tt> in conjunction with '''xargs''' or the '''-exec''' option to manipulate files after you've found what you're looking for.
 
Say you want to change the ownership of a bunch of files from root to www-data. Finding all the files is only the first step; you also need to change the ownership.
 
Doing it manually from a list of files returned by <tt>find</tt> sounds like tedium, and it is. So you might want to use the '''-exec''' option to change the ownership:
 
<div style="margin-left:0cm;margin-right:0cm;">find -user root -exec chown www-data {} \;</div>
 
That command tells find to pass all the files it finds to the '''chown''' utility and change the ownership to '''www-data'''. Piece of cake.
 
==== {{anchor|RefHeading529851158963051}} Dateien bearbeiten ====
 
Schließlich wünscht man sich, mit der gefundenen Datei etwas anstellen zu können, d.h. die gefundene Datei durch ein Kommando zu schleusen.
 
Mit der Option -exec Kommando(s) {} ; wird in jedem Schritt die gefundene Datei der Reihe nach mit den angegebenen Kommandos bearbeitet.
 
Die geschweiften Klammern dienen dabei als Platzhalter, der den aktuellen Dateinamen enthält.
 
Das Semikolon schließt die exec-Option ab:
 
<u>Suche nach leeren Dateien und zeige diese mittels "ls -l" an</u>
 
<div style="margin-left:0cm;margin-right:0cm;">find ./bsp/ -empty -exec ls -l \{\} \;
insgesamt 0
insgesamt 0
-rw-r--r--    1  user  users          0 Jun 16 09:30  ./bsp/lib/bla/file
-rw-r--r--    1  user  users          0 Jun 16 09:30  ./bsp/lib/foo/file </div>
 
<u>Bemerkung</u>
 
Die Maskierung der geschweiften Klammern und des Semikolons ist entscheidend, da diese sonst von der Shell substituiert werden (ein Semikolon wird bspw. entfernt).
 
Auch muss zwischen schließender Klammer und Semikolon ein Leerzeichen stehen!
 
==== -exec Kommando {} \;  ====
 
Wendet auf alle gefundenen Dateien den Shellbefehl "Kommando" an. {} steht dabei als Platzhalter für die gefundenen Dateinamen.
 
Das Zeichen ; terminiert den von find aufzurufenden Shellbefehl, damit es nicht unbeabsichtigt von der Shell interpretiert wird muss es mit \ maskiert werden.
 
==== {{anchor|RefHeadingToc5152498221824}} -exec Kommando; << ====
 
führt das Kommando aus; die Aktion ist wahr, wenn das Kommando einen Status von Null liefert; alle auf den Kommandonamen folgenden Argumente bis zu einem Semikolon.
 
werden als Kommandozeilenargumente für das Kommando interpretiert.
 
das Semikolon kann nicht weggelassen werden, und es muss durch mindestens ein Whitespace von der letzten Option getrennt werden
 
die Konstruktion {} wird durch den Pfadnamen der Datei ersetzt; die Klammern und das Semikolon müssen in der Kommandozeile für find quotiert werden, damit sie nicht von der Shell bearbeitet werden
 
==== {{anchor|RefHeading4414100347735}} Using ‑exec Efficiently ====
 
The <tt>‑exec</tt> action takes a command (along with its options) as an argument.
 
The arguments should contain <tt>{}</tt> (usually quoted), which is replaced in the command with the name of the currently found file.
 
The command is terminated by a semicolon, which must be quoted (“escaped”) so the shell will pass it literally to the <tt>find</tt> command.
 
To use a more complex action with <tt>‑exec</tt>, you can use “''complex-command''” as the Unix command.
 
Here's a somewhat contrived example, that for each found file replaces “Mr.” with “Mr. or Ms.”, and also converts the file to uppercase:
 
<div style="margin-left:0cm;margin-right:0cm;">find ''whatever...'' -exec sh -c 'sed "s/Mr\./Mr. or Ms./g" "{}" \'
      | tr "[:lower:]" "[:upper:]" >"{}.new"' \;</div>
 
The <tt>‑exec</tt> action in <tt>find</tt> is very useful.&nbsp; But since it runs the command listed for every found file, it isn't very efficient.
 
On a large system this makes a difference!&nbsp; One solution is to combine <tt>find</tt> with <tt>xargs</tt> as discussed [http://content.hccfl.edu/pollock/Unix/FindCmd.htm#xargs above]:
 
<div style="margin-left:0cm;margin-right:0cm;">  find ''whatever...'' | xargs ''command''</div>
 
However this approach has two limitations.&nbsp; Firstly not all commands accept the list of files at the end of the command.&nbsp; A good example is <tt>cp</tt>:
 
<div style="margin-left:0cm;margin-right:0cm;">find . -name \*.txt | xargs cp /tmp  <nowiki># This won't work!</nowiki></div>
 
(Note the Gnu version of <tt>cp</tt> has a non-POSIX option “<tt>‑t</tt>” for this, and Gnu <tt>xargs</tt> has options to handle this too.)
 
Secondly, filenames may contain spaces or newlines, which would confuse the command used with <tt>xargs</tt>.&nbsp; (Again Gnu tools have options for that, “<tt>find&nbsp;...&nbsp;‑print0&nbsp;|&nbsp;xargs&nbsp;‑0&nbsp;...</tt>”.)
 
There are standard POSIX (but non-obvious) solutions to both problems.&nbsp;
 
An alternate form of <tt>‑exec</tt> ends with a plus-sign, not a semi-colon.&nbsp; This form collects the filenames into groups or sets, and runs the command once per set.&nbsp;
 
This is exactly what <tt>xargs</tt> does, to prevent argument lists from becoming too long for the system to handle.
 
In this form, the <tt>{}</tt> argument expands to the set of filenames.&nbsp;
 
For example:
 
<div style="margin-left:0cm;margin-right:0cm;">find / -name core -exec /bin/rm -f '{}' +</div>
 
==== -execdir Kommando {} +  ====
 
Wendet auf alle gefundenen Dateien den Shellbefehl "Kommando" an. Im Ggs. zu <tt>-exec</tt> wird das Kommando im Verzeichnis, in dem die Datei liegt, ausgeführt.
 
Das Plus statt des <tt>\;</tt> am Ende provoziert die parallele Ausführung der Kommandos, und kann auch bei -exec verwendet werden
 
===== Mehrere Kommandos ausführen =====
 
As for the <tt>find</tt> command, you can also just add more <tt>-exec</tt> commands in a row:
 
<div style="margin-left:0cm;margin-right:0cm;">find . -name "*" -exec chgrp -v new_group '{}' \; -exec chmod -v 770 '{}' \;</div>
 
Note that this command is, in its result, equivalent of using
 
<div style="margin-left:0cm;margin-right:0cm;">chgrp -v new_group file '''&&''' chmod -v 770 file</div>
 
on each file.
 
All the <tt>find</tt>'s parameters such as <tt>-name</tt>, <tt>-exec</tt>, <tt>-size</tt> and so on, are actually '''tests''': <tt>find</tt> will continue to run them one by one as long as the entire chain so far has evaluated to ''true''. So each consecutive <tt>-exec</tt> command is executed '''only if''' the previous ones returned ''true'' (i.e. <tt>0</tt> exit status of the commands). But <tt>find</tt> also understands logic operators such as ''or'' (<tt>-o</tt>) and ''not'' (<tt>!</tt>). Therefore, to use a chain of <tt>-exec</tt> tests '''regardless''' of the previous results, one would need to use something like this:
 
<div style="margin-left:0cm;margin-right:0cm;">find . -name "*" \( -exec chgrp -v new_group {} \; -o -exec chmod -v 770 {} \; \)</div>
 
 
@user Unfortunately, I don't know if it is still necessary. I did some test just now and haven't come across a situation where it would change anything. I guess it's just "good practice" that will die out. –&nbsp;[http://unix.stackexchange.com/users/9382/rozcietrzewiacz rozcietrzewiacz] [http://unix.stackexchange.com/questions/18077/how-can-i-use-two-bash-commands-in-exec-of-find-command#comment24573_18085 Aug 5 '11 at 8:04]
 
<div style="margin-left:0cm;margin-right:0cm;">find . -name "*" -exec sh -c 'chgrp -v new_group "$0" ; chmod -v 770 "$0"' {} \;</div>
 
 
@Gilles: The wonders of <tt>-c</tt>'s odd handling of $0 make me think this is wrong every time I glance at it, but its definitely correct. –&nbsp;[http://unix.stackexchange.com/users/977/derobert derobert] [http://unix.stackexchange.com/questions/18077/how-can-i-use-two-bash-commands-in-exec-of-find-command#comment64156_18078 Aug 24 '12 at 16:52]
 
I like the explicit shell being defined... –&nbsp;[http://unix.stackexchange.com/users/7586/djangofan djangofan] [http://unix.stackexchange.com/questions/18077/how-can-i-use-two-bash-commands-in-exec-of-find-command#comment64180_18078 Aug 24 '12 at 19:05]
 
==== -ok ====
 
Anstatt <tt>-exec</tt> kann man auch <tt>-ok</tt> verwenden. Hierbei wird jedes mal gefragt, ob man die Aktion ausführen möchte.
 
Meist empfiehlt sich <tt>-execdir</tt> statt <tt>-exec</tt>
 
<div style="margin-left:0cm;margin-right:0cm;">find test -type d -exec tar -cjf archiv.bz2 {} \; </div>
 
<tt>-execdir</tt> führt das Kommando aus dem Verzeichnis heraus aus, in dem die Datei gefunden wird.
 
So wird also für jedes Unterverzeichnis ein '''archiv.bz2''' vor Ort angelegt.
 
Mit einem einfachen <tt>-exec</tt> würde für jedes Verzeichnis ein Archiv im aktuellen Verzeichnis angelegt, d.h. das Archiv immer wieder überschrieben, so dass am Ende nur ein Archiv mit den Ergebnissen des letzten Verzeichnisses existiert.
 
===== {{anchor|RefHeadingToc5160498221824}} -ok Kommando;  =====
 
wie -exec, vor der Ausführung des Kommandos wird aber noch eine Bestätigung erwartet; nur eine Eingabe, die mit einem B oder einem y beginnt, führt zur Ausführung des Kommandos
 
===== -ok Kommando {} \;  =====
 
Wie <tt>-exec</tt>, allerdings wird vor jeder Aktion eine Bestätigung erfragt. {} steht dabei als Platzhalter für die gefundenen Dateinamen
 
==== -okdir  ====
 
<div style="margin-left:0cm;margin-right:0cm;">find -name "*pdf" -okdir xpdf {} \; </div>
 
<tt>-okdir</tt> fragt im Gegensatz zu <tt>-execdir</tt> vor jeder Datei nach, ob man wirklich die Aktion ausführen möchte.
 
===== Parallele Ausführung mit +  =====
 
<div style="margin-left:0cm;margin-right:0cm;">find -name "*pdf" -execdir md5sum {} +  </div>
 
Beendet man ein Kommando mit Plus <tt>+</tt> statt mit Semikolon <tt><nowiki>;</nowiki></tt>, so werden mehrere, u.U. alle Funde auf einen Rutsch an das Kommando übergeben.
 
Dies ist dann sinnvoll, wenn das Kommando selbst mit mehreren Parametern zurechtkommt. Beispiele:
 
<div style="margin-left:0cm;margin-right:0cm;">find test -type f -execdir md5sum {} ";" </div>
 
ergibt:
 
<div style="margin-left:0cm;margin-right:0cm;">md5sum a
md5sum b
md5sum c</div>
 
Dagegen ergibt:
 
<div style="margin-left:0cm;margin-right:0cm;">find test -type f -execdir md5sum {} +
md5sum a b c </div>
 
Das + kann nur verwendet werden, wenn die geschweiften Klammern unmittelbar davor stehen.
 
Eine etwas heikle Angelegenheit ist das Löschen mit der Option <tt>-delete</tt>.
 
===== -okdir Kommando {} +  =====
 
Wie eine Kombination von <tt>-ok</tt> und <tt>-execdir</tt>, d.h. es wird eine Bestätigung erfragt, und das Kommando wird im Fundordner ausgeführt.
 
Das Plus kann statt ";" verwendet werden, wenn die <tt>{}</tt> der letzte Parameter sind; dann werden mehrere Funde auf einmal an <tt>Kommando</tt> übergeben.
 
== {{anchor|RefHeadingToc190391025091341}} Ausgabe formatieren ==
 
=== {{anchor|RefHeadingToc5162498221824}} -print  ===
 
gibt den vollständigen Pfadnamen der getesteten Datei auf die Standardausgabe
 
=== {{anchor|RefHeadingToc5154498221824}} -fprint Ausgabedatei  ===
 
schreibt den Pfadnamen der getesteten Datei in die Ausgabedatei; wenn die Ausgabedatei nicht existiert, wird sie erzeugt, sonst wird sie erweitert; die Standardausgabe und die Standardfehlerausgabe werden als /dev/stdout und /dev/stderr angesprochen
 
==== -fprint Datei  ====
 
Gibt die gefunden Dateinamen nicht auf die Standardausgabe (Bildschirm) aus, sondern schreibt diese in die Datei "Datei"
 
=== {{anchor|RefHeadingToc5164498221824}} -print0  ===
 
gibt den Pfadnamen der getesteten Datei, von einem Nullbyte abgeschlossen, auf die Standardausgabe; auf diese Weise können auch Pfadnamen korrekt weiterverarbeitet werden, die ein Zeilenende enthalten
 
==== {{anchor|RefHeadingToc5156498221824}} -fprint0 Ausgabedatei  ====
 
schreibt den Namen der getesteten Datei in die Ausgabedatei und schließt die Ausgabe mit einem Nullbyte ab, wie -print0
 
=== {{anchor|RefHeadingToc190411025091341}} -printf ===
 
Using the (non-standard) “<tt>‑printf</tt>” action instead of the default “<tt>‑print</tt>” is useful to control the output format better than you can with the <tt>ls</tt> or <tt>dir</tt> utilities.
 
You can use <tt>find</tt> with the <tt>‑printf</tt> action to produce output that can easily be parsed by other utilities or imported into spreadsheets or databases. See the Gnu <tt>find</tt> man page for the dozens of possibilities with the <tt>‑printf</tt> action.
 
In fact, <tt>find</tt> with <tt>‑printf</tt> is more versatile than <tt>ls</tt><nowiki>; it is the preferred tool for forensic examiners even on Windows systems, to list file information.</nowiki>
 
For example the following displays non-hidden (no leading dot) files in the current directory only (no subdirectories), with an custom output format:
 
<div style="margin-left:0cm;margin-right:0cm;">find . -maxdepth 1 -name '[!.]*' -printf 'Name: %16f Size: %6s\n'</div>
 
“<tt>‑maxdepth</tt>” is a Gnu extension. On a modern, POSIX version of <tt>find</tt> you could use this:
 
<div style="margin-left:0cm;margin-right:0cm;">find . -path './*' -prune ...</div>
 
On any version of <tt>find</tt> you can use this more complex (but portable) code:
 
<div style="margin-left:0cm;margin-right:0cm;">find . ! -name . -prune ...</div>
 
which says to “prune” (don't descend into) any directories except “<tt>.</tt>”.
 
Note that “<tt>‑maxdepth 1</tt>” will include “<tt>.</tt>” unless you also specify “<tt>‑mindepth 1</tt>”. A portable way to include “<tt>.</tt>” is:
 
<div style="margin-left:0cm;margin-right:0cm;"> find . \( -name . -o -prune \) ...</div>
 
The “<tt>\(</tt>” and “<tt>\)</tt>” are just parenthesis used for grouping, and escaped from the shell. The “<tt>‑o</tt>” means Boolean ''OR''. As a system administrator, you can use <tt>find</tt> to locate suspicious files (e.g., world writable files, files with no valid owner and/or group, Set files, files with unusual permissions, sizes, names, or dates). Here's a more complex example (which I saved as a shell script so I can run it often):
 
<div style="margin-left:0cm;margin-right:0cm;">find / -noleaf -wholename '/proc' -prune \
      -o -wholename '/sys' -prune \
      -o -wholename '/dev' -prune \
      -o -wholename '/windows-C-Drive' -prune \
      -o -perm -2 ! -type l  ! -type s \
      ! \( -type d -perm -1000 \) -print</div>
 
This says to seach the whole system, skipping the directories <tt>/proc</tt>, <tt>/sys</tt>, <tt>/dev</tt>, and <tt>/windows-C-Drive</tt> (presumably a Windows partition on a dual-booted computer).
 
The Gnu <tt>‑noleaf</tt> option tells <tt>find</tt> not to assume all remaining mounted filesystems are Unix file systems (you might have a mounted CD for instance). The “<tt>‑o</tt>” is the Boolean OR operator, and “<tt>!</tt>” is the Boolean NOT operator (applies to the following criteria).
 
So these criteria say to locate files that are world writable (“<tt>‑perm ‑2</tt>”, same as “<tt>‑o=w</tt>”) and NOT symlinks (“<tt>! ‑type l</tt>”) and NOT ''sockets'' (“<tt>! ‑type s</tt>”) and NOT directories with the ''sticky'' (or ''text'') bit set (“<tt>! \( ‑type d ‑perm ‑1000 \)</tt>”).
 
(Symlinks, sockets, and directories with the sticky bit set, are often world-writable and generally not suspicious.)
 
==== {{anchor|RefHeadingToc5166498221824}} -printf Format  ====
 
gibt für die getestete Datei die Zeichenkette Format auf der Standardausgabe aus; Format kann verschiedene Sonderzeichen und Platzhalter enthalten, die von find bearbeitet werden:
 
\aAlarmton \bRückschritt \cAbbruch der Ausgabe \fSeitenvorschub \nZeilenvorschub \rWagenrücklauf \thorizontaler Tabulator \vvertikaler Tabulator \\der Backslash selbst
 
ein Backspace gefolgt von irgendeinem anderen Zeichen wird als normales Zeichen interpretiert und einfach ausgegeben
 
%% das Prozentzeichen selbst %a die Zeit des letzten Zugriffs auf die Datei, in dem Format der ctime Funktion %A k die Zeit des letzten Zugriffs auf die Datei, in dem von k bestimmte Format; k hat dabei das gleiche Format wie der entsprechende Parameter der strftime Funktion in C:
 
@ Sekunden seit dem 1.1.1970 0 Uhr GMT H Stunde (00 bis 23) I Stunde (01 bis 12) k Stunde (0 bis 23) l Stunde (1 bis 12) M Minute (00 bis 59) p PM oder AM r Zeit, 12 Stunden (hh:mm:ss: AM/PM) S Sekunden (00 bis 61) T Zeit, 24 Stunden (hh:mm:ss) X Zeit (H:M:S) Z Zeitzone, oder nichts a abgekürzter Wochentag A ausgeschriebener Wochentag b abgekürzter Monatsname B ausgeschriebener Monatsname c Datum und Zeit d Tag im Monat D Datum (mm/dd/yy) h das gleiche wie b j der Tag im Jahr m die Zahl des Monats U die Nummer der Woche, Sonntag als erster Wochentag w die Zahl des Wochentags W die Nummer der Woche, Montag als erster Wochentag x Datum (mm/dd/yy) y die letzten beiden Stellen der Jahreszahl Y die Jahreszahl
 
%b die Dateigröße in 512 Byte Blöcken (aufgerundet) %c das Datum der letzten Statusänderung im Format der C ctime Funktion %Ck das Datum der letzten Statusänderung im Format der BR strftime " Funktion; Parameter wie oben" %d die Höhe der Datei im Verzeichnisbaum; Null bedeutet, dass die Datei Kommandozeilenargument ist
 
%f der Name der getesteten Datei, ohne Verzeichnisse
 
%g der Gruppenname der getesteten Datei oder die Kennzahl, wenn die Gruppe nicht eingetragen ist
 
%G die Gruppenkennzahl
 
%h die Verzeichnisnamen des Pfadnamen der getesteten Datei
 
%H das Kommandozeilenargument (Test), mit dem die Datei gefunden wurde
 
%i die Nummer der Inode der getesteten Datei
 
%k die aufgerundete Größe der getesteten Datei in Kilobytes
 
%l das Objekt, auf die ein symbolischer Link zeigt; leer, wenn die getestete Datei kein symbolischer Link ist
 
%m die Zugriffsrechte als Oktalzahl
 
%n die Anzahl der harten Links auf die getestete Datei
 
%p der Pfadname der Datei
 
%P der Pfadname und das Kommandozeilenargument (Test), mit dem die Datei gefunden wurde
 
%s die Größe der getesteten Datei in Bytes
 
%t die Zeit der letzten Änderung, im ctime Format
 
%Tk die Zeit der letzten Änderung, im strftime Format (siehe oben)
 
%u der Name des Eigentümers der getesteten Datei oder die Kennzahl, wenn der Benutzer nicht eingetragen ist
 
%U die Benutzerkennzahl des Eigentümers der getesteten Datei
 
==== {{anchor|RefHeadingToc5158498221824}} -fprintf Ausgabedatei Format  ====
 
schreibt den Namen der getesteten Datei in die Ausgabedatei und benutzt dabei das Format mit Sonderzeichen wie bei printf
 
=== {{anchor|RefHeadingToc5168498221824}} -prune  ===
 
Wenn die Datei ein Verzeichnis ist, wird nicht in dieses hinabgestiegen. * wahr, wenn die Option -depth nicht angegeben ist
* falsch, wenn die Option -depth angegeben ist, hat keine Auswirkungen.
 
 
 
=== {{anchor|RefHeading149261942887705}} Beispiele  ===
 
Ohne weitere Angaben gibt find die Namen der gefundenen Dateien aus:
 
<div style="margin-left:0cm;margin-right:0cm;">find /boot/grub/ -name "he*"
/boot/grub/hexdump.mod
/boot/grub/hello.mod
/boot/grub/help.mod  </div>
 
Wie bereits gesehen kann man mit <tt>-ls</tt> eine detailliertere Ausgabe erzeugen:
 
<div style="margin-left:0cm;margin-right:0cm;">find /boot/grub/ -name "he*" -ls
168624    4 -rw-r--r--  1 root    root        3196 Jan 13 17:08 /boot/grub/hexdump.mod
168603    4 -rw-r--r--  1 root    root        1308 Jan 13 17:08 /boot/grub/hello.mod
168623    4 -rw-r--r--  1 root    root        2200 Jan 13 17:08 /boot/grub/help.mod </div>
 
Mit <tt>-exec</tt> und dessen Varianten lassen sich beliebige Programme auf den Fundstellen ausführen.
 
Die Anzahl der Zeilen in Textdateien findet man mit <tt>wc -l DATEI</tt><nowiki>; kombiniert mit find sieht das so aus: </nowiki>
 
<div style="margin-left:0cm;margin-right:0cm;">find -name "*.py" -exec wc -l {} \;
10 ./x/abc.py
6 ./x/date-form.py
102 ./x/download.py </div>
 
Das Kommando <tt>wc -l</tt> (Anzahl der Zeilen zählen) wird auf jede gefundene Datei angewendet.
 
Die geschweiften Klammern werden durch die von find gefundenen Namen ersetzt.
 
Am Ende muss der ganze Befehl mit einem Semikolon abgeschlossen werden.
 
Damit das Semikolon nicht von der Shell interpretiert wird, muss man es mit einem Backslash oder Anführungsstrichen maskieren.
 
Kombination mit <tt>-print</tt>
 
<div style="margin-left:0cm;margin-right:0cm;">find tmp -name "a" -exec touch {} \; -print
./tmp/a
./tmp/a/a
./tmp/a/a/a </div>
 
<tt>touch</tt> setzt das Datum der Dateien auf den Ausführungszeitpunkt.
 
Da touch aber nicht den Dateinamen ausgibt sieht man nicht, welche Dateien nun betroffen waren. Daher schickt man ein <tt>-print</tt> hinterher.
 
== {{anchor|RefHeading2306821082722535}} Suche optimieren: xargs ==
 
Sollen viele Dateien bearbeiten werden wird für jede Datei ein eigene Befehl abgesetzt. Findet <tt>find(1)</tt> nun 2000 Dateien des Users toelpel, werden (hintereinander) 2000 Prozesse gestartet, die jeweils eine Datei löschen.
 
Das verlangsamt den Vorgang und erzeugt unnötig Last. <tt>rm(1)</tt> kann mehrere Dateien auf einmal löschen, ein einzelnes <tt>rm(1)</tt>-Kommando mit 2000 Argumenten wäre sinnvoller.
 
'''xargs''' erwartet als Parameter ein Kommando, welches dann auf Dateien einer Liste angewandt wird, die von der Standardeingabe gelesen werden.
 
Unter Linux/UNIX kann man fast alle Befehle auf einzelne Datei oder auch auf eine ganze Liste von Dateien anwenden.
 
Wenn dies nicht möglich sein sollte oder sich eine Dateiliste nicht mit Wildcards erstellen lässt, kann man das Kommando xargs verwenden.
 
Wenn viele Dateien (manchmal über den Verzeichnisbaum verteilt) gleichartig behandeln werden sollen, ob die Dateien nun gelöscht, der Eigentümer oder die Zugriffsrechte geändert werden soll, ist <tt>find(1)</tt> eine gute lösung.
 
<div style="margin-left:0cm;margin-right:0cm;">find / -user toelpel -exec rm  \{\} \;</div>
 
=== {{anchor|RefHeading4418100347735}} Syntax ===
 
xargs wird mit folgender Syntax in einem Terminal aufgerufen.
 
<div style="margin-left:0cm;margin-right:0cm;">Kommando1 | xargs [Optionen] Kommando2 </div>
 
Hierbei wird das "Kommando2" mit den Argumenten aufgerufen, die das "Kommando1" auf die Standardausgabe gibt.
 
<tt>xargs(1)</tt> hat die Funktion Kommandozeilen aus Standard-Input zu erstellen und auszuführen.
 
<div style="margin-left:0cm;margin-right:0cm;">find / -user toelpel -print | xargs rm</div>
 
<tt>find(1)</tt> listet alle Dateien des Users toelpel auf und reicht sie über die Pipe an xargs weiter. <tt>xargs(1)</tt> nimmt die Liste von der Standardeingabe und bastelt daraus und aus dem <tt>rm(1)</tt>, was ihm als Argument übergeben wurde, ein <tt>rm(1)</tt>-Kommando mit 2000 Argumenten.
 
Ergebnis: 3 Prozesse anstelle von 2001 Prozessen in der ersten Variante, um 2000 Dateien zu löschen.
 
=== {{anchor|RefHeading4420100347735}} Dateinamen mit Leerzeichen ===
 
Üblicher Weise enthält der IFS das Leerzeichen, daher bricht <tt>xargs </tt>die Dateinamen dort auseinander.
 
Dem ist abzuhelfen, wenn man die GNU-Version der benutzten Tools (find und xargs) verwendet. <tt>find(1)</tt> gibt man bekannt, er möge mit ASCII-NUL beendete Zeichenketten ausgeben, und xargs, er möge solche erwarten:
 
<div style="margin-left:0cm;margin-right:0cm;">find / -user toelpel -print0 | xargs -0 rm</div>
 
=== {{anchor|RefHeading4422100347735}} Eingabedatei als Parameter ===
 
Sollen die Dateien verschoben werden, erwartet mv die Quelldateien als erstes, das Zielverzeichnis als letztes Argument. Dieses Problem löst man bei <tt>xargs(1)</tt> genauso wie bei <tt>find(1)</tt>:
 
<div style="margin-left:0cm;margin-right:0cm;">find / -user toelpel -print0 | xargs -0 mv {} /tmp/toelpel-trash</div>
 
Die Zeichenkombination "{}" zeigt dem <tt>xargs(1)</tt>, an welcher Stelle er die Argumentliste für das Kommando einzufügen hat.
 
=== {{anchor|RefHeading4424100347735}} Optionen ===
 
 
{| style="border-spacing:0;margin:auto;width:17.501cm;"
|-
|-
| style="border-top:0.05pt solid #000000;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding:0.101cm;" | <tt>'''-a [Datei]</tt> oder <tt>--arg-file=[Datei]</tt> '''
| -user || Sucht Dateien des Benutzers Benutzername
| style="border:0.05pt solid #000000;padding:0.101cm;" | Liest die Argumente aus einer Datei anstatt von der Standardeingabe
|-
|-
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding:0.101cm;" | <tt>'''-0</tt> oder <tt>--null</tt> '''
| -exec ||Führt Befehl mit den gefundenen Dateien als Parameter aus. Die geschweiften Klammern stehen für den aktuell gefunden Dateinamen
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:0.05pt solid #000000;padding:0.101cm;" | Argumente werden aufgrund des NULL-Zeichens getrennt anstatt des Leerzeichen. Jedes Zeichen wird wörtlich genommen. Nützlich in Kombination mit der <tt>-print0</tt> Option von <tt>find</tt>.  
|-
|-
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding:0.101cm;" | <tt>'''-d [Trennzeichen]</tt> oder <tt>--delimiter=[Trennzeichen]</tt> '''
| -ok ||Führt Befehl nach Rückfrage aus
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:0.05pt solid #000000;padding:0.101cm;" | Argumente werden aufgrund des Trennzeichens getrennt anstatt des Leerzeichens. Jedes Zeichen wird wörtlich genommen. Das Trennzeichen kann ein einzelnes Zeichen sein, ein escaptes Zeichen, ein oktaler oder ein hexadezimaler Code. Mehrere Zeichen sind nicht erlaubt.
|-
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding:0.101cm;" | <tt>'''--help</tt> '''
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:0.05pt solid #000000;padding:0.101cm;" | Hilfe anzeigen.
|-
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding:0.101cm;" | <tt>'''-i'''</tt>
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:0.05pt solid #000000;padding:0.101cm;" | Standardmäßig wird "{}" als Ersatz-Zeichenkette verwendet, wie bei der Aktion <tt>-exec</tt> des Befehls <tt>find</tt>. xargs fügt dann die Dateiliste an der Stelle ein, wo die Ersatz-Zeichenkette steht. Dies kommt zur Anwendung wenn der Befehl die von xargs erzeugte Dateiliste nicht am Ende erwartet.
|-
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding:0.101cm;" | <tt>'''-p</tt> oder <tt>--interactive</tt> '''
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:0.05pt solid #000000;padding:0.101cm;" | Fragt vor jeder Ausführung, ob fortgefahren werden soll.
|-
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding:0.101cm;" | <tt>'''-r</tt> oder <tt>--no-run-if-empty</tt> '''
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:0.05pt solid #000000;padding:0.101cm;" | Führt "Kommando2" nicht aus, wenn die Standardeingabe keine Nicht-Leerzeichen enthält.
|-
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding:0.101cm;" | <tt>'''-n</tt> oder <tt>--max-args</tt> '''
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:0.05pt solid #000000;padding:0.101cm;" | Führt "Kommando2" auf jeweils eine bestimmt Anzahl von übergebenen Argumenten aus.
|-
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding:0.101cm;" | <tt>'''-P</tt> oder <tt>--max-procs</tt> '''
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:0.05pt solid #000000;padding:0.101cm;" | Führt "Kommando2" mehrfach aus. Mit der Kombination mit -n kann so eine bessere Auslastung des Systems erreicht werden.
|-
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:none;padding:0.101cm;" | <tt>'''-t</tt> oder <tt>--verbose</tt> '''
| style="border-top:none;border-bottom:0.05pt solid #000000;border-left:0.05pt solid #000000;border-right:0.05pt solid #000000;padding:0.101cm;" | Gibt mehr Informationen darüber, was gemacht wird.
 
 
|-
|-
|}
|}
=== {{anchor|RefHeading4426100347735}} Beispiele ===
<div style="margin-left:0cm;margin-right:0cm;">find /tmp -name core -type f -print | xargs /bin/rm -f</div>
Finde Dateien mit dem Namen core in oder unterhalb des Verzeichnisses /tmp und lösche diese.
Achtung, diese Aktion schlägt fehl falls die Dateinamen Zeilenvorschübe, einfache oder doppelte Anführungszeichen oder Leerzeichen enthalten.
Mit folgendem Befehl werden alle Dateien aus dem aktuellen Verzeichnis entfernt, die auf das Muster '''<nowiki>*.tmp</nowiki>''' passen.
Dabei werden Dateien, deren Namen Leerzeichen enthalten ebenfalls berücksichtigt:
<div style="margin-left:0cm;margin-right:0cm;">find . -name "*.tmp" -print0 | xargs -0 rm </div>
Als nächstes eine Anwendung mit der Ersatz-Zeichenkette {}. Alle Dateien des Benutzers mit der uid 1001 werden nach '''/tmp/klaus/test''' verschoben.
'''Achtung! '''
Die Verzeichnisstruktur wird dabei nicht wieder hergestellt. Die Dateien landen wirklich alle in '''/tmp/klaus/test'''.
<div style="margin-left:0cm;margin-right:0cm;">find . -uid 1001 -print | xargs -i mv {} /tmp/klaus/test </div>
Wenn man eine Datei '''software.list''' mit den Namen von Paketen hat, die sich im Verzeichnis '''~/installation/''' befindet und die wie folgt aufgebaut ist
<div style="margin-left:0cm;margin-right:0cm;">alltray
audacity
avidemux
azureus
compizconfig-settings-manager</div>
kann man mit
<div style="margin-left:0cm;margin-right:0cm;">xargs -a ~/installation/software.list sudo apt-get install </div>
die Pakete komfortabel alle auf einmal installieren. Dabei werden bereits installierte Pakete übersprungen.
Möchte man mehrere Dateien herunterladen, aber die Geschwindigkeit der Server lastet die eigene Internetverbindung nicht aus, so kann man mit xargs einfach mehrere Instanzen benutzen.
<div style="margin-left:0cm;margin-right:0cm;">xargs -a downloadlist -n 1 -P 4 wget </div>
Dieser Befehl übergibt jeweils eine URL aus der Datei '''downloadlist''' an wget.
Dabei wird wget vier mal jeweils mit einer anderen Datei gestartet.
So werden vier Dateien auf einmal heruntergeladen und die Internetverbindung optimal ausgenutzt.
==== {{anchor|RefHeading4428100347735}} Weitere Möglichkeiten ====
This command is equivalent to using <tt>find</tt> with <tt>xargs</tt>, only a bit shorter and more efficient.
But this form of <tt>‑exec</tt> can be combined with a shell feature to solve the other problem (names with spaces). The POSIX shell allows us to use:
<div style="margin-left:0cm;margin-right:0cm;">sh -c '''command-line''' [ ''command-name'' [ ''args''... ] ]</div>
We don't usually care about the ''command-name'', so “X”, “dummy”, “”, or “'inline cmd'” is often used.
Here's an example of efficiently copying found files to <tt>/tmp</tt>, in a POSIX-compliant way.
<div style="margin-left:0cm;margin-right:0cm;">find . -name '*.txt' -type f \
  -exec sh -c 'exec cp -f "$@" /tmp' X '{}' +</div>
Obvious, simple, and readable, isn't it?&nbsp; Perhaps not, but worth knowing since it is safe, portable, and efficient.
== {{anchor|RefHeading5679977924429}} Anwendungen ==
=== {{anchor|RefHeading134011942887705}} Beispiel 1 ===
Wo in meinem Homeordner liegt die Datei "test.pdf"?
<div style="margin-left:0cm;margin-right:0cm;">find ~ -name test.pdf</div>
Ihr habt vor ein paar Minuten eilig etwas gespeichert, habt aber den Namen der Datei und den Pfad sofort vergessen.
Irgendwo in eurem Homeordner, irgendein Name, vor ein paar Minuten...
<div style="margin-left:0cm;margin-right:0cm;">find ~ -type f ! -path '*/.*' -mmin -10 -ls</div>
Die Optionen im Einzelnen:* ~ -- rekursiv in meinem Homeordner
* -type f -- eine Datei (kein Ordner...)
* ! -path '*/.*' -- ohne Dateien oder Ordner, die mit Punkt beginnen.
* -mmin -10 -- nicht älter als 10 Minuten
* -ls -- lange Anzeige (wie ls -l)
Variante: mit Dotfiles, nicht aber Ordner, die mit Punkt beginnen (also ohne .gnome/ oder .kde/ usw., aber mit .bash_history). Und zwar alle Dateien, die nicht älter als zwei Tage sind.
<div style="margin-left:0cm;margin-right:0cm;">find ~ ! -path '*/.*/*' -type f -ctime -2</div>
Im Homeordner alle Dateien finden, deren Namen Leerzeichen enthalten.
Wieder ohne Dateien oder Ordner, die mit Punkt beginnen.
<div style="margin-left:0cm;margin-right:0cm;">find $HOME ! -path '*/.*' -type f -name '* *'</div>* $HOME -- ist gleichbedeutend mit ~
* -name '* *' -- Name enthält mindestens ein Leerzeichen
Ganz ähnlich, aber diesmal wird nach Ordnern gesucht:
<div style="margin-left:0cm;margin-right:0cm;">find $HOME ! -path '*/.*' -type d -name '* *'</div>
-type d -- Ordner (type directory)
Im Ordner public_html alle HTML und PHP Dateien ausfindig machen, in denen ".mp3" erwähnt wird.
Nur die Dateinamen ausgeben.
<div style="margin-left:0cm;margin-right:0cm;">find ~/public_html \( -name \*.html -o -name \*.php \) | xargs grep -l '.mp3'</div>
Zu beachten: ( ) * müssen vor der Bash versteckt, also mit Backslash escaped werden.
Andere Methode (-exec statt xargs), gleiches Ergebnis.
<div style="margin-left:0cm;margin-right:0cm;">find ~/public_html \( -name \*.html -o -name \*.php \) -exec grep -l '.mp3' '{}' \+</div>
Zu beachten: -exec mit''' \+''' abschließen statt mit '''\; '''beschleunigt das Abarbeiten ungemein, weil dann mehrere grep Prozesse parallell gestartet werden (vgl. xargs). Setzt eine halbwegs aktuelle Version von find voraus.
Hoppla, da sind auch Dateien mit Leerzeichen im Namen dabei? Kein Problem.
<div style="margin-left:0cm;margin-right:0cm;">find ~/public_html \( -name \*.html -o -name \*.php \) -print0 | xargs -0 grep -l '.mp3'</div>
finds Option -print0 erzeugt die richtige Ausgabe für xargs Option -0
Anderer Einsatzzweck: Plattenplatz wird knapp, wo sind die großen Dateien?
Also z.B.: in meinem Homeordner alle Dateien, die größer als 500MB sind.
<div style="margin-left:0cm;margin-right:0cm;">find ~ -size +500M</div>
Alle Dateien/Ordner in meinem Homeordner finden, die nicht mir gehören:
<div style="margin-left:0cm;margin-right:0cm;">find ~ ! -user $( whoami ) -ls</div>
Alle Dateien/Ordner in meinem Homeordner, die root gehören:
<div style="margin-left:0cm;margin-right:0cm;">find ~ -user root</div>
Alle Dateien/Ordner in meinem Homeordner, die die Rechte auf 777 gesetzt haben,
also Lese/Schreib/Ausführrechte für alle haben, lange Ausgabe wie "ls -l".
<div style="margin-left:0cm;margin-right:0cm;">find ~ -perm 777 -ls</div>
Welche Art von Dateien (Mimetype) liegen im Ordner Documents, mit Rücksicht auf Dateien mit Leerzeichen im Namen, nur in diesem Ordner, keine Unterordner:
<div style="margin-left:0cm;margin-right:0cm;">find ~/Documents/ -maxdepth 1 -type f -print0 | xargs -0 file</div>
Find sucht immer rekursiv, es sei denn, man schränkt mit "-maxdepth" die Tiefe ein. Die Liste ließe sich beliebig fortsetzen. Wie vielseitig find ist, zeigt sich schon an der Länge der manpage.
Find findet nach Name, Regex, Größe, Datum, Dateityp,... usw. und läßt sich mit "-exec" und der Pipe für "xargs" zu beinahe allem verwenden, was nur auf bestimmte Dateien/Ordner angewendet werden soll. Darum wird das Kommando in vielen Shellskripten verwendet.
=== {{anchor|RefHeading7015139995267}} [http://techblog.7d0.de/2009/01/beispiele-zur-benutzung-von-grep-und-find/ Beispiel] 2 ===
Dateien im aktuellen Ordner und Unterordnern finden, deren Namen einem bestimmen Muster entsprechen:
<div style="margin-left:0cm;margin-right:0cm;">find . -name "*.jpg"</div>
Dateien finden, deren Namen nicht einem bestimmten Muster entsprechen:
<div style="margin-left:0cm;margin-right:0cm;">find . \! -name "*.jpg"</div>
Dateien finden, deren Namen einem bestimmten Muster entsprechen und die einen bestimmten Text enthalten:
<div style="margin-left:0cm;margin-right:0cm;">find . -name "*.php" -exec grep -il "suchtext" {} \;</div>
Dateien finden, die bestimmte Datei-Endungen haben (Mit Regular-Expressions finden):
<div style="margin-left:0cm;margin-right:0cm;">find . -regex ".*(php|html|tpl)$"</div>
Große Dateien finden (Dateien finden, die größer als ca. 500 MB sind):
<div style="margin-left:0cm;margin-right:0cm;">find . -type f -size +500000k -exec ls -lh {} \;</div>
Dateien finden, deren Pfade einem bestimmten Pattern entsprechen:
<div style="margin-left:0cm;margin-right:0cm;">find . -path "*/.svn*"</div>
Dateien finden, deren Pfade nicht einem bestimmten Pattern entsprechen:
<div style="margin-left:0cm;margin-right:0cm;">find . \! -path "*/.svn*"</div>
Dateien finden, die nicht einem bestimmten User (nicht root) gehören:
<div style="margin-left:0cm;margin-right:0cm;">find . \! -user root</div>
Dateien finden, die “oo” oder “ee” im Namen haben:
<div style="margin-left:0cm;margin-right:0cm;">find . \( -name "*oo*" -or -name "*ee*" \)</div>
Dateien finden, die nicht “oo” oder “ee” im Namen haben:
<div style="margin-left:0cm;margin-right:0cm;">find . \! \( -name "*oo*" -or -name "*ee*" \)</div>
Geht nicht mit find (GNU findutils) 4.4.2:
<div style="margin-left:0cm;margin-right:0cm;">'''find . -regex “.*(php|html|tpl)$”'''
mkdir /tmp/tst
cd /tmp/tst
mkdir -p 1/2/3
mkdir -p 4/5/6
touch la.php
touch 1/2/uu.tpl
touch 4/lala.html
touch 4/5/6/eee.php
touch 4/5/oooooo'
find . -regex “.*(php|html|tpl)$”</div>
es wird nix ausgegeben :(
=== {{anchor|RefHeading4446100347735}} Beispiel 3 ===
Angenommen, Sie möchten eine Liste der Verzeichnisse in <tt>/usr/share</tt> erhalten, dann tippen Sie:
<div style="margin-left:0cm;margin-right:0cm;">find /usr/share -type d</div>
Angenommen, Sie haben einen HTTP-Server und alle Ihre HTML-Dateien befinden sich in <tt>/home/httpd/html</tt>, wo Sie sich auch gerade befinden. Sie möchten eine Liste aller Dateien, deren Inhalt seit einem Monat nicht verändert worden ist.
Da die Seiten von verschiedenen Schreibern stammen, enden einige auf <tt>html</tt> und einige auf <tt>htm</tt>. Sie möchten diese Dateien in das Verzeichnis <tt>/home/httpd/obsolete</tt> verknüpfen.
Geben Sie folgendes ein:[http://www.murnauer.de/mandrakeref/command-find.html#FTN.AEN4397 []
[http://www.murnauer.de/mandrakeref/command-find.html#FTN.AEN4397 Denken Sie daran, dass in diesem Beispiel beide Verzeichnisse auf dem selben Dateisystem sein müssen!]]
<div style="margin-left:0cm;margin-right:0cm;">find \( -name "*.htm" -o -name "*.html" \) -a -ctime -30 -exec
ln {} /home/httpd/obsolete \;</div>
Gut, das hier ist etwas komplex und verlangt nach Erklärung. Das Suchkriterium ist Folgendes:
<div style="margin-left:0cm;margin-right:0cm;">\( -name "*.htm" -o -name "*.html" \) -a -ctime -30</div>
Es findet alle Dateien, die entweder auf <tt>.htm</tt> oder auf <tt>.html</tt> enden (<tt>( -name "*.htm" -o -name "*.html" )</tt>) und (<tt>-a</tt>) die in den letzten 30 Tagen nicht modifiziert wurden (<tt>-ctime -30</tt>). Beachten Sie die Klammern, die hier notwendig sind, da <tt>-a</tt> eine höhere Wertigkeit hat.
Ließen Sie sie weg, würde das Kommando alle Dateien mit der Endung <tt>.htm</tt> finden sowie die Dateien, die auf <tt>.html</tt> enden und seit einem Monat nicht modifiziert wurden.
Beachten Sie auch, dass die Klammern vor der Shell geschützt wurden. Gäben Sie <tt>( .. )</tt> anstelle von <tt>\( .. \)</tt> ein, würde die Shell versuchen, diese zu interpretieren und das Kommando <tt>-name "*.htm" -o -name "*.html"</tt> in einer Sub-Shell auszuführen.
Sie können diesen Schutz übrigens auch durch Anführungszeichen erreichen.
Und schließlich das Kommando, das für jede gefundene Datei ausgeführt wird:
<div style="margin-left:0cm;margin-right:0cm;">-exec ln {} /home/httpd/obsolete \;</div>
Auch hier müssen Sie das <tt><nowiki>;</nowiki></tt> vor der Shell schützen, da diese es sonst als Kommandoseparator interpretiert und find sich beschweren wird, dass <tt>-exec</tt> ein Argument fehlt.
Ein letztes Beispiel:
Sie haben ein großes Verzeichnis mit allen möglichen Bilddateien: <tt>/shared/images</tt>.
Normalerweise benutzen Sie touch, um den Zeitstempel einer Datei namens <tt>stamp</tt> in diesem Verzeichnis aufzufrischen, um eine Zeitreferenz zu haben.
Sie wollen eine Liste aller JPEG-Dateien, die jünger als die Datei <tt>stamp</tt> sind.
Da Sie die Dateien von verschiedenen Quellen haben, haben Sie die Endungen <tt>jpg</tt>, <tt>jpeg</tt>, <tt>JPG</tt> oder <tt>JPEG</tt>. Sie möchten nicht im Verzeichnis <tt>old</tt> suchen, Sie möchten diese Liste zugeschickt bekommen und Ihr Benutzername ist <tt>john</tt>:
<div style="margin-left:0cm;margin-right:0cm;">find /shared/images -cnewer    \
      /shared/images/stamp      \
      -a -iregex ".*\.jpe?g"    \
      -a -not -regex ".*/old/.*" \
        | mail john -s "Neue Images"</div>
Nun wäre es nicht sehr schön, dieses Kommando regelmäßig neu eingeben zu müssen, also brauchen Sie…?
== {{anchor|RefHeading7028339995267}} Erweiterte Anwendungen ==
The “<tt>‑print</tt>” action lists the names of files separated by a newline.
But it is common to ''pipe'' the output of <tt>find</tt> into <tt>xargs</tt>, which uses a space to separate file names.
This can lead to problems if any found files contain spaces in their names, as the output doesn't use any quoting.
In such cases, when the output of <tt>find</tt> contains a file name such as “<tt>foo bar</tt>” and is piped into another command, that command “sees” two file names, not one file name containing a space.
Even without using <tt>xargs</tt>, you could have a problem if the file name contains a newline character, as most utilities expect one file name per line.
In such cases, you can specify the action “<tt>‑print0</tt>” instead. This lists the found files separated not with a newline but with a ''null'' (or “”) character, which is not a legal character in Unix or Linux file names.
Of course the command that reads the output of <tt>find</tt> must be able to handle such a list of file names.
Many commands commonly used with <tt>find</tt> (such as <tt>tar</tt> or <tt>cpio</tt>) have special options to read in file names separated with NULs instead of spaces.
Instead of having <tt>find</tt> list the files, it can run some command for each file found, using the “<tt>‑exec</tt>” action. The <tt>‑exec</tt> is followed by some shell command line, ended with a semicolon (“<tt><nowiki>;</nowiki></tt>”).
(The semicolon must be quoted from the shell, so <tt>find</tt> can see it!) Within that command line, the word “<tt>{}</tt>” will expand out to the name of the found file. See below for some examples.
You can use shell-style wildcards in the <tt>‑name</tt> search argument:
<div style="margin-left:0cm;margin-right:0cm;">find . -name foo\*bar</div>
This will search from the current directory down for <tt>foo*bar</tt> (that is, any filename that begins with <tt>foo</tt> and ends with <tt>bar</tt>).
Note that wildcards in the name argument must be quoted so the shell doesn't expand them before passing them to <tt>find</tt>.
Also, unlike regular shell wildcards, these will match leading periods in filenames. (For example “<tt>find ‑name \*.txt</tt>” would match “<tt>.foo.txt</tt>”.)
You can search for other criteria beside the name. Also you can list multiple search criteria.
When you have multiple criteria, any found files must match all listed criteria.
That is, there is an implied Boolean ''AND'' operator between the listed search criteria. <tt>find</tt> also allows ''OR'' and ''NOT'' Boolean operators, as well as grouping, to combine search criteria in powerful ways (not shown here.)
Here's an example using two search criteria:
<div style="margin-left:0cm;margin-right:0cm;">find / '''-type f -mtime -7''' | xargs tar -rf weekly_incremental.tar
gzip weekly_incremental.tar</div>
will find any regular files (i.e., not directories or other special files) with the criterion “<tt>‑type f</tt>”, and only those modified seven or fewer days ago (“<tt>‑mtime ‑7</tt>”).
Note the use of <tt>xargs</tt>, a handy utility that coverts a stream of input (in this case the output of <tt>find</tt>) into command line arguments for the supplied command (in this case <tt>tar</tt>, used to create a backup archive).
Using the <tt>tar</tt> option “<tt>‑c</tt>” is dangerous here; <tt>xargs</tt> may invoke <tt>tar</tt> several times if there are many files found, and each “<tt>‑c</tt>” will cause <tt>tar</tt> to over-write the previous invocation.
The “<tt>‑r</tt>” option ''appends'' files to an archive. Other options such as those that would permit filenames containing spaces would be useful in a “production quality” backup script.
Another use of <tt>xargs</tt> is illustrated below. This command will efficiently remove all files named <tt>core</tt> from your system (provided you run the command as root of course):
<div style="margin-left:0cm;margin-right:0cm;">find / -name core | xargs /bin/rm -f
find / -name core -exec /bin/rm -f '{}' \; # same thing
find / -name core -delete                  <nowiki># same if using Gnu find</nowiki></div>
The last two forms run the <tt>rm</tt> command once per file, and are not as efficient as the first form; but they are safer if file names contain spaces or newlines.
The first form can be made safer if rewritten to use “<tt>‑print0</tt>” instead of (the default) “<tt>‑print</tt>”. “<tt>‑exec</tt>” can be used more efficiently (see [http://content.hccfl.edu/pollock/Unix/FindCmd.htm#exec Using ][http://content.hccfl.edu/pollock/Unix/FindCmd.htm#exec ‑exec][http://content.hccfl.edu/pollock/Unix/FindCmd.htm#exec  Efficiently] below), but doing so means running the command once with many file names passed as arguments, and so has the same safety issues as with <tt>xargs</tt>.
One of my favorite of the <tt>find</tt> criteria is used to locate files modified less than 10 minutes ago. I use this right after using some system administration tool, to learn which files got changed by that tool:
<div style="margin-left:0cm;margin-right:0cm;">find / -mmin -10</div>
This search is also useful when I've downloaded some file but can't locate it, only in that case “<tt>‑cmin</tt>” may work better.
Keep in mind neither of these criteria is standard; “<tt>‑mtime</tt>” and “<tt>‑ctime</tt>” are standard, but use days and not minutes.
Another common use is to locate all files owned by a given user (“<tt>‑user </tt>''username''”). This is useful when deleting user accounts.
You can also find files with various permissions set. “<tt>‑perm /</tt>''permissions''” means to find files with '''any''' of the specified ''permissions'' on, “<tt>‑perm -</tt>''permissions''” means to find files with '''all''' of the specified ''permissions'' on, and “<tt>‑perm </tt>''permissions''” means to find files with '''exactly''' ''permissions''. ''Permissions'' can be specified either symbolically (preferred) or with an octal number.
The following will locate files that are writable by “others” (including symlinks, which should be writable by all):
<div style="margin-left:0cm;margin-right:0cm;">find . -perm -o=w</div>
(Using <tt>‑perm</tt> is more complex than this example shows.
You should check both the [http://www.opengroup.org/onlinepubs/9699919799/utilities/find.html#tag_20_47_04 POSIX documentation for ][http://www.opengroup.org/onlinepubs/9699919799/utilities/find.html#tag_20_47_04 find] (which explains how the symbolic modes work) and the [http://www.gnu.org/software/findutils/manual/html_mono/find.html#Overview Gnu ][http://www.gnu.org/software/findutils/manual/html_mono/find.html#Overview find][http://www.gnu.org/software/findutils/manual/html_mono/find.html#Overview  man page] (which describes the Gnu extensions).
When using <tt>find</tt> to locate files for backups, it often pays to use the “<tt>‑depth</tt>” option (really a criterion that is always true), which forces the output to be ''depth-first''—that is, files first and then the directories containing them.
This helps when the directories have restrictive permissions, and restoring the directory first could prevent the files from restoring at all (and would change the time stamp on the directory in any case).
Normally, <tt>find</tt> returns the directory first, before any of the files in that directory.
This default behavior is useful when using the “<tt>‑prune</tt>” action to prevent <tt>find</tt> from examining any files you want to ignore:
<div style="margin-left:0cm;margin-right:0cm;">find / -name /dev -prune ...''other criteria'' | xargs tar ...</div>
Using just “<tt>find / ‑name /dev ‑prune | xargs tar ...</tt>” won't work as most people might expect. This says to only find files named “<tt>/dev</tt>”, and then (if a directory) don't descend into it. So you only get the single directory name “<tt>/dev</tt>”! A better plan is to use the following:
<div style="margin-left:0cm;margin-right:0cm;">find / ! -path /dev\* |xargs ...</div>
which says find everything except pathnames that start with “<tt>/dev</tt>”. The “<tt>!</tt>” means Boolean ''NOT''.
When specifying time with <tt>find</tt> options such as <tt>‑mmin</tt> (minutes) or <tt>‑mtime</tt> (24 hour periods, starting from now), you can specify a number “''n''” to mean exactly ''n'', “''‑n''” to mean less than ''n'', and “''+n''” to mean more than ''n''.
Fractional 24-hour periods are truncated! That means that “<tt>find ‑mtime +1</tt>” says to match files modified '''two or more days ago.'''
For example:
<div style="margin-left:0cm;margin-right:0cm;">find . -mtime 0  <nowiki># find files modified between now and 1 day ago</nowiki>
                  <nowiki># (i.e., within the past 24 hours)</nowiki>
find . -mtime -1  <nowiki># find files modified less than 1 day ago</nowiki>
                  <nowiki># (i.e., within the past 24 hours, as before)</nowiki>
find . -mtime 1  <nowiki># find files modified between 24 and 48 hours ago</nowiki>
find . -mtime +1  <nowiki># find files modified more than 48 hours ago</nowiki>
find . -mmin +5 -mmin -10 # find files modified between
                          <nowiki># 6 and 9 minutes ago</nowiki></div>
=== {{anchor|RefHeadingToc52274055916525}} Find und Sort ===
<div style="margin-left:0cm;margin-right:0cm;">find -type f -print0 | xargs -0 stat -c "%y %n" | sort -r | head -20</div>
==== Sort by size ====
<div style="margin-left:0cm;margin-right:0cm;">find -type f -exec ls -ltu {} \; | sort -k 5 -n</div>
==== Sort by access time ====
<div style="margin-left:0cm;margin-right:0cm;">find -type f -exec ls -ltu {} \; | sort -k 6 -M</div>
==== Search recursively by date ====
<div style="margin-left:0cm;margin-right:0cm;">find -printf "%TY-%Tm-%Td %TT %p\n" | tail -20 | sort -n</div>
Have you ever wanted to view a list of all files or subdirectories within a directory in Linux and order them by when they were last changed or modified? Then you have come to the right place! Here we are going to provide and explain some useful commands that when piped together will give us this result, allowing us to recursively list files and directories by date.
This is one of my favourite commands to use when trying to build a timeline of events, for instance if a server or website has been compromised and you want to see when files have been modified with malicious content. By seeing other files that were modified around the same time you can get a better idea of what took place and when, allowing you to correlate these events with your logs.
===== {{anchor|RefHeadingToc3064060109319}} The Commands =====
So here are the simple commands piped together, run this within a directory and you will be provided with a list of all files and subdirectories along with the date they were last modified. The most recently changed contents will be at the bottom of the list, so after running it you’ll see the most recent changes with the older changes as you scroll up. If you have a lot of output piping the whole lot into ‘less’ may be a good idea so that you can easily scroll through.
find . -printf '%T@ %t %p\n' | sort -k 1 -n | cut -d' ' -f2-
Below is an example output from running this full command.
'''<nowiki># find . -printf '%T@ %t %p\n' | sort -k 1 -n | cut -d' ' -f2-</nowiki>'''
Wed Aug 26 09:25:04.0000000000 2015 ./images/1.jpg
Tue Sep  1 06:27:43.0000000000 2015 ./1.JPG
Sat Sep 12 12:36:51.0000000000 2015 ./directory/6.jpg
Sat Sep 12 12:43:48.0166880221 2015 ./directory
Mon Oct 12 05:18:21.0000000000 2015 ./images/7.jpg
Sun Oct 18 08:29:46.0000000000 2015 ./8.jpg
Wed Oct 21 10:50:16.0672628610 2015 ./index.html
As shown we can see the files sorted from oldest date and time modified to newest. Now let’s break down what each part is actually doing for us.
====== {{anchor|RefHeadingToc3084060109319}} [http://linux.die.net/man/1/find Find] ======
First off the find command is run which finds us the list of all files and subdirectories recursively within the current working directory, as specified by the “.” after the find command. To confirm your current working directory you can run the “pwd” command. You can change the “.” to a full directory path instead to list all files and subdirectories in there instead if required, this way you don’t have to be in the directory.
The “-printf” flag is used to print the output in the format specified, in this case this is ‘%T@ %t %p\n’. The %T@ displays the epoch time, that is the amount of seconds since the 1st of January 1970, the %t shows the files last modification time, the %p displays the files name while \n is simply a new line so that each result in our output shows up on a new line which makes it easier to read and work with.
It is worth noting that you could also replace %t with %c, which will instead use the files last status change time rather than the modification time. This should show things such as permission changes which don’t actually modify the contents file but change the metadata.
The output of this find command alone looks like this.
1445424616.6726286100 Wed Oct 21 10:50:16.0672628610 2015 ./index.html
At this stage the output does not display in any sort of chronological order. We can see the output displayed as expected, the files epoch time followed by the last modification date and time, followed by the file name.
====== {{anchor|RefHeadingToc3104060109319}} [http://linux.die.net/man/1/sort Sort] ======
Now with this output you may have noticed that there is no order applied, this is taken care of with the sort command. The -k flag specifies a start position which in this case is 1, the first column being the epoch time.
The output with the sort is shown below, now we have the files in the same order as the output of the full command string shown previously after sorting by column 1, the epoch time. As the epoch time is all numbers, we also use -n to perform a numerical based sort.
1440581104.0000000000 Wed Aug 26 09:25:04.0000000000 2015 ./images/1.jpg
1441088863.0000000000 Tue Sep  1 06:27:43.0000000000 2015 ./1.JPG
1442061411.0000000000 Sat Sep 12 12:36:51.0000000000 2015 ./directory/6.jpg
1442061828.1668802210 Sat Sep 12 12:43:48.0166880221 2015 ./directory
1444627101.0000000000 Mon Oct 12 05:18:21.0000000000 2015 ./images/7.jpg
1445156986.0000000000 Sun Oct 18 08:29:46.0000000000 2015 ./8.jpg
1445424616.6726286100 Wed Oct 21 10:50:16.0672628610 2015 ./index.html
We can change -n to -nr which will reverse the output, resulting in the oldest modified files showing at the bottom of the output, rather than the newest.
====== {{anchor|RefHeadingToc3124060109319}} [http://linux.die.net/man/1/cut Cut] ======
Now that we have our sorted output we use the cut command to tidy up and print out a more specific selection. By specifying a delimiter with -d of ‘ ‘ we find the first white space which comes after the epoch time and cut everything afterwards.
At this point we now have the complete output which lists all files by date recursively from the specified directory. The epoch time provided an easy way to perform the sort, but we don’t really need to see that in the final output as it isn’t particularly human readable so it’s been removed after the sort.
===== {{anchor|RefHeadingToc3144060109319}} Other Options =====
Of course you can always use the much simpler “ls -lrt” within a directory to view all files within the current working directory from oldest to newest, however this does not take into consideration subfolder contents. Even if we use the recursive option and use “ls -lRrt” we only see the files ordered based on the dates within each directory and not a combination of all subdirectories.
If you aren’t interested in the subdirectories themselves you could also add a “-type f” to the find command which will only list files, as shown below.
find . '''-type f''' -printf '%T@ %t %p\n' | sort -k 1 -n | cut -d ' ' -f2-
This still lists files within subdirectories, it simply no longer also shows the subdirectory names themselves in the output.
The opposite can also be done, by using “-type d” which will display only directories and no files.
find . '''-type d''' -printf '%T@ %t %p\n' | sort -k 1 -n | cut -d ' ' -f2-
===== {{anchor|RefHeadingToc3164060109319}} Summary =====
By combining a few relatively simple bash commands in Linux we have been able to successfully list all files and subdirectories within a specified directory recursively by their modification or change date, in either ascending or descending order. We can also optionally specify to only view files or directories in the output.
This command is a great way of building a timeline of events as the chronological output allows us to see the order of file modifications, regardless of where the file is actually located.
===== {{anchor|RefHeadingToc3184060109319}} Quelle =====
* <tt>Posted by [https://www.rootusers.com/author/jarrod/ Jarrod] on November 25, 2015 [https://www.rootusers.com/how-to-search-all-files-by-date-recursively-in-linux/#respond Leave a comment] (1) [https://www.rootusers.com/how-to-search-all-files-by-date-recursively-in-linux/#comments Go to comments]
==== Weitere Lösungen ====
<div style="margin-left:0cm;margin-right:0cm;">find -type f -printf '%T@ %p\0' | sort -zk 1nr | sed -z 's/^[^ ]* //' | tr '\0' '\n' | head -n 10</div>
<div style="margin-left:0cm;margin-right:0cm;">find -type f -printf '%T@ %p\n' | sort -k1 -n</div>
<div style="margin-left:0cm;margin-right:0cm;">find -type f -print0 | xargs -0 stat -c "%y %n" | sort</div>
<div style="margin-left:0cm;margin-right:0cm;">find -type f -print0 | xargs -0 stat -f "%m %Sm %N" | sort -rn</div>
If you have not GNU utilities, you could use newlines as separators instead of nulls, but you'll lose support for filenames containing newlines.
<div style="margin-left:0cm;margin-right:0cm;">find -type f -printf '%T@ %p\n' | sort -k 1nr | sed 's/^[^ ]* //'</div>
=== {{anchor|RefHeadingToc4923640187039}} Compare Filetree ===
<div style="margin-left:0cm;margin-right:0cm;">find directory1 -type d -printf "%P\n" | sort > file1
find directory2 -type d -printf "%P\n" | sort | diff – file1</div>
== {{anchor|RefHeading7188315101596}} Typische Probleme ==
=== {{anchor|RefHeading4430100347735}} Find ohne Ende ===
Wenn die Suche mit find läuft und viel zu viele Ergebnisse ausspuckt und nicht aufhören will, so bricht man find mit Strg + C ab.
=== {{anchor|RefHeading4432100347735}} Pfad muss vor Suchkriterium stehen ===
Wenn man den Stern <tt><nowiki>*</nowiki></tt> nicht maskiert kommt es oft zu folgender Meldung:
<div style="margin-left:0cm;margin-right:0cm;">find /tmp -name *sh
find: Der Pfad muß vor dem Suchkriterium stehen: adhoc.sh
Aufruf: find [-H] [-L] [-P] [-Olevel] [-D help|tree|search|stat|rates|opt|exec] [Pfad...] [Suchkriterium] </div>
Mit
<div style="margin-left:0cm;margin-right:0cm;">find /tmp -name "*sh" </div>
ist das leicht geheilt.
=== {{anchor|RefHeading4434100347735}} Seltsame Größen ===
Bei der Suche nach Dateigrößen kann man leicht verzweifeln, wenn man nicht dahinter kommt, dass die Vorgabemaßeinheit Blöcke zu 512 Bytes sind.
<div style="margin-left:0cm;margin-right:0cm;">find -size 200c  </div>
sucht nach Größen, die man vom Dezimalsystem her erwartet.
====== {{anchor|RefHeading4436100347735}} Seltsames Nichtfinden bei Größen wie k, M, G ======
Sucht man nach Dateien, die kleiner sind als 1000k, so werden Dateien bis maximal 999k gefunden:
<div style="margin-left:0cm;margin-right:0cm;">find -size -1000k  </div>
Das klingt zunächst plausibel, aber es wird keine Datei gefunden, die 999001 Bytes groß ist, denn es wird erst aufgerundet (auf 1000k) und dann verglichen (nicht kleiner als 1000k).
Krasser noch, wenn man Dateien bis 1M suchen wollte - selbst 1 Byte ist größer als die nächstkleinere Ganzzahl in dieser Maßeinheit, also größer als 0M, und wird daher nicht gefunden.
=== {{anchor|RefHeading4438100347735}} Kombination von UND und ODER  ===
Bei der Kombination von mehreren Optionen mit UND und ODER helfen Klammern Fehler zu vermeiden.
=== {{anchor|RefHeading4440100347735}} Positionssensitiv ===
Bei mehreren Optionen und Ausdrücken (options und expressions) unterscheiden sich erstere von zweiteren dadurch, dass Optionen nicht mit 'ODER' gruppiert werden können - die Optionen werden immer für die ganze Suche verwendet.
Stehen die Optionen hinter Ausdrücken, so sieht das aus, als habe der User eine andere Absicht gehabt, und man bekommt eine Warnung:
Folgende Meldung erhält man, wenn man Optionen nach Argumenten benutzt.
<div style="margin-left:0cm;margin-right:0cm;">find tmp -name "a" -maxdepth 3 -mindepth 3 </div>
<div style="margin-left:0cm;margin-right:0cm;">find: Warnung: Sie haben die Option `-maxdepth` nach dem Argument -name angegeben, aber Optionen sind nicht positionssensitiv (`-maxdepth` beeinträchtigt sowohl Tests, die vor ihr als auch nach ihr definiert sind). Diese Optionen ist vor den anderen Argumenten anzugeben. </div>
Provozieren kann man die Warnung etwa so:
<div style="margin-left:0cm;margin-right:0cm;">find ./suchverzeichnis -maxdepth 4 -name foo -or -maxdepth 2 </div>
=== {{anchor|RefHeading4442100347735}} Xargs und Schleifen ===
Oft findet man Konstruktionen mit <tt>find ... xargs</tt> oder Shellschleifen die find bemühen.
Fast immer lässt sich das Problem durch eine der [http://wiki.ubuntuusers.de/find#Aktionen Aktionen] (-okdir, -execdir, ...) eleganter lösen.
=== {{anchor|RefHeading4444100347735}} Aktion -delete an falscher Stelle ===
So löscht z.B. der folgende Aufruf den kompletten Inhalt des Ordners '''/home/otto/''':
<div style="margin-left:0cm;margin-right:0cm;">find /home/otto/ -delete -name Cache  </div>
=== {{anchor|RefHeading7028739995267}} Common “Gotcha” ===
If the given expression to <tt>find</tt> does not contain any of the “action” primaries <tt>‑exec</tt>, <tt>‑ok</tt>, or <tt>‑print</tt>, the given expression is effectively replaced by:
<div style="margin-left:0cm;margin-right:0cm;">find \( ''expression'' \) -print</div>
The implied parenthesis can cause unexpected results. For example, consider these two similar commands:
<div style="margin-left:0cm;margin-right:0cm;">'''find -name tmp -prune -o -name \*.txt'''
./bin/data/secret.txt
./tmp
./missingEOL.txt
./public_html/graphics/README.txt
./datafile.txt</div>
<div style="margin-left:0cm;margin-right:0cm;">'''find -name tmp -prune -o -name \*.txt -print'''
./bin/data/secret.txt
./missingEOL.txt
./public_html/graphics/README.txt
./datafile.txt</div>
The lack of an action in the first command means it is equivalent to:
<div style="margin-left:0cm;margin-right:0cm;">find . \( -name tmp -prune -o -name \*.txt \) -print</div>
This causes <tt>tmp</tt> to be included in the output. However for the second <tt>find</tt> command the normal rules of Boolean operator precedence apply, so the pruned directory does not appear in the output.
A related issue is the precedence of the Boolean operators.&nbsp; OR has lower precedence than AND, and NOT has the highest precedence.&nbsp; When in any doubt, add parenthesis to your expressions.
The <tt>find</tt> command can be amazingly useful.&nbsp; See the man page to learn all the criteria and actions you can use.
=== {{anchor|RefHeading7014539995267}} -regex ===
I'm having trouble using the regex of the <tt>find</tt> command. Probably something I don't understand about escaping on the command line.


Why are these not the same?


<div style="margin-left:0cm;margin-right:0cm;">find -regex '.*[1234567890]'</div>
<div style="margin-left:0cm;margin-right:0cm;"><nowiki>find -regex '.*[[:digit:]]'</nowiki></div>


Regular expressions with character classes (e.g. <tt><nowiki>[[:digit:]]</nowiki></tt>) are not supported in the default regular expression syntax used by <tt>find</tt>. You need to specify a different regex type such as <tt>posix-extended</tt> in order to use them.
=== Parameter ===
=== Umgebungsvariablen ===
=== Exit-Status ===


Take a look at GNU Find's Regular Expression [http://www.gnu.org/software/findutils/manual/html_mono/find.html#Regular-Expressions documentation] which shows you all the regex types and what they support.
<noinclude>


I have some images named with generated uuid1 string. For example 81397018-b84a-11e0-9d2a-001b77dc0bed.jpg. I want to find out all these images using "find" command:
== Anhang ==
=== Siehe auch ===
{{Special:PrefixIndex/{{BASEPAGENAME}}}}
----
* [[chmod]](1)
* [[locate]](1)
* [[ls]](1)
* [[xargs]](1)
* [[lstat]](2)
* [[stat]](2)
* [[ctime]](3)
* [[fnmatch]](3)
* [[printf]](3)
* [[strftime]](3)
* [[regex]](7)


<div style="margin-left:0cm;margin-right:0cm;">find . -regex "[a-f0-9\-]\{36\}\.jpg".</div>
==== Dokumentation ====


But it doesn't work. Something wrong with the regex? Could someone help me with this?
===== Man-Page =====
# find


<div style="margin-left:0cm;margin-right:0cm;">find . -regextype sed -regex ".*/[a-f0-9\-]\{36\}\.jpg"</div>
===== Info-Pages =====
==== Links ====
===== Projekt =====
===== Weblinks =====


Note that you need to specify <tt>.*/</tt> in the beginning because <tt>find</tt> matches the whole path.
[[Kategorie:Find]]


==== Beispiel ====
{{DEFAULTSORT:find}}
{{DISPLAYTITLE:find}}


<div style="margin-left:0cm;margin-right:0cm;">'''$ find . -name "*.jpg"'''
</noinclude>
./foo-111.jpg
./test/81397018-b84a-11e0-9d2a-001b77dc0bed.jpg
./81397018-b84a-11e0-9d2a-001b77dc0bed.jpg</div>
<div style="margin-left:0cm;margin-right:0cm;">'''$ find . -regextype sed -regex ".*/[a-f0-9\-]\{36\}\.jpg"'''
./test/81397018-b84a-11e0-9d2a-001b77dc0bed.jpg
./81397018-b84a-11e0-9d2a-001b77dc0bed.jpg</div>
<div style="margin-left:0cm;margin-right:0cm;">'''$ find . -regextype foo -regex ".*/[a-f0-9\-]\{36\}\.jpg"'''
find: Unknown regular expression type `foo'; valid types are `findutils-default', `awk', `egrep', `ed', `emacs', `gnu-awk', `grep', `posix-awk', `posix-basic', `posix-egrep', `posix-extended', `posix-minimal-basic', `sed'.</div>

Aktuelle Version vom 12. November 2024, 18:41 Uhr

find - Dateien nach Eigenschaften suchen

Beschreibung

Werkzeug für die Suche nach Dateien
  • kann auf vielfältige Weise die Suche filtern
  • Etwa Dateiname, -alter oder -größe
  • Formatierung der Ergebnisliste
  • Suchergebnisse können weiterverarbeiten werden

Implementierungen

Nicht alle Implementierungen von find sind gleich
  • Der Befehl find ist unter Linux etwas anders als auf BSDs, Solaris oder Mac OS X.
  • Ein Großteil der Syntax von find ist gleich und kann auf allen Systemen verwendet werden, aber nicht vollständig.

Bei Schwierigkeiten prüfen Sie die man-Page des Systems. 

find --version
find (GNU findutils) 4.4.2

Abgrenzung

Programm  Beschreibung
locate Suche nur nach Dateinamen
  • Sehr schnell, da Indexbasiert, der täglich aktualisiert wird
  • Findet jedoch nur Dateien, die im Index enthalten sind
whereis Suche nach Programmen
Aktuelles Verzeichnis
Weitere Manche Programme an, Unterverzeichnisse zu berücksichtigen

Installation

apt install findutils

Aufruf

find [-H] [-L] [-P] [-D Fehlersuchoptionen] [-OStufe] [Startpunkt …] [Ausdruck]

Optionen

Option Beschreibung
-name Sucht Dateien nach Dateinamen
-iname Sucht nach Dateinamen und ignoriert Groß- und Kleinschreibung
-size Sucht Dateien, die größer oder kleiner als größer sind
-type Sucht Dateien eines bestimmten Typs
-atime Sucht Dateien, auf die seit mehr oder weniger als X Tagen nicht mehr zugegriffen wurde
-amin Sucht Dateien, auf die seit mehr oder weniger als X Minuten nicht mehr zugegriffen wurde
-mtime Sucht Dateien, die seit mehr oder weniger als X Tagen nicht mehr verändert wurden
-mmin Sucht Dateien, die seit mehr oder weniger als X Minuten nicht mehr verändert wurden
-perm Sucht Dateien nach Zugriffsrechten
-user Sucht Dateien des Benutzers Benutzername
-exec Führt Befehl mit den gefundenen Dateien als Parameter aus. Die geschweiften Klammern stehen für den aktuell gefunden Dateinamen
-ok Führt Befehl nach Rückfrage aus


Parameter

Umgebungsvariablen

Exit-Status

Anhang

Siehe auch

Dokumentation

Man-Page
  1. find
Info-Pages

Links

Projekt
Weblinks



Abgerufen von „https://wiki.foxtom.de/index.php?title=Find&oldid=115108“