The way you are being told to do it is not only wasting a lot of resources but also dangerous and easily broken by unexpected (yet legal) sets of input data. RudiC was absolutely correct in his suggestion and i will try to explain the concept to you. Be prepared, though, it has absolutely nothing to do with subshells. I suggest you get yourself a good book about programming your shell (probably ksh or bash) and start reading.

The shell accepts its input in "fields": parts which form distinct entities. You rely implicitly on this mechanism when you enter

Code:

grep 5000 /etc/passwd

because something has to tell the shell that "5000" is the first argument and "/etc/passwd" is the second. The reason is obvious: there is a blank in between. So, the blank character splits field1 (the first argument) from field2 (the second argument). Now consider the following:

Code:

grep "5000 /etc/passwd" /some/other/file

This will search for the string "5000 /etc/passwd" in a file named "/some/other/file". The double quotes have prevented the field splitting (or - just another way to put it - stripped from the blank character the ability to split fields). We notice that the field splitting character - the correct term is "internal field separator" or IFS for short - can be redefined.

In fact there is an environment variable "IFS", which defines the IFS character. It is possible to redefine it by simply changing its value:

Code:

IFS=X

will set the splitting character from " " to "X". Usually we want such a behavior only for a very limited part of our script (otherwiseXweXwouldXhaveXtoXuseX"X"sXinsteadXofXblanks) and fortunately it is possible to redefine the environment for only one command (this is as close to the concept of subshells as it will get). This is what RudiC did:

Code:

IFS=: read UN X UID GID USER REST

This reads a line and puts the content of field1 into variable "UN", field2 into "X", field3 into "UID", etc.. "field" now is not something sepearated by blanks but by colons - exactly the format the file /etc/passwd is written.

RudiC now put this in a while-loop to circle through all the lines in the file:

Code:

while <command> ; do
     <command1>
     <command2>
     ...
done </etc/passwd

This will execute the while-loop for as long as <command> returns "TRUE". Once it returns something else the loop is aborted. Note that the whole loop has a redirected input: it gets fed the content of /etc/passwd. This is passed to the read-command, one line for every pass of the loop. When the end of the file is reached, read will return FALSE and the loop will be aborted.

Code:

while IFS=: read UN X UID GID USER REST ; do
     echo Variable UN   holds: $UN
     echo Variable X    holds: $X
     echo Variable UID  holds: $UID
     echo Variable GID  holds: $GID
     echo Variable USER holds: $USER
     echo Variable REST holds: $REST
done </etc/passwd

Notice that all remaining parts (regardless of how many fields the line may consist of) are stored into the last variable. Try the following and notice the difference:

Code:

while IFS=: read UN X UID REST ; do
     echo Variable UN   holds: $UN
     echo Variable X    holds: $X
     echo Variable UID  holds: $UID
     echo Variable REST holds: $REST
done </etc/passwd

Once you have made sure all the variables hold the values you expect them to hold replace the echo ...-statements by some code which does whatever you want.

I hope this helps.

bakunin