Ytdyklly

I want to do it with a for loop. This is what I've come up with so far which does not work.

for home in /home/ {.,/}*; do echo "$home"; done

I would like to do this non-recursively if possible.

There are many higher level commands that will almost do what you want to do, but this is a good demonstration of how to do the same thing in a shell script. This should work on any system that has /bin/sh. It's not dependent on any other commands.

You can save this script as any filename, and then type sh ./whatever_you_named_it to execute it.

I've split this into two sections, Listing the Files, and Counting the Files. Listing the files recursively is the most complicated, but once we have a list, it's easy to count them.

Listing the Files

This script recursively lists all of the files and directories under your home directory or a directory it receives as a parameter. With no parameters, it defaults to the home directory.

#!/bin/sh



if test $# -eq 0

then

    startdir="$HOME"

else

    startdir="$1"

fi



for f in "$start"/*          # step through all files in the starting directory

do

     echo "$f"               # print the file name

     if test -d "$f"         # is the file a directory? (-d)

     then

        sh "$0" "$f"         # yes call this script with the dir as arg

     fi

done

Let's discuss each step:

1. 
   

   If no parameters were passed to the script, then use "$HOME" as the starting directory, otherwise use the first parameter. ($# contains the number of parameters passed to this script and we use the shell's built-in test command to find out if it's zero):

   
   
   

   if test $# -eq 0
   
   then
   
           startdir="$HOME"
   
   else
   
           startdir="$1"
   
   fi
   
   

   
   


2. 
   

   Iterate over files in your home directory. "$HOME"/* expands to all of the non-hidden files and directories at the top level of your home directory:

   
   
   

   for f in "$HOME"/*
   
   do
   
   

   
   


3. 
   

   Print the file name. I think you know echo:

   
   
   

        echo "$f"               # print the file name
   
   

   
   


4. 
   

   Call the shell built-in test command with the -d option. test returns true if the argument, "$f", is a directory. This is most often written as [ -d "$f" ] for brevity, but it really is a command. [Search for "test expr" in the sh man page]:

   
   
   

       if test -d "$f"         # is the file a directory? (-d)
   
       then
   
   

   
   


5. 
   

   This next statement is where we recur. We start a new copy of the currently running script and pass a the current "$f" directory name to it. The $0 expands to the filename of the current shell script. Rather than type some filename here, we use $0 so this script will work even if it's name is changed. For example, if the script was called rlist, then you could also write sh rlist "$f", but if the script was renamed, the script would no longer function correctly, because it would be calling a non-existent script, or the wrong script. [See "Special Parameters" in the sh man page]:

   
   
   

           sh "$0" "$f"         # yes call this script with the dir as arg
   
   

   
   


6. 
   

   Terminates the if statement and the for loop.

   
   
   

        fi
   
   done
   
   

   
   

Counting the Files

The script so far lists the files but does not count them. If you want to get a count of all the files and directories execute this:

sh ./scriptname | wc -l

wc -l is the "word count" command, and with the -l option counts only the lines. The above pipeline prints a number which is the number of files under your home directory.

with find for not directory types in the current directory without recursing:

find . ! -name . -prune ! -type d | grep -c /

...for only directories drop the second bang, or for all filetypes drop the -type test entirely.

that's easy in this case because without recursion we only ever see one path delimiter per file and so there is no confusion about what and where to count. counting newlines when you should be counting files can lead to trouble - the two things are unrelated. so what to do otherwise?

find .//. | grep -c '^.//.'

...will return an accurate count of child objects + this object rooted in the current directory.

equally as valid, but with reversed logic because it quotes newlines internally and probably faster because it needs only to stat() each directory rather than every constituent file:

ls -1qRA . | grep -Exc [^/]+

if you drop the -R option to ls it will work without recursion just as well.

it is possible, though, that the above could return a false count depending on multibyte characters in filenames and incompatible locale settings. putting LC_ALL=C in a POSIX-conformant ls's environment would protect against that, and for depth counts of a sizable tree, doing so can only help matters with regards to performance after all.

Use find:

When you say non-recursively, did you mean that you only want a count of files/directories in /home, but not any subdirectories? If that is the case, you can restrict results to the top level with the maxdepth option.

find /home -maxdepth 1 | wc -l

Using for:

i=0; for home in ~/*; do (( i++ )); done; echo $i

Note the spaces between the double parentheses and the enclosed i++.