I downloaded a lot of images in a directory.
Downloader renamed files which already exist.
I also renamed some of the files manually.

hello.jpg      <-- manually renamed `b(3).jpg`
world.jpg      <-- manually renamed `d.jpg`

How to remove duplicated ones? The result should be:


note: name doesn't matter. I just want uniq files.

11 Answers 11

up vote 20 down vote accepted

bash 4.x

declare -A arr
shopt -s globstar

for file in **; do
  [[ -f "$file" ]] || continue

  read cksm _ < <(md5sum "$file")
  if ((arr[$cksm]++)); then 
    echo "rm $file"

This is both recursive and handles any file name. Downside is that it requires version 4.x for the ability to use associative arrays and recursive searching. Remove the echo if you like the results.

gawk version

gawk '
    cmd="md5sum " q FILENAME q
    cmd | getline cksm
    sub(/ .*$/,"",cksm)
      cmd="echo rm " q FILENAME q
  }' q='"' *

Note that this will still break on files that have double-quotes in their name. No real way to get around that with awk. Remove the echo if you like the results.

  • fine, the bash version worked for me, but in my test, with 2 similar folders, it deleted half of duplicates in one folder, and half in the other. why. i would expect deletion of everyone (duplicated) of one folder. – Ferroao Dec 5 '17 at 17:58
  • @Ferroao Perhaps they were not exact duplicates. If just one bit is off the md5 hash that my script is using to determine duplicity would be completely different. You could add an echo cksm just after the line starting with read if you want to see each file’s hash. – SiegeX Dec 5 '17 at 20:38
  • no, all "duplicates" (copies) were removed, remaining 1 version, let's say the original. half copies were deleted from one folder, and the other half from the other folder (100% deletion of copies). my 100% is for copies in excess, not of the totality – Ferroao Dec 5 '17 at 22:40
  • @Ferroao I see. In that case it seems when bash does its recursive path expansion via **, it orders the list in such a way that the two folders are interleaved rather than all of folder 1 then all of folder 2. The script will always leave the first ‘original’ it hits as it iterates through the list. You can echo $file before the read line to see if this is true. – SiegeX Dec 6 '17 at 0:49

fdupes is the tool of your choice. To find all duplicate files (by content, not by name) in the current directory:

fdupes -r .

To manually confirm deletion of duplicated files:

fdupes -r -d .

To automatically delete all copies but the first of each duplicated file (be warned, this warning, this actually deletes files, as requested):

fdupes -r -f . | grep -v '^$' | xargs rm -v

I'd recommend to manually check files before deletion:

fdupes -rf . | grep -v '^$' > files
... # check files
xargs -a files rm -v
  • Works great, but fails if file names contain spaces. – Daniel Wolf Jun 23 '17 at 12:15
  • 1
    @DanielWolf try with xargs option -d '\n' – Jakob Jun 27 '17 at 12:13

You can try FSLint. It has both command line and GUI interface.

Being a bit lazy, it didn't take me long to find one online.

You first have to create a CRC checksum of each file, as you obviously only want to remove exact duplicates.

cksum  *.jpg | sort -n > filelist

Then, iterate over this file list, reading in the checksum and also the filename. If two checksums are the same, the file will be removed. This works, since the sort is numerical, and only sorts on the checksums, which groups duplicate files.

while read sum lines filename
      if [[ "$sum" != "$old" ]] ; then
      rm -f "$filename"
done < filelist

Obviously, this doesn't work recursively.

How to test files having unique content?

if diff "$file1" "$file2" > /dev/null; then

How can we get list of files in directory?

files="$( find ${files_dir} -type f )"

We can get any 2 files from that list and check if their names are different and content are same.

# removeDuplicates.sh

if [[ -z "$files_dir" ]]; then
    echo "Error: files dir is undefined"

files="$( find ${files_dir} -type f )"
for file1 in $files; do
    for file2 in $files; do
        # echo "checking $file1 and $file2"
        if [[ "$file1" != "$file2" && -e "$file1" && -e "$file2" ]]; then
            if diff "$file1" "$file2" > /dev/null; then
                echo "$file1 and $file2 are duplicates"
                rm -v "$file2"

For example, we have some dir:

$> ls .tmp -1

So there are only 3 unique files.

Lets run that script:

$> ./removeDuplicates.sh .tmp/
.tmp/text(2) and .tmp/text are duplicates
removed `.tmp/text'
.tmp/all.txt and .tmp/all(2).txt are duplicates
removed `.tmp/all(2).txt'

And we get only 3 files leaved.

$> ls .tmp/ -1

I wrote this tiny script to delete duplicated files


Basically it uses a temporary file (/tmp/list.txt) to create a map of files and their hashes. Later I use that files and the magic of Unix pipes to do the rest.

The script won't delete anything but will print the commands to delete files.

mfilter.sh ./dir | bash

Hope it helps

More concise version of removing duplicated files(just one line)

young@ubuntu-16:~/test$ md5sum `find ./ -type f` | sort -k1 | uniq -w32 -d | xargs rm -fv


#!/usr/bin/env bash
#set -x
#This is small script can find same size of files.

if [[ -z $1 || ! -d $1 ]]
echo "Usage $0 directory_name" ;
 exit $?
echo "current directory is $1"

for i in $(find $dir_name -type f); do
   ls -fl $i
done | awk '{f=""
        if(NF>9)for(i=9;i<=NF;i++)f=f?f" "$i:$i; else f=$9;
        if(a[$5]){ a[$5]=a[$5]"\n"f; b[$5]++;} else a[$5]=f} END{for(x     in b)print a[x] }' | xargs stat -c "%s  %n" #For just list files

find_same_size $1

young@ubuntu-16:~/test$ bash find_same_size.sh tttt/ | awk '{ if($1 !~   /^([[:alpha:]])+/) print $2}' | xargs md5sum | uniq -w32 -d | xargs rm -vf

I found an easier way to perform the same task

for i in `md5sum * | sort -k1 | uniq -w32 -d|awk '{print $2}'`; do
rm -rf $i

Most and possibly all of the remaining answers are terribly inefficient by computing the checksum of each and every file in the directory to process.

A potentially orders of magnitude faster approach is to first get the size of each file, which is almost immediate (ls or stat), and then compute and compare the checksums only for the files having a non unique size.

This is not what you are asking, but I think someone might find it useful when the checksums are not the same, but the name is similar (with suffix in parentheses). This script removes the files with suffixes as ("digit")

#! /bin/bash
# Warning: globstar excludes hidden directories.
# Turn on recursive globbing (in this script) or exit if the option is not supported:
shopt -s globstar || exit
for f in **
#get only files with parentheses suffix
FILEWITHPAR=$( echo "${f%.*}".$extension | grep -o -P "(.*\([0-9]\)\..*)")
# print file to be possibly deleted
if [ -z "$FILEWITHPAR" ] ;then
echo "$FILEWITHPAR ident"
# identify if a similar file without suffix exists
FILENOPAR=$(echo $FILEWITHPAR | sed -e 's/^\(.*\)([0-9])\(.*\).*/\1\2/')
echo "$FILENOPAR exists?"
if [ -f "$FILENOPAR" ]; then
#delete file with suffix in parentheses
echo ""$FILEWITHPAR" to be deleted"
echo "no"

I found a small program that really simplifies this kind of tasks: fdupes.

  • Please add installation instructions and a usage example appropriate for the question. – simlev Sep 21 at 8:05

Your Answer


By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service, privacy policy and cookie policy, and that your continued use of the website is subject to these policies.

Not the answer you're looking for? Browse other questions tagged or ask your own question.