Styjun

I am trying to save the result from find as arrays.
Here is my code:

#!/bin/bash

echo "input : "
read input

echo "searching file with this pattern '$input' under present directory"
array=`find . -name $input`

len=$#array[*]
echo "found : $len"

i=0

while [ $i -lt $len ]
do
echo $array[$i]
let i++
done

I get 2 .txt files under current directory.
So I expect '2' as result of $len. However, it prints 1.
The reason is that it takes all result of find as one elements.
How can I fix this?

P.S

I found several solutions on StackOverFlow about a similar problem. However, they are a little bit different so I can't apply in my case. I need to store the results in a variable before the loop. Thanks again.

Here is one solution for getting the output of find into a bash array:

array=()
while IFS= read -r -d $''; do
 array+=("$REPLY")
done < <(find . -name "$input" -print0)

This is tricky because, in general, file names can have spaces, new lines, and other script-hostile characters. The only way to use find and have the file names safely separated from each other is to use -print0 which prints the file names separated with a null character. This would not be much of an inconvenience if bash's readarray/mapfile functions supported null-separated strings but they don't. Bash's read does and that leads us to the loop above.

How it works

1. The first line creates an empty array: array=()




2. Every time that the read statement is executed, a null-separated file name is read from standard input. The -r option tells read to leave backslash characters alone. The -d $'' tells read that the input will be null-separated. Since we omit the name to read, the shell puts the input into the default name: REPLY.




3. The array+=("$REPLY") statement appends the new file name to the array array.




4. The final line combines redirection and command substitution to provide the output of find to the standard input of the while loop.

Why use process substitution?

If we didn't use process substitution, the loop could be written as:

array=()
find . -name "$input" -print0 >tmpfile
while IFS= read -r -d $''; do
 array+=("$REPLY")
done <tmpfile
rm -f tmpfile

In the above the output of find is stored in a temporary file and that file is used as standard input to the while loop. The idea of process substitution is to make such temporary files unnecessary. So, instead of having the while loop get its stdin from tmpfile, we can have it get its stdin from <(find . -name $input -print0).

Process substitution is widely useful. In many places where a command wants to read from a file, you can specify process substitution, <(...), instead of a file name. There is an analogous form, >(...), that can be used in place of a file name where the command wants to write to the file.

Like arrays, process substitution is a feature of bash and other advanced shells. It is not part of the POSIX standard.

Additional notes

The following command creates a shell variable, not a shell array:

array=`find . -name "$input"`

If you wanted to create an array, you would need to put parens around the output of find. So, naively, one could:

array=(`find . -name "$input"`) # don't do this

The problem is that the shell performs word splitting on the results of find so that the elements of the array are not guaranteed to be what you want.

If you are using bash 4 or later, you can replace your use of find with

shopt -s globstar nullglob
array=( **/*"$input"* )

The ** pattern enabled by globstar matches 0 or more directories, allowing the pattern to match to an arbitrary depth in the current directory. Without the nullglob option, the pattern (after parameter expansion) is treated literally, so with no matches you would have an array with a single string rather than an empty array.

Add the dotglob option to the first line as well if you want to traverse hidden directories (like .ssh) and match hidden files (like .bashrc) as well.

Bash 4.4 introduced a -d option to readarray/mapfile, so this can now be solved with

readarray -d '' array < <(find . -name "$input" -print0)

for a method that works with arbitrary filenames including blanks, newlines, and globbing characters.

From the manual (omitting other options):

mapfile [-d delim] [array]

-d

The first character of delim is used to terminate each input line, rather than newline. If delim is the empty string, mapfile will terminate a line when it reads a NUL character.

And readarray is just a synonym of mapfile.

you can try something like

array=(`find . -type f | sort -r | head -2`)