Shulou(Shulou.com)06/03 Report--

This article mainly introduces the Linux shell programming IO and conditions and loop processing example analysis, has a certain reference value, interested friends can refer to, I hope you can learn a lot after reading this article, the following let Xiaobian take you to understand.

> and

< 差在哪？ 谈到I/O redirection，不妨先让我们认识一下File Descriptor（FD）。程序的运算，在大部份情况下都是进行数据（data）的处理，这些数据从哪读进？又，送出到哪里呢？这就是File descriptor（FD）的功用了。 在shell程序中，最常使用的FD大概有三个，分别为： 0: Standard Input（STDIN） 1: Standard Output（STDOUT） 2: Standard Error Output（STDERR） 在标准情况下，这些FD分别跟如下设备（device）关联： stdin（0）：keyboard stdout（1）：monitor stderr（2）：monitor 我们可以用如下下命令测试一下： $ mail -s test rootthis is a test mail.please skip. ^d（同时按crtl跟d键） 很明显，mail程序所读进的数据，就是从stdin也就是keyboard读进的。不过，不见得每个程序的stdin都跟mail一样从keyboard读进，因为程序作者可以从档案参数读进stdin，如： $ cat /etc/passwd 但，要是cat之后没有档案参数则又如何呢？哦，请您自己玩玩看啰….^_^ $ cat （请留意数据输出到哪里去了，最后别忘了按^d离开…）至于stdout与stderr，嗯…然后，让我们继续看stderr好了。 事实上，stderr没甚么难理解的：说穿了就是"错误信息"要往哪边送而已…比方说，若读进的档案参数是不存在的，那我们在monitor上就看到了： $ ls no.such.filels: no.such.file: No such file or directory 若，一个命令同时产生stdout与stderr呢？那还不简单，都送到monitor来就好了： $ touch my.file$ ls my.file no.such.filels: no.such.file: No such file or directorymy.file okay，至此，关于FD及其名称、还有相关联的设备，相信你已经没问题了吧？那好，接下来让我们看看如何改变这些FD的预设数据信道，我们可用来改变送出的数据信道（stdout，stderr），使之输出到指定的档案。比方说： $ cat < my.file 就是从my.file读进数据 $ mail -s test root < /etc/passwd 则是从/etc/passwd读进… 这样一来，stdin将不再是从keyboard读进，而是从档案读进了…严格来说，file.both 2>

File.both

If both stdout (1) and stderr (2) are writing file.both at the same time, it is "overwriting": later writing overwrites the front. Let's imagine a situation where stdout and stderr are written to file.out at the same time:

First stdout writes 10 characters

Then stderr writes six characters

So, at this point, the 10 characters originally output by stdout are overwritten by stderr. So, how to solve it? As the saying goes, the mountain does not turn, the road does not turn, the road does not turn, we can change our thinking: import stderr into stdout or stdout into sterr, instead of everyone grabbing the same file, that's it! bingo! that's it:

2 > & 1 is to merge stderr into stdout as output.

1 > & 2 or > & 2 means to merge stdout into stderr as output

Therefore, the previous error action can be changed to:

$ls my.file no.such.file 1 > file.both 2 > & 1

Or

$ls my.file no.such.file 2 > file.both > & 2

In the Linux file system, there is a device file located at / dev/null. A lot of people have asked me what it is. I have a deal with you: that's "empty"! that's right! empty is null. . May I ask whether the donor has suddenly made a mistake? Congratulations, however, this null is very useful in the I _ Redirection:

If you transfer FD1 and FD2 to / dev/null, you can lose stdout and stderr.

If you send FD0 to / dev/null, it is read into nothing.

For example, when we are executing a program, the screen will send out both stdout and stderr.

If you don't want to see stderr (and you don't want to save it to a file), you can:

$ls my.file no.such.file 2 > / dev/nullmy.file

To the contrary: just want to see stderr? It's not easy! just get stdout to null:

$ls my.file no.such.file > / dev/nullls: no.such.file: No such file or directory

Next, what if you just run the program and don't want to see any output? Oh, here is a way that was not mentioned in the last program, which is specially given to the right person! In addition to > / dev/null 2 > & 1, you can also do this:

$ls my.file no.such.file & > / dev/null

(hint: replace & > with > & it's all right! )

Okay? After talking about the Buddha, let's take a look at the following:

$echo "1" > file.out$ cat file.out1 $echo "2" > file.out$ cat file.out2

It seems that when we redirect stdout or stderr into a file, we always seem to get the result of the last import. So, what about the previous content? Oh, to solve this question is very simple, just replace > with > >:

$echo "3" > > file.out$ cat file.out23

In this way, the content of the redirected target file will not be lost, while the new content will always be added at the end. Easy? Heh... ^ _ ^

However, as long as you use a single > to redirect again, then the old content will still be "washed" out! at this time, how do you avoid it? -backup! yes, I hear you! but... . Is there anything better? Since you are so predestined with the giver, Lao Na will give you a trick up your sleeve:

$set-o noclobber$ echo "4" > file.out-bash: file: cannot overwrite existing file

So, how can this "restriction" be lifted? Oh, just change set-o to set + o:

$set + o noclobber$ echo "5" > file.out$ cat file.out5

Ask again: then... Is there any way to write the target file "temporarily" without canceling it? Oh, the Buddha said: you can't tell me! Ah, I was joking, joking, jo

$set-o noclobber$ echo "6" > | file.out$ cat file.out6

Have you noticed: just add a "|" after > (Note: there can be no space between > and |). Call... (take a deep breath) there is one more difficult problem for you to figure out:

$echo "some text here" > file$ cat

< filesome text here$ cat < file >

File.bak$ cat

< file.baksome text here$ cat < file >

File$ cat

< file 嗯？！注意到没有？！！----怎么最后那个cat命令看到的file竟是空的？﹗why？why？why？当当当~上课啰~ ^_^ 前面提到：$ cat < file >

After file, the files with content were washed out! it's not difficult to understand this phenomenon, it's just a problem with priority:

In IO Redirection, the pipeline between stdout and stderr is ready before data is read from stdin. That is, in the above example, > file empties the file before reading it into the

< file，但这时候档案已经被清空了，因此就变成读不进任何数据了…哦~原来如此~~ ^_^ 那…如下两例又如何呢？ $ cat file$ cat < file >

> file

Um... Students, these two answers are regarded as exercise questions. Please hand in your homework before next class! all right, I am almost finished with I Redirection, sorry, because that's all I know. However, there is one more thing that must be said, everyone. # @! $%):-even pipe line!

When it comes to pipe line, I'm sure many people are familiar with it: the "|" symbol we often see on many command line is pipe line. But what exactly is pipe line? Don't worry... Look it up in the English-Chinese dictionary first to see what pipe means. That's right! it means "water pipe". So, can you imagine how water pipes go from one pipe to another? And what about the input and output between each pipe? Huh? A flash of inspiration: it turns out that the pipe line's stdout O is exactly the same as that of the water pipe: the stdin of the previous command has gone to the next command! That's true... No matter how many pipe line you use on command line, the front and back command are connected to each other! (congratulations: you finally got it! ^ _ ^)

But... However... But. Where's stderr? Good question! but it's also easy to understand: what if the water pipe leaks? That is to say: between pipe line, the stderr of the previous command will not be connected to the stdin of the next command, and its output will be sent to the camera if it is not directed to file with 2 >! you must pay attention to this point in the use of pipe line. Then, you may ask: is there a way to feed stderr into the stdin of the next command? (greedy guy!) of course there is, and you've already learned it! ^ _ ^ I'll just give you a hint: how do you merge stderr into stdout and output it? If you can't answer, come back and ask me after class. If you are really thick-skinned. )

Maybe you still haven't done your best! maybe you've encountered the following problems:

In cm1 | cm2 | cm3... In this pipe line, what if you want to save the results of cm2 to a certain file?

If you write cm1 | cm2 > file | cm3, then you will definitely find that the stdin of cm3 is empty! (of course, you connected the plumbing to another pool!) the smart one may solve it like this: cm1 | cm2 > file; cm3 < file Yes, you can do that, but the biggest downside is: this doubles the file stdin O! in the whole process of command execution, file Icanano is the most common maximum performance killer. All experienced shell operators will try their best to avoid or reduce the frequency of file I Dot O. So, is there a better way to ask the above question? Yes, that's the tee command.

The so-called tee command is to copy a copy of the stdout to the file without affecting the original Imax O. Therefore, the above command line can be typed as follows:

Cm1 | cm2 | tee file | cm3

By default, tee will overwrite the target file, and if you want to add content instead, you can use the-a parameter.

Basically, pipe line is widely used in shell operations, especially in text filtering.

Where you raise cat,more,head,tail,wc,expand,tr,grep,sed,awk,... When you use word processing tools such as pipe line, you will be surprised to find that command line is so wonderful! it often makes people feel that "people look for him thousands of degrees in the crowd, suddenly look back, but that person is in the dim lights!" ^ _ ^

Do you want if or case?

After a happy Spring Festival holiday, people become lazy. It's just that if you agree to your homework, you still have to stick to it.

Remember the return value we introduced in Chapter 10? Yes, the next introduction is related to it, if your memory is also offset by the happy time of the holiday, then you are advised to go back to study and come back first.

If you remember return value, I think you should also remember & & and | | what do you mean? If we use these two symbols to match command group, we can make shell script smarter. For example:

Comd1 & & {comd2 comd3:} | | {comd4 comd5}

If the return value of comd1 is true, then execute comd2 and comd3, otherwise execute comd4 and comd5.

In fact, when we write shell script, we often need to use one condition or another to make different processing actions.

It is true that the effect of conditional execution can be achieved with & & and |. However, it is not so intuitive in terms of "human language".

More often, we still like to use if. . then... Else... Such a keyword is used to express conditional execution. In bash shell, we can modify the previous code as follows:

If comd1then comd2 comd3else comd4 comd5fi

This is also the most commonly used if judgment in shell script: as long as the command line after if returns the return value of true (we most often use the test command to send out return value), then execute the command after then, otherwise execute the command after else; fi is used to end the judgment keyword.

In the if judgment, the else part may not be used, but then is required. If you don't want to run any command after then, you can use this null command instead. Of course, a further level of conditional judgment can also be used after then or else, which is common in shell script design.

If there are many conditions that need to be judged "in order", we can use a keyword such as elif:

If comd1; then comd2elif comd3; then comd4else comd5fi

If comd1 is true, then execute comd2; or test comd3 again, then execute comd4; if neither comd1 nor comd3 is valid, then execute comd5.

Examples of if judgments are very common, as you can see in many shell script, so I won't give any more examples here. The next thing I would like to introduce to you is the case judgment.

Although if judgment can handle most of the conditions, it is not flexible enough in some cases, especially in the judgment of string style, such as:

QQ () {echo-n "Do you want to continue? (Yes/No):" read YN if ["$YN" = Y-o "$YN" = y-o "$YN" = "Yes"-o "$YN" = "yes"-o "$YN" = "YES"] then QQ else exit 0 fi} QQ

From the example, we can see that the most troublesome part is to determine that there may be several styles of YN values. If you are smart, you may modify it like this:

If echo "$YN" | grep-Q'^ [Yy]\ ([Ee] [Ss]\) * $'

That is, Regular Expression is used to simplify the code. (we have a chance to introduce RE again) it's just... Is there any other more convenient way? Yes, just use the case judgment formula:

QQ () {echo-n "Do you want to continue? (Yes/No):" read YN case "$YN" in [Yy] | [Yy] [Ee] [Ss]) QQ;; *) exit 0;; esac} QQ

We often use the case formula to determine that a variable is treated differently when it has different values (usually string), for example, judging the script parameter to execute different commands. If you are interested in using the Linux system, dig up the case usage in the pile of script in / etc/init.d/*. The following is an example:

Case "$1" in start) start;; stop) stop;; status) rhstatus;; restart | reload) restart;; condrestart) [- f / var/lock/subsys/syslog] & & restart |;; *) echo $"Usage: $0 {start | stop | status | restart | condrestart}" exit 1 esac

If your impression of positional parameter is blurred, please revisit Chapter 9. (okay, there is only one question left in the thirteenth question. Come back and fix it in a few days. . ^ _ ^

For what? What's the difference between while and until?

Finally, I would like to introduce the "loop" that is common in shell script design. The so-called loop is a piece of code in script that is executed repeatedly under certain conditions. There are three kinds of loop commonly used in bash shell: for while until

For loop reads the value of a variable from a list and executes the command line between do and done in a loop "in turn". Example:

For var in one two three four fivedo echo-echo'$var is'$var echodone

The execution result of the above example will be:

For defines a variable called var, whose value is one two three four five in turn.

Because there are five variable values, the command line between do and done is iterated five times.

Each cycle uses echo to generate three lines of sentences. In the second line, $var that is not within the hard quote is replaced by one two three four five in turn.

When the value of the last variable is processed, the loop ends.

It is not difficult to see that in for loop, the number of cycles is determined by the value of the variable. However, whether a variable is used in a loop or not is not certain, depending on the design requirements. If for loop does not use the in keyword to specify a list of variable values, its values will inherit from $@ (or $*):

For var; do... Done

If you forget positional parameter, please review Chapter 9. )

For loop is very convenient for dealing with "list" items, which can be obtained not only from explicitly specified or obtained from positional parameter, but also from variable substitution or command substitution. (once again, don't forget the "reorganization" feature of the command line! )

However, for some "cumulative change" items (such as integer addition and subtraction), for can also handle:

For ((iTun1)

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.