mjhjmtu

I have a directory with over 400 images. Most of them are corrupt. I identified the good ones. They are listed in a text file (there're 100+ of them). How can I move them all at once to another directory on BASH?

There are several ways to do this that come to mind immediately:

1. Using a while-loop


2. Using xargs


3. Using rsync

Suppose the file names are listed (one per line) in files.txt and we want to move them from the subdirectory source/ to the subdirectory target.

The while-loop could look something like this:

while read filename; do mv source/$filename target/; done < files.txt

The xargs command could look something like this:

cat files.txt | xargs -n 1 -d'n' -I mv source/ target/

And the rsync command could look something like this:

rsync -av --remove-source-files --files-from=files.txt source/ target/

It might be worthwhile to create a sandbox to experiment with and test out each approach, e.g.:

# Create a sandbox directory
mkdir -p /tmp/sandbox

# Create file containing the list of filenames to be moved
for filename in file001..100.dat; do basename $filename; done >> /tmp/sandbox/files.txt

# Create a source directory (to move files from)
mkdir -p /tmp/sandbox/source

# Populate the source directory (with 100 empty files)
touch /tmp/sandbox/source/file001..100.dat

# Create a target directory (to move files to)
mkdir -p /tmp/sandbox/target

# Move the files from the source directory to the target directory
rsync -av --remove-source-files --files-from=/tmp/sandbox/files.txt /tmp/sandbox/source/ /tmp/sandbox/target/

Fast solution with GNU parallel:

Let's say the "good" image filenames are listed in file good_img.txt and the destination folder is named good_images.

cat good_img.txt | parallel -m -j0 --no-notice mv good_images 

• -m - insert as many arguments as the command line length permits. If multiple jobs are being run in parallel: distribute the arguments evenly among the jobs




• -j N - number of jobslots. Run up to N jobs in parallel. 0 means as many as possible. Default is 100% which will run one job per CPU core.

If there is one file name per line:

xargs -d \n echo mv -t /target/directory

While you requested a bash solution, you may have really meant a command-line-based solution. Others have provided using a variety of command-line tools. Here is a solution that uses a bash builtin (readarray / mapfile) to read the contents of the text file in order to then pass those filenames on to the mv command:

Setup

$ touch a..z.jpg "bad one.jpg" "good one.jpg"
$ mkdir good
$ cat saveus
j.jpg
good one.jpg
z.jpg

Preparation

$ readarray -t < saveus.txt
$ declare -p MAPFILE
declare -a MAPFILE='([0]="j.jpg" [1]="good one.jpg" [2]="z.jpg")'

Do it

$ mv -- "$MAPFILE[@]" good/

Confirmation

$ ls -1 good/
good one.jpg
j.jpg
z.jpg
$ ls "good one.jpg" j.jpg z.jpg
ls: cannot access good one.jpg: No such file or directory
ls: cannot access j.jpg: No such file or directory
ls: cannot access z.jpg: No such file or directory