I hate to say it, but: not quite.

Programming (writing a script, however small, IS programming) is a complex activity and you need to do it right, the same way you need to establish a protocol.

When establishing a certain method - say, i want to use a Taqman PCR to establish the expression of a certain protein - we need to not only get one good try but we need to work on the method as long as it takes to get good tries reliably. To show that one certain mouse had a higher expression level means nothing - we would need to show that all the knock-down specimen have significantly higher/lower expression levels than the control group, yes? When writing programs you do not stop once it did once what you want but you work until it does what you want even under the most adverse conditions (or nothing at all, but definitely not doing something you do NOT want), you work until you can understand it well and until a certain "elegance" in the way it is written is reached. *)

You are right, it looks ugly - or, as i prefer to say, rather "unelegant". The usage of a (completely unnecessary) "tmp"-file is one of the reasons. But let us start at a basic topic:

Code:

for y in {1..3}
do
    for x in {1..3}

Of course for the system it doesn't matter what variable names you use, but YOU - the human reader trying to understand what the program does - it matters big time. Do yourself a favour and give variables a meaningful name: "row" and "column" is more easily understood than "x" and "y". It will not matter how you name variables, but do so in a way you yourself can easily understand its purpose and it possible contents from the name.


No! Programming is about keeping order and you should NEVER use such devices. If you want a list of replacements then create a list of replacements, not a list of anything with replacements interspersed. if you need a separate name for a file then create it using a separate variable - there is no shortage of them, for example:

Code:

for outerloop in {1..3} ; do
     for innerloop in {0..2} ; do
          (( filenamepart = innerloop + 1 ))
          eval command \${array${outerloop}[$innerloop]} > file.${filenamepart}.${outerloop}
     done
done

At last, let us talk about the intermediate "tmp" file:

Code:

eval echo "\${TMPArray${y}[$x]}" > tmp | awk -v "REP=$(awk '{print}' tmp)"[...]

First, the pipe is not necessary at all and most probably keeping the line from doing what you want to do. Picture a process (any process - "awk" or any other program) like a garden hose: you pour data into it at the top, and some (processed) data flows out at the bottom. A pipe, to carry on with this picture, means to connect two such garden hoses so that the outflow of one pours into the other.

Some programs take their data from either this input ("stdin") or from files and "awk" is among them. So the following two lines do the same:

Code:

awk '....' inputfile
cat inputfile | awk '...'

"cat" just takes an input file (or "stdin") and spews out what is there. Notice that the following - though not making very much sense - is also doing the same:

Code:

cat inputfile | cat | awk '...'

the first "cat reads from a file and puts its contents to "stdout", which is connected to the "stdin" of the second "cat". This again puts everything going in there to its own "stdout" (we are now through two hoses of the same type) and finally this is connected to "stdin" of awk.

To come back to your line: there is nothing you want to pass through this mechanism to "awk" and therefore this is just redundant. Its just two commands:

Code:

eval echo "\${TMPArray${y}[$x]}" > tmp
awk -v "REP=$(awk '{print}' tmp)"[...]

Now, when you look closely at the first command, what does go into this file "tmp"? In fact, after all the "eval"s and expansions, it is a certain array element, say "GGGGGG|TTTTT". So, effectively you have there a line that says:

Code:

echo "GGGGGG|TTTTT" > tmp

(yes, the values differ for each execution of the loop, but the schema stays the same). You could - if you don't want to convolute your "awk" statement too much, which is a good idea, always do one thing in a step, but do it good - put it in a variable:

Code:

eval replacement=\${TMPArray${y}[$x]}
awk -v "REP=${replacement}"[...]

I hope this helps.

bakunin
__________________
*) this is a difficult topic to explain to a novice and you will probably just have to believe me - at least for the moment. I can tell you that "elegantly written" programs tend to work better and are more easily maintained than "unelegant" ones.