You do not have permission to edit this page, for the following reasons:

This IP address has been blocked from editing Wikipedia.
This does not affect your ability to read Wikipedia pages.
Most people who see this message have done nothing wrong. Some kinds of blocks restrict editing from specific service providers or telecom companies in response to recent abuse or vandalism, and can sometimes affect other users who are unrelated to that abuse. Review the information below for assistance if you do not believe that you have done anything wrong.

The IP address or range 44.201.0.0/16 has been blocked (disabled) by ‪ST47‬ for the following reason(s):

The IP address that you are currently using has been blocked because it is believed to be a web host provider. To prevent abuse, web hosts may be blocked from editing Wikipedia.
You will not be able to edit Wikipedia using a web host provider because it hides your IP address, much like a proxy or VPN.
We recommend that you attempt to use another connection to edit. For example, if you use a proxy or VPN to connect to the internet, turn it off when editing Wikipedia. If you edit using a mobile connection, try using a Wi-Fi connection, and vice versa. If you are using a corporate internet connection, switch to a different Wi-Fi network. If you have a Wikipedia account, please log in.
If you do not have any other way to edit Wikipedia, you will need to request an IP block exemption.

How to appeal if you are confident that your connection does not use a web host's IP address:
If you are confident that you are not using a web host, you may appeal this block by adding the following text on your talk page: ((unblock|reason=Caught by a web host block but this host or IP is not a web host. My IP address is _______. Place any further information here. ~~~~)). You must fill in the blank with your IP address for this block to be investigated. Your IP address can be determined here. Alternatively, if you wish to keep your IP address private you can use the unblock ticket request system. There are several reasons you might be editing using the IP address of a web host (such as if you are using VPN software or a business network); please use this method of appeal only if you think your IP address is in fact not a web host.

Administrators: The IP block exemption user right should only be applied to allow users to edit using web host in exceptional circumstances, and they should usually be directed to the functionaries team via email. If you intend to give the IPBE user right, a CheckUser needs to take a look at the account. This can be requested most easily at SPI Quick Checkuser Requests. Unblocking an IP or IP range with this template is highly discouraged without at least contacting the blocking administrator.

This block will expire on 23:54, 31 July 2024.

Even when blocked, you will usually still be able to edit your user talk page, as well as email administrators and other editors.

For information on how to proceed, please read the FAQ for blocked users and the guideline on block appeals. The guide to appealing blocks may also be helpful.

Other useful links: Blocking policy · Help:I have been blocked
Your IP address is in a range that has been blocked on all Wikimedia Foundation wikis. The block was made by ‪AntiCompositeNumber‬. The reason given is Open proxy/Webhost: Visit the FAQ if you are affected .
- Start of block: 13:55, 18 August 2022
- Expiry of block: 13:55, 18 April 2025
Your current IP address is 44.201.28.123. The blocked range is 44.201.0.0/16. Please include all above details in any queries you make. If you believe you were blocked by mistake, you can find additional information and instructions in the No open proxies global policy. Otherwise, to discuss the block please post a request for review on Meta-Wiki. You could also send an email to the stewards VRT queue at stewards@wikimedia.org including all above details.

You can view and copy the source of this page:

((refimprove|date=June 2016))
((lowercase|title=find))
((Infobox software
| name                   = find
| logo                   = 
| screenshot             = 
| screenshot size        = 
| caption                = 
| author                 = Dick Haight
| developer              = [[AT&T Bell Laboratories]]
| released               = 
| latest release version = 
| latest release date    = 
| operating system       = [[Unix]], [[Unix-like]], [[Plan 9 from Bell Labs|Plan 9]], [[IBM i]]
| platform               = [[Cross-platform]]
| genre                  = [[Command (computing)|Command]]
| website                = 
))
In [[Unix-like]] and some other [[operating system]]s, <code>'''find'''</code> is a [[command-line utility]] that locates [[Computer file|files]] based on some [[User (computing)|user]]-specified criteria and either prints the pathname of each matched object or, if another action is requested, performs that action on each matched object. 

It initiates a search from a desired starting location and then recursively traverses the [[Node (computer science)|nodes]] (directories) of a hierarchical structure (typically a [[Tree (data structure)|tree]]). '''find''' can traverse and search through different file systems of partitions belonging to one or more storage devices mounted under the starting directory.<ref>((Cite web|url=http://man7.org/linux/man-pages/man1/find.1.html|title=find(1) - Linux manual page|website=man7.org|access-date=2019-11-19))</ref>

The possible search criteria include a [[pattern matching|pattern]] to match against the [[filename]] or a time range to match against the modification time or access time of the file. By default, <code>find</code> returns a list of all files below the current [[working directory]], although users can limit the search to any desired maximum number of levels under the starting directory.

The related <code>[[locate (Unix)|locate]]</code> programs use a database of indexed files obtained through <code>find</code> (updated at regular intervals, typically by <code>[[cron]]</code> job) to provide a faster method of searching the entire file system for files by name.

==History==
<code>find</code> appeared in [[Version 5 Unix]] as part of the [[PWB/UNIX|Programmer's Workbench]] project, and was written by Dick Haight alongside [[cpio]],<ref name="reader">((cite tech report |first1=M. D. |last1=McIlroy |author-link1=Doug McIlroy |year=1987 |url=http://www.cs.dartmouth.edu/~doug/reader.pdf |title=A Research Unix reader: annotated excerpts from the Programmer's Manual, 1971–1986 |series=CSTR |number=139 |institution=Bell Labs))</ref> which were designed to be used together.<ref>((Cite web|title = libarchive/libarchive|url = https://github.com/libarchive/libarchive/wiki/FormatCpio|website = GitHub|access-date = 2015-10-04))</ref>

The [[GNU Find Utilities|GNU]] <code>find</code> implementation was originally written by Eric Decker. It was later enhanced by David MacKenzie, Jay Plett, and Tim Wood.<ref>[https://www.gnu.org/software/findutils/manual/html_mono/find.html#Introduction Finding Files]</ref>

The ((Mono|find)) command has also been ported to the [[IBM i]] operating system.<ref>((cite web |title=IBM System i Version 7.2 Programming Qshell |language=en |website=[[IBM]] |url=https://www.ibm.com/support/knowledgecenter/ssw_ibm_i_74/rzahz/rzahzpdf.pdf?view=kc |access-date=2020-09-05 ))</ref>

==Find syntax==
<syntaxhighlight lang="console">
$ find [-H|-L] path... [operand_expression...]
</syntaxhighlight>
The two options control how the <code>find</code> command should treat symbolic links. The default behaviour is never to follow symbolic links. The ((code|-L)) flag will cause the <code>find</code> command to follow symbolic links. The ((code|-H)) flag will only follow symbolic links while processing the command line arguments. These flags are specified in the POSIX standard for <code>find</code>.<ref name=sus>((man|cu|find|SUS|find files))</ref> A common extension is the ((code|-P)) flag, for explicitly disabling symlink following.<ref name=fbsd>((man|1|find|FreeBSD))</ref><ref>((man|1|find|Linux))</ref>

At least one path must precede the expression. <code>find</code> is capable of interpreting [[Wildcard character|wildcards]] internally and commands must be quoted carefully in order to control [[Glob (programming)|shell globbing]].

Expression elements are separated by the [[command-line argument]] boundary, usually represented as whitespace in shell syntax. They are evaluated from left to right. They can contain logical elements such as AND (((code|-and)) or ((code|-a))) and OR (((code|-or)) or ((code|-o))) as well as predicates (filters and actions).

GNU <code>find</code> has a large number of additional features not specified by POSIX.

===Predicates===
((anchor|type filters))

Commonly-used primaries include:

* <code>-name ''pattern''</code>: tests whether the file name matches the shell-glob pattern given.
* <code>-type ''type''</code>: tests whether the file is a given type. [[Unix file types]] accepted include:
** <code>b</code>: [[Device file|block device (buffered)]];
** <code>c</code>: [[Device file|character device (unbuffered)]];
** <code>d</code>: ''[[Directory (computing)|directory]]'';
** <code>f</code>: ''[[regular file]]'';
** <code>l</code>: [[symbolic link]];
** <code>p</code>: [[named pipe]];
** <code>s</code>: [[Unix domain socket|socket]];
** <code>D</code>: [[Doors (computing)|door]].
* <code>-print</code>: always returns true; prints the name of the current file plus a newline to the [[stdout]].
* <code>-print0</code>: always returns true; prints the name of the current file plus a null character to the [[stdout]]. Not required by POSIX.
* <code>-exec ''program'' ''[arguments...]'' ;</code>: runs ''program'' with the given arguments, and returns true if its exit status was 0, false otherwise. If ''program'', or an argument is '''{}''', it will be replace by the current path (if ''program'' is '''{}''', <code>find</code> will try to run the current path as an executable). POSIX doesn't specify what should happen if multiple '''{}''' are specified. Most implementations will replace all '''{}''' with the current path, but that is not standard behavior.
* <code>-exec ''program'' ''[arguments...]'' {} +</code>: always returns true; run ''program'' with the given arguments, followed by as many paths as possible (multiple commands will be run if the maximum command-line size is exceeded, like for [[xargs]]).<ref name=sus/>
* <code>-ok ''program'' ''[arguments...]'' ;</code>: for every path, prompts the user for confirmation; if the user confirms (typically by entering ''y'' or ''yes''), it behaves like <code>-exec ''program [arguments...]'' ;</code>, otherwise the command is not run for the current path, and false is returned.

If the expression uses none of <code>-print0</code>, <code>-print</code>, <code>-exec</code>, or <code>-ok</code>, find defaults to performing <code>-print</code> if the conditions test as true.

===Operators===
Operators can be used to enhance the expressions of the find command. Operators are listed in order of decreasing precedence:
* <code>( expr )</code>: forces precedence;
* <code>! expr</code>: true if expr is false;
* <code>expr1 expr2</code> (or <code>expr1 -a expr2</code>: AND. ((code|expr2)) is not evaluated if ((code|expr1)) is false;
* <code>expr1 -o expr2</code>: OR. expr2 is not evaluated if ((code|expr1)) is true.

<syntaxhighlight lang="console">
$ find . -name 'fileA_*' -o -name 'fileB_*'
</syntaxhighlight>
This command searches the current working directory tree for files whose names start with ((code|fileA_)) or ((code|fileB_)). We quote the ((code|fileA_*)) so that the shell does not expand it.

<syntaxhighlight lang="console">
$ find . -name 'foo.cpp' '!' -path '.svn'
</syntaxhighlight>
This command searches the current working directory tree except the subdirectory tree ".svn" for files whose name is "foo.cpp". We quote the <code>!</code> so that it's not interpreted by the shell as the history substitution character.

==POSIX protection from infinite output==
Real-world file systems often contain looped structures created through the use of [[hard link|hard]] or [[symbolic link|soft links]]. The [[POSIX|POSIX standard]] requires that
((Quotation|
The <code>find</code> utility shall detect infinite loops; that is, entering a previously visited
directory that is an ancestor of the last file encountered. When it detects an infinite
loop, <code>find</code> shall write a diagnostic message to standard error and shall either recover
its position in the hierarchy or terminate.
))

==Examples==

===From the current working directory===
<syntaxhighlight lang="console">
$ find . -name 'my*'
</syntaxhighlight>
This searches the current working directory tree for files whose names start with ''my''. The single quotes avoid the [[shell (computing)|shell]] expansion—without them the shell would replace ''my*'' with the list of files whose names begin with ''my'' in the current working directory. In newer versions of the program, the directory may be omitted, and it will imply the current working directory.

===Regular files only===
<syntaxhighlight lang="console">
$ find . -name 'my*' -type f
</syntaxhighlight>
This limits the results of the above search to only regular files, therefore excluding directories, special files, symbolic links, etc. ''my*'' is enclosed in single quotes (apostrophes) as otherwise the shell would replace it with the list of files in the current working directory starting with ''my''…

===Commands===
The previous examples created listings of results because, by default, <code>find</code> executes the <code>-print</code> action. (Note that early versions of the <code>find</code> command had no default action at all; therefore the resulting list of files would be discarded, to the bewilderment of users.)

<syntaxhighlight lang="console">
$ find . -name 'my*' -type f -ls
</syntaxhighlight>
This prints extended file information.

===Search all directories===
<syntaxhighlight lang="console">
$ find / -name myfile -type f -print
</syntaxhighlight>
This searches every directory for a regular file whose name is ''myfile'' and prints it to the screen. It is generally not a good idea to look for files this way. This can take a considerable amount of time, so it is best to specify the directory more precisely. Some operating systems may mount dynamic file systems that are not congenial to <code>find</code>. More complex filenames including characters special to the shell may need to be enclosed in single quotes.

===Search all but one subdirectory tree===
<syntaxhighlight lang="console">
$ find / -path excluded_path -prune -o -type f -name myfile -print
</syntaxhighlight>
This searches every directory except the subdirectory tree ''excluded_path'' (full path including the leading /) that is pruned by the <code>-prune</code> action, for a regular file whose name is ''myfile''.

===Specify a directory===
<syntaxhighlight lang="console">
$ find /home/weedly -name myfile -type f -print
</syntaxhighlight>
This searches the ''/home/weedly'' directory tree for regular files named ''myfile''. You should always specify the directory to the deepest level you can remember.

===Search several directories===
<syntaxhighlight lang="console">
$ find local /tmp -name mydir -type d -print
</syntaxhighlight>
This searches the ''local'' subdirectory tree of the current working directory and the ''/tmp'' directory tree for directories named ''mydir''.

===Ignore errors===
If you're doing this as a user other than root, you might want to ignore permission denied (and any other) errors. Since errors are printed to [[stderr]], they can be suppressed by redirecting the output to /dev/null. The following example shows how to do this in the bash shell:
<syntaxhighlight lang="console">
$ find / -name myfile -type f -print 2> /dev/null
</syntaxhighlight>

If you are a [[C shell|csh]] or [[tcsh]] user, you cannot redirect [[stderr]] without redirecting [[stdout]] as well. You can use sh to run the <code>find</code> command to get around this:
<syntaxhighlight lang="console">
$ sh -c "find / -name myfile -type f -print 2> /dev/null"
</syntaxhighlight>
An alternate method when using [[C shell|csh]] or [[tcsh]] is to pipe the output from [[stdout]] and [[stderr]] into a [[grep]] command. This example shows how to suppress lines that contain permission denied errors.
<syntaxhighlight lang="console">
$ find . -name myfile |& grep -v 'Permission denied'
</syntaxhighlight>

===Find any one of differently named files===
<syntaxhighlight lang="console">
$ find . \( -name '*jsp' -o -name '*java' \) -type f -ls
</syntaxhighlight>
The <code>-ls</code> operator prints extended information, and the example finds any regular file whose name ends with either 'jsp' or 'java'. Note that the parentheses are required. In many shells the parentheses must be escaped with a backslash (<code>\(</code> and <code>\)</code>) to prevent them from being interpreted as special shell characters. The <code>-ls</code> operator is not available on all versions of <code>find</code>.

===Execute an action===
<syntaxhighlight lang="console">
$ find /var/ftp/mp3 -name '*.mp3' -type f -exec chmod 644 {} \;
</syntaxhighlight>
This command changes the [[File system permissions|permissions]] of all regular files whose names end with ''.mp3'' in the directory tree ''/var/ftp/mp3''. The action is carried out by specifying the statement <code>-exec [[chmod]] 644 {} \;</code> in the command. For every regular file whose name ends in <code>.mp3</code>, the command <code>chmod 644 {}</code> is executed replacing <code>{}</code> with the name of the file. The semicolon (backslashed to avoid the shell interpreting it as a command separator) indicates the end of the command. Permission <code>644</code>, usually shown as <code>rw-r--r--</code>, gives the file owner full permission to read and write the file, while other users have read-only access. In some shells, the <code>{}</code> must be quoted. The trailing "((code|;))" is customarily quoted with a leading "((code|\))", but could just as effectively be enclosed in single quotes.

Note that the command itself should '''not''' be quoted; otherwise you get error messages like
<syntaxhighlight lang="output">
find: echo "mv ./3bfn rel071204": No such file or directory
</syntaxhighlight>
which means that <code>find</code> is trying to run a file called '((code|2=sh|echo "mv ./3bfn rel071204"))' and failing.

If you will be executing over many results, it is more efficient to use a variant of the exec primary that collects filenames up to ((mono|ARG_MAX)) and then executes COMMAND with a list of filenames.

<syntaxhighlight lang="console">
$ find . -exec COMMAND {} +
</syntaxhighlight>
This will ensure that filenames with whitespaces are passed to the executed ((code|COMMAND)) without being split up by the shell.

===Delete files and directories===
The <code>-delete</code> action is a GNU extension, and using it turns on <code>-depth</code>. So, if you are testing a find command with <code>-print</code> instead of <code>-delete</code> in order to figure out what will happen before going for it, you need to use <code>-depth -print</code>.

Delete empty files and print the names (note that <code>-empty</code> is a vendor unique extension from GNU <code>find</code> that may not be available in all <code>find</code> implementations):
<syntaxhighlight lang="console">
$ find . -empty -delete -print
</syntaxhighlight>

Delete empty regular files:
<syntaxhighlight lang="console">
$ find . -type f -empty -delete
</syntaxhighlight>

Delete empty directories:
<syntaxhighlight lang="console">
$ find . -type d -empty -delete
</syntaxhighlight>

Delete empty files named 'bad':
<syntaxhighlight lang="console">
$ find . -name bad -empty -delete
</syntaxhighlight>

Warning. — The <code>-delete</code> action should be used with conditions such as <code>-empty</code> or <code>-name</code>:
<syntaxhighlight lang="console">
$ find . -delete # this deletes all in .
</syntaxhighlight>

===Search for a string===
This command will search all files from the /tmp directory tree for a string:
<syntaxhighlight lang="console">
$ find /tmp -type f -exec grep 'search string' /dev/null '{}' \+
</syntaxhighlight>
The <code>[[/dev/null]]</code> argument is used to show the name of the file before the text that is found. Without it, only the text found is printed.  (Alternatively, some versions of grep support a ((mono|-H)) flag that forces the file name to be printed.)
GNU <code>grep</code> can be used on its own to perform this task:
<syntaxhighlight lang="console">
$ grep -r 'search string' /tmp
</syntaxhighlight>

Example of search for "LOG" in jsmith's home directory tree:
<syntaxhighlight lang="console">
$ find ~jsmith -exec grep LOG '{}' /dev/null \; -print
/home/jsmith/scripts/errpt.sh:cp $LOG $FIXEDLOGNAME
/home/jsmith/scripts/errpt.sh:cat $LOG
/home/jsmith/scripts/title:USER=$LOGNAME
</syntaxhighlight>

Example of search for the string "ERROR" in all XML files in the current working directory tree:
<syntaxhighlight lang="console">
$ find . -name "*.xml" -exec grep "ERROR" /dev/null '{}' \+ 
</syntaxhighlight>
The double quotes (" ") surrounding the search string and single quotes (<nowiki>' '</nowiki>) surrounding the braces are optional in this example, but needed to allow spaces and some other special characters in the string. Note with more complex text (notably in most popular shells descended from `sh` and `csh`) single quotes are often the easier choice, since ''double quotes do not prevent all special interpretation''. Quoting filenames which have English contractions demonstrates how this can get rather complicated, since a string with an apostrophe in it is easier to protect with double quotes:
<syntaxhighlight lang="console">
$ find . -name "file-containing-can't" -exec grep "can't" '{}' \; -print
</syntaxhighlight>

===Search for all files owned by a user===
<syntaxhighlight lang="console">
$ find . -user <userid>
</syntaxhighlight>

===Search in case insensitive mode===
Note that <code>-iname</code> is not in the standard and may not be supported by all implementations.
<syntaxhighlight lang="console">
$ find . -iname 'MyFile*'
</syntaxhighlight>

If the <code>-iname</code> switch is not supported on your system then workaround techniques may be possible such as:
<syntaxhighlight lang="console">
$ find . -name '[mM][yY][fF][iI][lL][eE]*'
</syntaxhighlight>

===Search files by size===
Searching files whose size is between 100 kilobytes and 500 kilobytes:
<syntaxhighlight lang="console">
$ find . -size +100k -a -size -500k
</syntaxhighlight>

Searching empty files:
<syntaxhighlight lang="console">
$ find . -size 0k
</syntaxhighlight>

Searching non-empty files:
<syntaxhighlight lang="console">
$ find . ! -size 0k
</syntaxhighlight>

===Search files by name and size ===
<syntaxhighlight lang="console">
$ find /usr/src ! \( -name '*,v' -o -name '.*,v' \) '{}' \; -print
</syntaxhighlight>
This command will search the /usr/src directory tree. All files that are of the form ((mono|'*,v')) and ((mono|'.*,v')) are excluded. Important arguments to note are in the [[tooltip]] that is displayed on mouse-over.

<syntaxhighlight lang="bash">
for file in $(find /opt \( -name error_log -o -name 'access_log' -o -name 'ssl_engine_log' -o -name 'rewrite_log' -o -name 'catalina.out' \) -size +300000k -a -size -5000000k); do 
    cat /dev/null > $file
done
</syntaxhighlight>
The units should be one of ((mono|[bckw])), 'b' means 512-byte blocks, 'c' means byte, 'k' means kilobytes and 'w' means 2-byte words. The size does not count indirect blocks, but it does count blocks in sparse files that are not actually allocated.

=== Searching files by time ===
Date ranges can be used to, for example, list files changed since a backup.

* ((code|-mtime)) : modification time
* ((code|-ctime)) : inode change time
* ((code|-atime)) : access time

Files modified a relative number of days ago:
* +[number] = At least this many days ago.
* -[number] = Less than so many days ago.
*  [number] = Exactly this many days ago.
* Optionally add <code>-daystart</code> to measure time from the beginning of a day (0 o'clock) rather than the last 24 hours.

Example to find all text files in the document folder modified since a week (meaning 7 days): 
<syntaxhighlight lang="console">
$ find ~/Documents/ -iname "*.txt" -mtime -7
</syntaxhighlight>

Files modified before or after an absolute date and time:
* <code>     -newermt YYYY-MM-DD</code>: Last modified after date
* <code>-not -newermt YYYY-MM-DD</code>: Last modified before date

Example to find all text files last edited in February 2017:
<syntaxhighlight lang="console">
$ find ~/Documents/ -iname "*.txt"  -newermt 2017-02-01 -not -newermt 2017-03-01
</syntaxhighlight>

*<code>-newer [file]</code>: More recently modified than specified file.
** <code>-cnewer</code>: Same with inode change time.
** <code>-anewer</code>: Same with access time.
** Also prependable with <code>-not</code> for inverse results or range.

List all text files edited more recently than "document.txt":
<syntaxhighlight lang="console">
$ find ~/Documents/ -iname "*.txt"  -newer document.txt
</syntaxhighlight>

==Related utilities==
* <code>[[locate (Unix)|locate]]</code> is a Unix search tool that searches a prebuilt database of files instead of directory trees of a file system. This is faster than <code>find</code> but less accurate because the database may not be up-to-date.
* <code>[[grep]]</code> is a command-line utility for searching plain-text data sets for lines matching a regular expression and by default reporting matching lines on [[standard output]].
* <code>[[tree (command)|tree]]</code> is a command-line utility that recursively lists files found in a directory tree, indenting the filenames according to their position in the file hierarchy.
* [[GNU Find Utilities]] (also known as findutils) is a [[GNU package]] which contains implementations of the tools <code>find</code> and <code>[[xargs]]</code>.
* [[BusyBox]] is a utility that provides several stripped-down Unix tools in a single executable file, intended for embedded operating systems with very limited resources. It also provides a version of <code>find</code>.
* <code>[[dir (command)|dir]]</code> has the /s option that recursively searches for files or directories.
* [[Plan 9 from Bell Labs]] uses two utilities to replace ((code|find)): a ((code|walk)) that only walks the tree and prints the names and a ((code|sor)) that only filters (like grep) by evaluating expressions in the form of a shell script. Arbitrary filters can be used via pipes. The commands are not part of [[Plan 9 from User Space]], so Google's Benjamin Barenblat has a ported version to POSIX systems available through GitHub.<ref>((cite web |title=google / walk: Plan 9 style utilities to replace find(1) |url=https://github.com/google/walk |website=GitHub |access-date=30 March 2020))</ref>
* ((code|fd)) is a simple alternative to ((code|find)) written in the [[Rust programming language]].<ref>((cite web |last1=Peter |first1=David |title=sharkdp/fd: A simple, fast and user-friendly alternative to 'find' |url=https://github.com/sharkdp/fd |website=GitHub |date=30 March 2020))</ref>

==See also==
* [[mdfind]], a similar utility that utilizes metadata for [[macOS]] and [[Darwin (operating system)|Darwin]]
* [[List of Unix commands]]
* [[List of DOS commands]]
* [[Filter (higher-order function)]]
* [[find (Windows)]], a DOS and Windows command that is very different from Unix <code>find</code>
* [[forfiles]], a Windows command that finds files by attribute, similar to Unix <code>find</code>
* [[grep]], a Unix command that finds text matching a pattern, similar to Windows <code>find</code>

==References==
((Reflist))

==External links==
((Wikibooks|Guide to Unix|Commands))
* [https://www.gnu.org/software/findutils/manual/html_mono/find.html Official webpage for GNU find]
* [http://www.librebyte.net/en/gnulinux/command-find-25-practical-examples/ Command find – 25 practical examples]

((Unix commands))

[[Category:Information retrieval systems]]
[[Category:Standard Unix programs]]
[[Category:Unix SUS2008 utilities]]
[[Category:Plan 9 commands]]
[[Category:IBM i Qshell commands]]

Pages transcluded onto the current version of this page (help):

Find (Unix) (edit)
Template:Ambox (view source) (template editor protected)
Template:Anchor (view source) (template editor protected)
Template:Blockquote (view source) (template editor protected)
Template:Blockquote/styles.css (view source) (template editor protected)
Template:Cite tech report (view source) (semi-protected)
Template:Cite web (view source) (protected)
Template:Code (view source) (template editor protected)
Template:Find sources mainspace (view source) (template editor protected)
Template:Hlist/styles.css (view source) (protected)
Template:Icon (view source) (template editor protected)
Template:Ifsubst (view source) (template editor protected)
Template:Infobox (view source) (template editor protected)
Template:Infobox software (view source) (template editor protected)
Template:Infobox software/simple (view source) (template editor protected)
Template:Lowercase (view source) (template editor protected)
Template:Lowercase title (view source) (template editor protected)
Template:Main other (view source) (protected)
Template:Man (view source) (semi-protected)
Template:Man/FreeBSD (edit)
Template:Man/Linux (edit)
Template:Man/SUS (edit)
Template:Man/format (view source) (semi-protected)
Template:Mono (view source) (template editor protected)
Template:Mono/styles.css (view source) (template editor protected)
Template:More citations needed (view source) (template editor protected)
Template:Navbox (view source) (template editor protected)
Template:Plainlist/styles.css (view source) (protected)
Template:Quotation (view source) (template editor protected)
Template:Refimprove (view source) (template editor protected)
Template:Reflist (view source) (protected)
Template:Reflist/styles.css (view source) (protected)
Template:Side box (view source) (template editor protected)
Template:Sister project (view source) (template editor protected)
Template:Template other (view source) (protected)
Template:Trim (view source) (protected)
Template:Unix commands (edit)
Template:Wikibooks (view source) (template editor protected)
Template:Wikidata (view source) (template editor protected)
Module:Anchor (view source) (template editor protected)
Module:Arguments (view source) (protected)
Module:Category handler (view source) (protected)
Module:Category handler/blacklist (view source) (protected)
Module:Category handler/config (view source) (protected)
Module:Category handler/data (view source) (protected)
Module:Category handler/shared (view source) (protected)
Module:Check for unknown parameters (view source) (protected)
Module:Citation/CS1 (view source) (protected)
Module:Citation/CS1/COinS (view source) (protected)
Module:Citation/CS1/Configuration (view source) (protected)
Module:Citation/CS1/Date validation (view source) (protected)
Module:Citation/CS1/Identifiers (view source) (protected)
Module:Citation/CS1/Utilities (view source) (protected)
Module:Citation/CS1/Whitelist (view source) (protected)
Module:Citation/CS1/styles.css (view source) (protected)
Module:Find sources (view source) (template editor protected)
Module:Find sources/config (view source) (template editor protected)
Module:Find sources/links (view source) (template editor protected)
Module:Find sources/templates/Find sources mainspace (view source) (template editor protected)
Module:Icon (view source) (template editor protected)
Module:Icon/data (view source) (template editor protected)
Module:Infobox (view source) (template editor protected)
Module:Infobox/styles.css (view source) (template editor protected)
Module:InfoboxImage (view source) (template editor protected)
Module:Message box (view source) (protected)
Module:Message box/ambox.css (view source) (protected)
Module:Message box/configuration (view source) (protected)
Module:Namespace detect/config (view source) (protected)
Module:Namespace detect/data (view source) (protected)
Module:Navbar (view source) (protected)
Module:Navbar/configuration (view source) (protected)
Module:Navbar/styles.css (view source) (protected)
Module:Navbox (view source) (template editor protected)
Module:Navbox/configuration (view source) (template editor protected)
Module:Navbox/styles.css (view source) (template editor protected)
Module:Side box (view source) (template editor protected)
Module:Side box/styles.css (view source) (template editor protected)
Module:TableTools (view source) (protected)
Module:Unsubst (view source) (protected)
Module:Wd (view source) (template editor protected)
Module:Wd/i18n (view source) (template editor protected)
Module:Yesno (view source) (protected)

Return to Find (Unix).

Retrieved from "https://en.wikipedia.org/wiki/Find_(Unix)"