Strange variable scope behavior when calling function recursivly

Question

EDIT: sorry. this is my first question here.

Here is a minimal working example

#!/bin/bash
#
count=0

function something() {
    if test -f "$1"; then
        # is a file
        ((count++))
        echo $count $1
    elif test -d "$1"; then
        # is a folder
        find $1 | while read line; do
            if [ $1 != $line ]; then  # first line in find is the folder itself. prevent infinte recursion
                something $line
            fi
        done
    fi
}

while [ $# -gt 0 ]
do
    something "$1"
    shift
done

echo "Processed $count files"

Example output:

$ ./test.sh *
1 0/file1.txt
2 0/file2.txt
1 1/file1.txt
2 1/file2.txt
1 2/file1.txt
2 2/file2.txt
1 3/file1.txt
2 3/file2.txt
1 4/file1.txt
2 4/file2.txt
1 5/file1.txt
2 5/file2.txt
1 6/file1.txt
2 6/file2.txt
1 7/file1.txt
2 7/file2.txt
1 8/file1.txt
2 8/file2.txt
1 9/file1.txt
2 9/file2.txt
1 test.sh
Processed 1 files

As you can see each time I call the function recursively it returns to the variable state on parent function and messes up the count.

Using Ubuntu 22.06 on WSL2 VM

Answer 1

Do I get it right that you want to count all files in a directory tree, or something like that? I.e. you want the variable count to be global?

Your issue is here:

find $1 | while read line; do

See that pipeline? What pipelines do is that they start two or more processes in parallel, and doing that requires starting distinct OS-level processes. Which the shell does here by cloning itself. Those clones can't affect the parent process, so the variable is effectively localized, and when the pipeline ends, you get the original value back.

See Why is my variable local in one 'while read' loop, but not in another seemingly similar loop? for solutions to that.

As an example, a normal recursive function:

% cat local1.sh
#!/bin/bash

count=1
func() {
    (( count++ ))
    printf "$1 %$1s count=$count\n" ""
    if (( $1 < 3 )); then
        func $(( $1 + 1 ))
    fi
    printf "$1 %$1s count=$count\n" ""
}

func 1

running that prints:

1   count=2
2    count=3
3     count=4
3     count=4
2    count=4
1   count=4

Now, change the inner func line to e.g. echo | func $(( $1 + 1 )) and you'll see the count go back down when the function calls return.

---

Now, another thing entirely is that calling find on each level of a recursive tree walk is a bit suspicious, since find will itself recursively walk the whole tree. Are you sure you want to add another walk on top of that? It'll lead to directories being processed multiple times.

If we go back to counting files, you could do that with just one find, e.g.:

find "$dir" -type f | wc -l

though that would count filenames with newlines as multiple files. With GNU find, you could use ... -printf x | wc -c to avoid that.

---

Actually, just removing the manual recursion should be all right to call a function for each (regular) file:

#!/bin/bash
shopt -s lastpipe

count=0
func() {
    echo "processing '$1'..."
    ((count++))
}
find "$1" -type f | while IFS= read -r file; do
    func "$file"
done
echo "end. count=$count"

Clear IFS and use read -r as above to avoid having read treat whitespace and backslashes specially.

_{(and to avoid issues with newlines in filenames, use find ... -print0 | while IFS= read -r -d '' file; do ... in Bash)})