Sstrhsrtj

I'm trying to concatenate files from three different subdirectories into one file. The names of the files in each subdirectory are exactly the same. I'd like to use a loop to iterate through the subdirectories, and then place an iteration number into the newly named concatenated file, in a new directory.
For example a directory structure like:

Foo

|||

||Bar3

|Bar2

Bar1

Inside each Bar(?) folder are files named:
File1, File2, File3

I'd like to concatenate the Files with the same names to a larger file with a new name including a number:

cat Foo/Bar1/File1 Foo/Bar2/File1 Foo/Bar3/File1 > /combined_files/all_file1



cat Foo/Bar1/File2 Foo/Bar2/File2 Foo/Bar3/File2 > /combined_files/all_file2



cat Foo/Bar1/File3 Foo/Bar2/File3 Foo/Bar3/File3 > /combined_files/all_file3

From the Foo directory I can use:

for number in {1..3}

    do

    cat Bar1/File$number_* Bar2/File$number_* Bar3/File$number_* > combined_files/'all_files'$number

    done

exit

But I need to have a more universal script, for larger numbers of Bar directories, and Files.
I want something like

files=`ls ./Run1/ | wc -l`   #to count the number of files and assign a number

For n in {1..$files}

    do

    cat Bar1/File$n_* Bar2/File$n_* Bar3/File$n_* > combined_files/'all_files'$n

    done

But I'm stuck.

#!/bin/sh



for pathname in Foo/Bar1/File*; do

    filename=${pathname##*/}

    cat "$pathname" 

        "Foo/Bar2/$filename" 

        "Foo/Bar3/$filename" >"combined/all_$filename"

done

This would loop over all files whose names matches File* under Foo/Bar1 (we assume that the pattern matches exactly the names we are actually interested in).

For each such file, we extract the filename portion of the pathname, yielding $filename (this could also have been done with filename=$(basename "$pathname")). We then concatenate the original file with the corresponding files in the Foo/Bar2 and Foo/Bar3 directories, writing the result to a new all_$filename file in some other directory.

With a bit of error checking:

#!/bin/sh



for pathname in Foo/Bar1/File*; do

    if [ ! -f "$pathname" ]; then

        printf '% is not a regular file, skippingn' "$pathname" >&2

        continue

    fi



    filename=${pathname##*/}



    if [ -f "Foo/Bar2/$filename" ] &&

       [ -f "Foo/Bar3/$filename" ]

    then

        cat "$pathname" 

            "Foo/Bar2/$filename" 

            "Foo/Bar3/$filename" >"combined/all_$filename"

    else

        printf 'Missing %s or %sn' "Foo/Bar2/$filename" "Foo/Bar3/$filename" >&2

    fi

done

A variation that also allows for a varied number of BarN subdirectories. It is assumed that each BarN directory is numbered sequentially from 1 to some large number.

#!/bin/sh



# This is just used to count the number of BarN subdirectories.

# The number of these will be $#.

set -- Foo/Bar*/



for pathname in Foo/Bar1/File*; do

    filename=${pathname##*/}



    n=1

    while [ "$n" -le "$#" ]; do

        if [ ! -f "Foo/Bar$n/$filename" ]; then

            printf '%s missing, %s will be incompleten' 

                "Foo/Bar$n/$filename" "combined/all_$filename" >&2

            break

        fi



        cat "Foo/Bar$n/$filename"

        n=$(( n + 1 ))

    done >"combined/all_$filename"

done

Thank you again @Kusalananda and @Debian_yadav. I was able to make your script work on my system. My actual directory names are now:

Joes
|||
||Run3
|Run2
Run1

Inside each RunX directory I created Files named the same but with different contents

Run1File1

Run2File1

Run3File1

First I ran the simple script you showed, slightly modified to my directory structure:

ANSWER

#!/bin/bash

for pathname in Run1/File*; do

    filename=${pathname##*/}

    cat "$pathname" 

        "Run2/$filename" 

        "Run3/$filename" > "RunCat/all_$filename"

one

The script output was a file "allFile1" with contents:
123

Your longer (final) script (I named K2script.sh) also worked on my system.

The output exactly the same again after slightly modifying the directory structure:

ANSWER

#!/bin/sh

# This is just used to count the number of RunN subdirectories.

# The number of these will be $#.

set -- Joes/Run*/



for pathname in Run1/File*; do

    filename=${pathname##*/}



    n=1

    while [ "$n" -le "$#" ]; do

        if [ ! -f "Run$n/$filename" ]; then

            printf '%s missing, %s will be incompleten' 

                "Run$n/$filename" "RunCat/all_$filename" >&2

            break

        fi



        cat "Run$n/$filename"

        n=$(( n + 1 ))

    done >"RunCat/all_$filename"

done 

Also, using the script from
an other stackexchange discussion

ANSWER

Changing the folder names made it work on my system.

#!/bin/bash

for FILE in Run1/* ; do

    FILE2=Run2/${FILE#*/}

    FILE3=Run3/${FILE#*/}

    if [ -f $FILE2 ] ; then

        cat $FILE $FILE2 $FILE3 > RunCat/${FILE#*/}

    fi

done

I've learned a lot about while [ "$n" -le "$#" ]; do and how ${pathname##*/} works,
but wasn't able to fully grasp why ${FILE#*/} worked when other wildcard symbols or regular expressions would not.