{"id":181,"date":"2014-04-13T02:21:50","date_gmt":"2014-04-13T02:21:50","guid":{"rendered":"https:\/\/stevepedwards.today\/DebianAdmin\/?p=181"},"modified":"2025-07-03T17:27:10","modified_gmt":"2025-07-03T16:27:10","slug":"cool-command-2-find-with-exec-or-delete-or-pipe-to-xargs-rm-v","status":"publish","type":"post","link":"https:\/\/stevepedwards.today\/DebianAdmin\/cool-command-2-find-with-exec-or-delete-or-pipe-to-xargs-rm-v\/","title":{"rendered":"Cool Command #2, Find with -exec or -delete or pipe to xargs rm -v"},"content":{"rendered":"
<\/div>\n

<\/path><\/svg><\/i> \"Loading\"<\/p>\n

<\/div>\n

man find<\/span><\/p>\n

FIND(1)<\/span><\/p>\n

NAME
\n<\/span><\/p>\n

find - search for files in a directory hierarchy<\/span><\/p>\n

SYNOPSIS
\n<\/span><\/p>\n

find [-H] [-L] [-P] [-D debugopts] [-Olevel] [path...] [expression]<\/span><\/p>\n

DESCRIPTION
\n<\/span><\/p>\n

This manual page documents the GNU version of find. GNU find searches the directory tree rooted at each given file name by evaluating the given expression from left to right, according to the rules of precedence (see section OPERATORS), until the outcome is known (the left hand side is false for and operations, true for or), at which point find moves on to the next file name.
\n<\/span><\/p>\n

If you are using find in an environment where security is important (for example if you are using it to search directories that are writable by other users), you should read the \"Security Considerations\" chapter of the findutils documentation, which is called Finding Files and comes with findutils. That document also includes a lot more detail and discussion than this manual page, so you may find it a more useful source of information.<\/span><\/p>\n

In most Linux commands, the form is usually in the order of:
\n<\/span><\/p>\n

CMD [OPTION]... [DIR\/FILE]...
\n<\/span><\/p>\n

The find<\/span> cmd is unusual in that it has its options switches placed AFTER the DIR\/FILE to be searched e.g.
\n<\/span><\/p>\n

find \/home\/ -name libflashplayer.so
\n<\/span><\/p>\n

This will recursively search for a file named libflashplayer.so in the home directory, and finds it in my Downloads folder:
\n<\/span><\/p>\n

root@LinuxLaptop:~# find \/home\/ -name libflashplayer.so<\/span><\/p>\n

\/home\/stevee\/Downloads\/libflashplayer.so<\/span><\/p>\n

So its default behaviour is to file search recursively with no switch required.
\n<\/span><\/p>\n

A very useful addition can be made to this command by adding the -exec command switch, a program in its own right, who's description is a bit cryptic:
\n<\/span><\/p>\n

man exec
\n<\/span><\/p>\n

NAME
\n<\/span><\/p>\n

execl, execlp, execle, execv, execvp, execvpe - execute a file<\/span><\/p>\n

SYNOPSIS
\n<\/span><\/p>\n

#include <unistd.h><\/span><\/p>\n

extern char **environ;<\/span><\/p>\n

int execl(const char *path, const char *arg, ...);
\n<\/span><\/p>\n

int execlp(const char *file, const char *arg, ...);
\n<\/span><\/p>\n

int execle(const char *path, const char *arg,
\n<\/span><\/p>\n

..., char * const envp[]);
\n<\/span><\/p>\n

int execv(const char *path, char *const argv[]);
\n<\/span><\/p>\n

int execvp(const char *file, char *const argv[]);
\n<\/span><\/p>\n

int execvpe(const char *file, char *const argv[],
\n<\/span><\/p>\n

char *const envp[]);<\/span><\/p>\n

Feature Test Macro Requirements for glibc (see feature_test_macros(7)):<\/span><\/p>\n

execvpe(): _GNU_SOURCE<\/span><\/p>\n

DESCRIPTION
\n<\/span><\/p>\n

The exec () family of functions replaces the current process image with
\n<\/span><\/p>\n

a new process image. The functions described in this manual page are
\n<\/span><\/p>\n

front-ends for execve(2). (See the manual page for execve(2) for fur\u00c3:
\n<\/span><\/p>\n

ther details about the replacement of the current process image.)<\/span><\/p>\n

The initial argument for these functions is the name of a file that is\u00a0<\/strong><\/span>to be executed.<\/strong><\/span><\/p>\n

The key thing to take from that is the execution of a \"file\" that follows it. In Linux, everything that is not a directory is a \"file\" even hardware, which gets virtualised as an alias. So, exec can start another program file. <\/span><\/p>\n

\"-exec command ;<\/em><\/span>
\n Execute command; true if 0 status is returned. All following<\/em><\/span>
\n arguments to find are taken to be arguments to the command until<\/em><\/span>
\n an argument consisting of `;' is encountered. The string `{}'<\/em><\/span>
\n is replaced by the current file name being processed everywhere<\/em><\/span>
\n it occurs in the arguments to the command, not just in arguments<\/em><\/span>
\n where it is alone, as in some versions of find. Both of these<\/em><\/span>
\n constructions might need to be escaped (with a `\\') or quoted to<\/em><\/span>
\n protect them from expansion by the shell. See the EXAMPLES sec<\/em><\/span>tion for examples of the use of the -exec option. The specified<\/em><\/span>
\n command is run once for each matched file. The command is exe<\/em><\/span>cuted in the starting directory. There are unavoidable secu<\/em><\/span>rity problems surrounding use of the -exec action; you should<\/em><\/span>
\n use the -execdir option instead.<\/em><\/span><\/p>\n

-exec command {} +<\/em><\/span>
\n This variant of the -exec action runs the specified command on<\/em><\/span>
\n the selected files, but the command line is built by appending<\/em><\/span>
\n each selected file name at the end; the total number of invoca\u00c3:<\/em><\/span>
\n tions of the command will be much less than the number of<\/em><\/span>
\n matched files. The command line is built in much the same way<\/em><\/span>
\n that xargs builds its command lines. Only one instance of `{}'<\/em><\/span>
\n is allowed within the command. The command is executed in the<\/em><\/span>
\n starting directory.\"<\/em><\/span><\/p>\n

For this example it starts the copy command (cp) which copies the file libflashplayer.so that <\/span>find<\/strong> found, and copies it elsewhere:<\/span><\/p>\n

find \/home\/ -name libflashplayer.so -exec cp -vt \/etc\/chromium\/plugins\/ {} +;<\/span>
\n<\/span><\/p>\n

The cp cmd could be replaced with any other cmd like remove (rm) etc. So this makes this a useful line for housekeeping your backups etc.
\n<\/span><\/p>\n

I used it to finally sort out my messy \/Files subdirectories on my 1TB BU drive, by creating directories of all Windows files of a specific extension type - .doc, .docx, .rtf, .txt, .pdf, .PDF, jpg, .jpeg, .mp3, .mp4, .mov, .xls, .html, and any others I wanted to move to separate folders of the same type name, so they could be checked for content, then deleted to save space as required.
\n<\/span><\/p>\n

For multiple types by find alone, the format is:<\/p>\n

find . -iname \"*.mp3\" -o -iname \"*.mp4\"<\/span> ...etc...<\/p>\n

This finds extra files that match any same letters in the name also, but gets the required extensions too:<\/p>\n

find -type f | egrep '.*\\.(jpg|png|doc|docx|rtf|txt|pdf|jpg|jpeg|mp3|mp4|mov|xls|html)'<\/span><\/p>\n

.\/Documents\/MintCourse\/Day 5 Package Installation, AV, Backups\/Day 5 Package Installation, AV, Backups.pdf<\/span>
\n.\/Cprogs\/converterprogideas<\/span>.txt<\/span>
\n.\/.pki\/nssdb\/pkcs11<\/span>.txt<\/span>
\n.\/Videos\/Rachel.mp4<\/span>.gpg<\/span><\/p>\n

To find all file types of mixed caps like .m4p and .M4P, use the -iname format instead of -name e.g.<\/p>\n

find \/1500\/MP3 -iname *m4p -exec cp -vt \/1500\/M4P\/ {} +;<\/span><\/p>\n

This took time but I plodded on, letting Linux sort it all out in the background as I did other things, by amending each line for each file type, over a day or two.
\n<\/span><\/p>\n

Once done though, I could check through everything, finding some old useful\/important but forgotten documents in the process, and deleting the no longer relevant. The original messy folder containing all the mixed up originals could then be deleted saving a load of space.
\n<\/span><\/p>\n

Once all the file types to be found and copied were decided on and folders created, the command was amended to find and copy them there using the wildcard *:
\n<\/span><\/p>\n

find \/Storebird\/Files -name *.pdf -exec cp -vt \/Storebird\/PDFs {} +;<\/span><\/p>\n

The -vt after cp is for \"verbose\" and \"to\" destination folder and the \"t\" MUST come last i.e. right before the destination folder, as \"-tv\" \/DestFolder does not work.<\/span><\/p>\n

Note, on search types like those containing UPPER and lower case letters, you can use the -iname switch to find ALL file types that end in either .pdf or PDF, or .doc and .DOC for example:<\/p>\n

find \/Storebird\/PDF\/ -iname *PDF<\/span><\/p>\n

\/Storebird\/PDF\/5.pdf<\/span>
\n\/Storebird\/PDF\/514168_NIKOLA_TESLA.PDF<\/span><\/p>\n

Experiment with other examples using this syntax from the book TLCL-13.07.pdf by\u00a0William Shotts here:<\/p>\n

TLCL-13.07.pdf<\/span><\/a><\/span><\/p>\n

such as files\/dirs with whitespace for removal of spaces e.g.:<\/p>\n

find \/Quadra\/MP3\/ -type f -name '*[[:blank:]]*' -exec rename \"s\/ \/\/g\" {} +;<\/span><\/p>\n

find \/1500\/MP3\/ITunes\/ -type d -name \"*\\ *\"<\/span><\/p>\n

\"Table 4-1: Wildcards<\/em>
\nWildcard Meaning<\/em>
\n* Matches any characters<\/em>
\n? Matches any single character<\/em>
\n[characters] Matches any character that is a member of the set characters <\/em>
\n[!characters] Matches any character that is not a member of the set <\/em>
\ncharacters<\/em>
\n[[:class:]] Matches any character that is a member of the specified class<\/em>
\nTable 4-2 lists the most commonly used character classes:<\/em>
\nTable 4-2: Commonly Used Character Classes<\/em>
\nCharacter Class Meaning<\/em>
\n[:alnum:] Matches any alphanumeric character<\/em>
\n[:alpha:] Matches any alphabetic character<\/em>
\n[:digit:] Matches any numeral<\/em>
\n[:lower:] Matches any lowercase letter<\/em>
\n[:upper:] Matches any uppercase letter<\/em>
\nUsing wildcards makes it possible to construct very sophisticated selection criteria for <\/em>
\nfilenames. Here are some examples of patterns and what they match:<\/em>
\nTable 4-3: Wildcard Examples<\/em>
\nPattern Matches<\/em>
\n* All files<\/em>
\ng* Any file beginning with g<\/em>
\nb*.txt Any file beginning with b followed by <\/em>
\nany characters and ending with .txt<\/em>
\n26Wildcards<\/em>
\nData??? <\/em><\/p>\n

Any file beginning with Data followed by exactly three characters\u00a0<\/em><\/p>\n

[abc]* Any file beginning with either an a, a b, or a c<\/em>
\nBACKUP.[0-9][0-9][0-9] Any file beginning with BACKUP. <\/em>
\nfollowed by exactly three numerals\u00a0<\/em><\/p>\n

[[:upper:]]* Any file beginning with an uppercase letter\u00a0<\/em><\/p>\n

[![:digit:]]* Any file not beginning with a numeral\u00a0<\/em><\/p>\n

*[[:lower:]123] Any file ending with a lowercase letter or the numerals 1, 2, or 3<\/em><\/p>\n

Wildcards can be used with any command that accepts filenames as arguments, but we,ll\u00a0talk more about that in Chapter 7.<\/em>
\nCharacter Ranges<\/em>
\nIf you are coming from another Unix-like environment or have been reading some other books on this subject, you may have encountered the [A-Z] or the [a-z] character range notations. These are traditional Unix notations and\u00a0worked in older versions of Linux as well. They can still work, but you have to be\u00a0very careful with them because they will not produce the expected results unless properly configured. For now, you should avoid using them and use character\u00a0classes instead.\"<\/em><\/p>\n

Here's a good house cleaner for removing those pesky Windows \"Thumbs.db\", \".tmp\"<\/strong> or \"desktop.ini\"<\/strong> files that get everywhere:<\/p>\n

find \u00a0\/Quadra\/Test\/ -name Thumbs.db \u00a0-exec rm -v \u00a0{} +;<\/span><\/p>\n

CAUTION<\/strong>: You may want to test is on a known directory first before you unleash it on a whole drive; like the root dir, or using a *.db<\/strong>\u00a0shortcut, as you might delete all your system's databases!<\/p>\n

You could also just use functions of \"find\" alone for the same job in that case:<\/p>\n

find ~ -type f -name 'Thumbs.db' -delete<\/span><\/p>\n

sudo find ~ -type f -name 'desktop.ini'\u00a0| xargs rm -v<\/span><\/p>\n

BUT!! Beware - many\u00a0linux files ALSO end in .ini so be careful what directories you use wildcards in! Check the results first without the -delete.<\/strong><\/p>\n

\/usr\/share\/themes\/Mint-X-Sand\/gtk-3.0\/settings.ini<\/span><\/p>\n

Similarly for \"locked\" temp files of type that start with \"~$\". Note the $ is a Special char so has to be escaped with the backslash, so either of:<\/p>\n

sudo find \/1500\/ -name ~*<\/span>
\n\/1500\/AET\/~$luing Diversity Notes.docx<\/span>
\n\/1500\/AET\/~$les, Responsibilities and Relationships in Education and Training.docx\u00a0<\/span><\/p>\n

OR<\/p>\n

sudo find \/1500\/ -name ~\\$*<\/span>
\n\/1500\/AET\/~$luing Diversity Notes.docx<\/span>
\n\/1500\/AET\/~$les, Responsibilities and Relationships in Education and Training.docx<\/span><\/p>\n

If you have a very large ext4 backup drive - say 1TB or more, it may pay you to defrag it before doing any housecleaning to speed up finds. Word tmp files alone could account for much space.<\/p>\n

man e4defrag<\/span><\/p>\n

My main 1500GB backup drive has this many (mainly Win) .tmp files:<\/p>\n

find . -name *.tmp | wc -l<\/span>
\n333<\/span><\/p>\n

ALSO! beware of mounted file systems on backup and\/or smb networked drives! Use the:<\/strong><\/span><\/p>\n

\u00a0-mount<\/strong> Don't descend directories on other file systems. An alternate\u00a0name for -xdev<\/strong>, for compatibility with some other versions of\u00a0find.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

<\/div>\n

<\/path><\/svg><\/i> \"Loading\"<\/p>\n

<\/div>\n

man find FIND(1) NAME find - search for files in a directory hierarchy SYNOPSIS find [-H] [-L] [-P] [-D debugopts] [-Olevel] [path...] [expression] DESCRIPTION This manual page documents the GNU version of find. GNU find searches the directory tree rooted at each given file name by evaluating the given expression from left to right, according ...\u00a0 Cool Command #2, Find with -exec or -delete or pipe to xargs rm -v<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4,2],"tags":[],"class_list":["post-181","post","type-post","status-publish","format-standard","hentry","category-post","category-uncategorized"],"a3_pvc":{"activated":true,"total_views":0,"today_views":0},"_links":{"self":[{"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/posts\/181","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/comments?post=181"}],"version-history":[{"count":6,"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/posts\/181\/revisions"}],"predecessor-version":[{"id":10562,"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/posts\/181\/revisions\/10562"}],"wp:attachment":[{"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/media?parent=181"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/categories?post=181"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/stevepedwards.today\/DebianAdmin\/wp-json\/wp\/v2\/tags?post=181"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}