Skip to content
Navigation Menu
{{ message }}
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy path0340bashshell-scripts.html
More file actions
1600 lines (1599 loc) · 114 KB
/
Copy path0340bashshell-scripts.html
File metadata and controls
1600 lines (1599 loc) · 114 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<!DOCTYPE html>
<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="Author" content="VBird, 鸟哥">
<meta name="Description" content="学习 Shell Scripts">
<title>鸟哥的 Linux 私房菜 -- 第十二章、学习 Shell Scripts</title>
<style type="text/css">
</style>
<link href="./vbird_files/style_2013.css" rel="stylesheet" type="text/css">
</head>
<body>
<div class="tablearea">
<div class="mainarea">
<div class="block1">
<!-- 本文的档头部分 -->
<h1>第十二章、学习 Shell Scripts</h1>
<div style="text-align:right">
<span class="text_history">最近更新日期：2015/07/17</span>
</div>
<!-- 本文的档头部分 -->
<div class="abstract">
<p>如果你真的很想要走信息这条路，并且想要管理好属于你的主机，那么，别说鸟哥不告诉你，
可以自动管理系统的好工具： Shell scripts！这家伙真的是得要好好学习学习的！
基本上， shell script 有点像是早期的批次档，亦即是将一些指令汇整起来一次运行，但是 Shell script
拥有更强大的功能，那就是他可以进行类似程序 (program) 的撰写，并且不需要经过编译 (compile) 就能够运行，
真的很方便。加上我们可透过 shell script 来简化我们日常的工作管理，
而且，整个 Linux 环境中，一些服务 (services) 的启动都是透过 shell script 的，
如果你对于 script 不了解，嘿嘿！发生问题时，可真是会求助无门喔！所以，好好的学一学他吧！</p>
</div>
<!-- 本文的链接区部分 -->
<div class="links">
<ul>
<li><a href="0340bashshell-scripts.html#script">12.1 什么是 Shell Script</a>
<ul>
<li><a href="0340bashshell-scripts.html#script_why">12.1.1 干嘛学习 shell scripts</a></li>
<li><a href="0340bashshell-scripts.html#script_1st">12.1.2 第一支 script 的撰写与运行</a></li>
<li><a href="0340bashshell-scripts.html#script_be">12.1.3 撰写 shell script 的良好习惯创建</a></li>
</ul></li>
<li><a href="0340bashshell-scripts.html#some_ex">12.2 简单的 shell script 练习</a>
<ul>
<li><a href="0340bashshell-scripts.html#some_ex_simple">12.2.1 简单范例</a>： <a href="0340bashshell-scripts.html#ex_read">对谈式脚本</a>,
<a href="0340bashshell-scripts.html#ex_date">随日期变化</a>, <a href="0340bashshell-scripts.html#ex_cal">数值运算</a>, <a href="0340bashshell-scripts.html#ex_pi">计算 pi</a></li>
<li><a href="0340bashshell-scripts.html#some_ex_run">12.2.2 script 的运行方式差异 (source, sh script, ./script)</a></li>
</ul></li>
<li><a href="0340bashshell-scripts.html#dis">12.3 善用判断式</a>
<ul>
<li><a href="0340bashshell-scripts.html#test">12.3.1 利用 test 指令的测试功能</a></li>
<li><a href="0340bashshell-scripts.html#test_2">12.3.2 利用判断符号 [ ]</a></li>
<li><a href="0340bashshell-scripts.html#dis3">12.3.3 Shell script 的缺省变量($0, $1...)</a>： <a href="0340bashshell-scripts.html#shift">shift</a></li>
</ul></li>
<li><a href="0340bashshell-scripts.html#rule">12.4 条件判断式</a>
<ul>
<li><a href="0340bashshell-scripts.html#ifthen">12.4.1 利用 if .... then</a>： <a href="0340bashshell-scripts.html#ifthen_simple">单层简单条件</a>,
<a href="0340bashshell-scripts.html#ifthen_multi">多重复杂条件</a>, <a href="0340bashshell-scripts.html#check_1">检验$1内容</a>, <a href="0340bashshell-scripts.html#netstat">网络状态</a>,
<a href="0340bashshell-scripts.html#retire">退伍</a></li>
<li><a href="0340bashshell-scripts.html#case">12.4.2 利用 case ..... esac 判断</a></li>
<li><a href="0340bashshell-scripts.html#function">12.4.3 利用 function 功能</a></li>
</ul></li>
<li><a href="0340bashshell-scripts.html#loop">12.5 循环 (loop)</a>
<ul>
<li><a href="0340bashshell-scripts.html#while">12.5.1 while...do...done, until...do...done (不定循环)</a></li>
<li><a href="0340bashshell-scripts.html#for">12.5.2 for...do...done (固定循环)</a>： <a href="0340bashshell-scripts.html#for_account">帐号检查</a>,
<a href="0340bashshell-scripts.html#for_ping">网络状态 $(seq )</a></li>
<li><a href="0340bashshell-scripts.html#for_2">12.5.3 for...do...done 的数值处理</a></li>
<li><a href="0340bashshell-scripts.html#array">12.5.4 搭配乱数与数组的实验</a></li>
</ul></li>
<li><a href="0340bashshell-scripts.html#debug">12.6 shell script 的追踪与 debug</a></li>
<li><a href="0340bashshell-scripts.html#hint">12.7 重点回顾</a></li>
<li><a href="0340bashshell-scripts.html#ex">12.8 本章习题</a></li>
</ul>
</div>
</div>
<!-- 本文的正式部分 -->
<a id="script"></a>
<div class="block1">
<h2>12.1 什么是 Shell scripts</h2>
<p>什么是 shell script (程序化脚本) 呢？就字面上的意义，我们将他分为两部份。
在『 shell 』部分，我们在 <a href="0320bash.html">十章的 BASH</a>
当中已经提过了，那是一个文本接口底下让我们与系统沟通的一个工具接口。那么『 script 』是啥？
字面上的意义， script 是『脚本、剧本』的意思。整句话是说， shell script 是针对 shell 所写的『剧本！』</p>
<p>什么东西啊？其实， <span class="text_import2">shell script 是利用 shell 的功能所写的一个『程序
(program)』，这个程序是使用纯文本档，将一些 shell 的语法与指令(含外部指令)写在里面，
搭配正规表示法、管线命令与数据流重导向等功能，以达到我们所想要的处理目的。</span></p>
<p>所以，简单的说， shell script 就像是早期 DOS 年代的批次档 (.bat) ，最简单的功能就是将许多指令汇整写在一起，
让用户很轻易的就能够 one touch 的方法去处理复杂的动作 (运行一个文件 "shell script" ，就能够一次运行多个指令)。
而且 shell script 更提供数组、循环、条件与逻辑判断等重要功能，让用户也可以直接以 shell
来撰写程序，而不必使用类似 C 编程语言等传统程序撰写的语法呢！</p>
<p>这么说你可以了解了吗？是的！ shell script 可以简单的被看成是批次档，
也可以被说成是一个编程语言，且这个编程语言由于都是利用 shell 与相关工具指令，
所以不需要编译即可运行，且拥有不错的调试 (debug) 工具，所以，他可以帮助系统管理员快速的管理好主机。</p>
<a id="script_why"></a>
<div class="block2"><div class="gototop"><a href="0340bashshell-scripts.html#top">Top</a></div>
<h2>12.1.1 干嘛学习 shell scripts</h2>
<p>这是个好问题：『我又干嘛一定要学 shell script ？我又不是信息人，没有写程序的概念，
那我干嘛还要学 shell script 呢？不要学可不可以啊？』呵呵～如果 Linux 对你而言，
你只是想要『会用』而已，那么，不需要学 shell script 也还无所谓，这部分先给他跳过去，
等到有空的时候，再来好好的瞧一瞧。但是，如果你是真的想要玩清楚 Linux 的来龙去脉，
那么 shell script 就不可不知，为什么呢？因为：</p>
<div class="illus">
<ul><li>自动化管理的重要依据</li></ul>
<p>不用鸟哥说你也知道，管理一部主机真不是件简单的事情，每天要进行的任务就有：查找注册表、追踪流量、监控用户使用主机状态、主机各项硬件设备状态、
主机软件更新查找、更不要说得应付其他用户的突然要求了。而这些工作的进行可以分为：
(1)自行手动处理，或是 (2)写个简单的程序来帮你每日『自动处理分析』这两种方式，你觉得哪种方式比较好？
当然是让系统自动工作比较好，对吧！呵呵～这就得要良好的 shell script 来帮忙的啦！</p>
<ul><li>追踪与管理系统的重要工作</li></ul>
<p>虽然我们还没有提到服务启动的方法，不过，这里可以先提一下，我们 CentOS 6.x 以前的版本中，系统的服务
(services) 启动的接口是在 /etc/init.d/ 这个目录下，目录下的所有文件都是 scripts ；
另外，包括开机 (booting) 过程也都是利用 shell script 来帮忙搜索系统的相关设置数据，
然后再代入各个服务的设置参数啊！举例来说，如果我们想要重新启动系统注册表，
可以使用：『/etc/init.d/rsyslogd restart』，那个 rsyslogd 文件就是 script 啦！</p>
<p>另外，鸟哥曾经在某一代的 Fedora 上面发现，启动 MySQL 这个数据库服务时，确实是可以启动的，
但是屏幕上却老是出现『failure』！后来才发现，原来是启动 MySQL 那个 script
会主动的以『空的密码』去尝试登录 MySQL ，但为了安全性鸟哥修改过 MySQL 的密码啰～当然就登录失败～
后来改了改 script ，就略去这个问题啦！如此说来， script 确实是需要学习的啊！</p>
<p>时至今日，虽然 /etc/init.d/* 这个脚本启动的方式 (systemV) 已经被新一代的 systemd 所取代 (从 CentOS 7 开始)，
但是很多的个别服务在管理他们的服务启动方面，还是使用 shell script 的机制喔！所以，最好还是能够熟悉啦！</p>
<ul><li>简单入侵侦测功能</li></ul>
<p>当我们的系统有异状时，大多会将这些异状记录在系统记录器，也就是我们常提到的『系统注册表』，
那么我们可以在固定的几分钟内主动的去分析系统注册表，若察觉有问题，就立刻通报管理员，
或者是立刻加强防火墙的设置规则，如此一来，你的主机可就能够达到『自我保护』的聪明学习功能啦～
举例来说，我们可以通过 shell script 去分析『当该封包尝试几次还是连接失败之后，就予以抵挡住该
IP』之类的举动，例如鸟哥写过一个关于<a href="http://linux.vbird.org/linux_server/0360apache.html#security_teleport">抵挡砍站软件的 shell script</a> ，
就是用这个想法去达成的呢！</p>
<ul><li>连续指令单一化</li></ul>
<p>其实，对于新手而言， script 最简单的功能就是：『<span class="text_import2">汇整一些在
command line 下达的连续指令，将他写入 scripts 当中，而由直接运行 scripts
来启动一连串的 command line 指令输入！</span>』例如： 防火墙连续规则
(iptables)，开机加载进程的项目 (就是在 /etc/rc.d/rc.local 里头的数据)
，等等都是相似的功能啦！ 其实，说穿了，如果不考虑 program 的部分，那么
scripts 也可以想成『仅是帮我们把一大串的指令汇整在一个文件里面，
而直接运行该文件就可以运行那一串又臭又长的指令段！』就是这么简单啦！</p>
<ul><li>简易的数据处理</li></ul>
<p>由前一章<a href="0330regularex.html">正规表示法</a>的 awk 程序说明中，
你可以发现， awk 可以用来处理简单的数据数据呢！例如薪资单的处理啊等等的。
shell script 的功能更强大，例如鸟哥曾经用 shell script 直接处理数据数据的比对啊，
文本数据的处理啊等等的，撰写方便，速度又快(因为在 Linux 性能较佳)，真的是很不错用的啦！</p>
<p>举例来说，鸟哥每学期都得要以学生的学号来创建他们能够操作 Linux 的系统帐号，然后每个帐号还得要能够有磁盘容量的限制 (quota) 以及相关的设置等等，
那因为学校的校务系统提供的数据都是一整串学生信息，并没有单纯的学号字段，所以鸟哥就得要透过前几章的方法搭配 shell script 来自动处理相关设置流程，
这样才不会每学期都头疼一次啊！</p>
<ul><li>跨平台支持与学习历程较短</li></ul>
<p>几乎所有的 Unix Like 上面都可以跑 shell script ，连 MS Windows 系列也有相关的 script 仿真器可以用，
此外， shell script 的语法是相当亲和的，看都看的懂得文本 (虽然是英文)，而不是机器码，
很容易学习～这些都是你可以加以考量的学习点啊！</p>
</div>
<p>上面这些都是你考虑学习 shell script 的特点～此外， shell script 还可以简单的以 vim
来直接编写，实在是很方便的好东西！所以，还是建议你学习一下啦。</p>
<p>不过，虽然 shell script 号称是程序 (program) ，但实际上， shell script 处理数据的速度上是不太够的。因为 shell script 用的是外部的指令与 bash shell
的一些缺省工具，所以，他常常会去调用外部的函数库，因此，运算速度上面当然比不上传统的编程语言。
所以啰，<span class="text_import2"> shell script 用在系统管理上面是很好的一项工具，但是用在处理大量数值运算上，
就不够好了，因为 Shell scripts 的速度较慢，且使用的 CPU 资源较多，造成主机资源的分配不良。</span>还好，
我们通常利用 shell script 来处理服务器的侦测，倒是没有进行大量运算的需求啊！所以不必担心的啦！</p>
<br></div><br>
<a id="script_1st"></a>
<div class="block2"><div class="gototop"><a href="0340bashshell-scripts.html#top">Top</a></div>
<h2>12.1.2 第一支 script 的撰写与运行</h2>
<p>如同前面讲到的，shell script 其实就是纯文本档，我们可以编辑这个文件，然后让这个文件来帮我们一次运行多个指令，
或者是利用一些运算与逻辑判断来帮我们达成某些功能。所以啦，要编辑这个文件的内容时，当然就需要具备有 bash
指令下达的相关认识。下达指令需要注意的事项在<a href="0160startlinux.html#cmd_cmd">第四章的开始下达指令</a>小节内已经提过，有疑问请自行回去翻阅。
在 shell script 的撰写中还需要用到底下的注意事项：</p>
<ol class="text_import2">
<li>指令的运行是从上而下、从左而右的分析与运行；</li>
<li>指令的下达就如同<a href="0160startlinux.html#cmd_cmd">第四章</a>内提到的：
指令、选项与参数间的多个空白都会被忽略掉；</li>
<li>空白行也将被忽略掉，并且 [tab] 按键所推开的空白同样视为空白键；</li>
<li>如果读取到一个 Enter 符号 (CR) ，就尝试开始运行该行 (或该串) 命令；</li>
<li>至于如果一行的内容太多，则可以使用『 \[Enter] 』来延伸至下一行；</li>
<li>『 # 』可做为注解！任何加在 # 后面的数据将全部被视为注解文本而被忽略！</li>
</ol>
<p>如此一来，我们在 script 内所撰写的程序，就会被一行一行的运行。现在我们假设你写的这个程序文件名是
/home/dmtsai/shell.sh 好了，那如何运行这个文件？很简单，可以有底下几个方法：</p>
<a id="script_run"></a>
<ul class="text_import2">
<li>直接指令下达： shell.sh 文件必须要具备可读与可运行 (rx) 的权限，然后：
<ul>
<li>绝对路径：使用 /home/dmtsai/shell.sh 来下达指令；</li>
<li>相对路径：假设工作目录在 /home/dmtsai/ ，则使用 ./shell.sh 来运行</li>
<li>变量『PATH』功能：将 shell.sh 放在 PATH 指定的目录内，例如： ~/bin/</li>
</ul><br></li>
<li>以 bash 程序来运行：透过『 bash shell.sh 』或『 sh shell.sh 』来运行</li>
</ul>
<p>反正<span class="text_import2">重点就是要让那个 shell.sh 内的指令可以被运行</span>的意思啦！
咦！那我为何需要使用 『./shell.sh 』来下达指令？忘记了吗？回去<a href="0320bash.html#settings_path">第十章内的指令搜索顺序</a>察看一下，
你就会知道原因了！同时，由于 CentOS 缺省用户家目录下的 ~/bin 目录会被设置到 ${PATH} 内，所以你也可以将 shell.sh
创建在 /home/dmtsai/bin/ 底下 ( ~/bin 目录需要自行设置) 。此时，若 <span class="text_import2">shell.sh 在 ~/bin
内且具有 rx 的权限，那就直接输入 shell.sh 即可运行该脚本程序</span>！</p>
<p>那为何『 sh shell.sh 』也可以运行呢？这是因为 /bin/sh 其实就是 /bin/bash (链接档)，使用 sh shell.sh
亦即告诉系统，我想要直接以 bash 的功能来运行 shell.sh 这个文件内的相关指令的意思，所以<span class="text_import2">此时你的 shell.sh 只要有 r 的权限即可被运行喔</span>！而我们也可以利用 sh 的参数，如 -n 及 -x
来检查与追踪 shell.sh 的语法是否正确呢！ ^_^</p>
<ul class="toplist"><li>撰写第一支 script</li></ul>
<p>在武侠世界中，不论是那个门派，要学武功要从扫地与蹲马步做起，那么要学程序呢？呵呵，肯定是由『秀出 Hello World！』
这个字眼开始的！OK！那么鸟哥就先写一支 script 给大家瞧一瞧：</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study ~]$ <span class="term_command">mkdir bin; cd bin</span>
[dmtsai@study bin]$ <span class="term_command">vim hello.sh</span>
<span class="term_write">#!/bin/bash
# Program:
# This program shows "Hello World!" in your screen.
# History:
# 2015/07/16 VBird First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
echo -e "Hello World! \a \n"
exit 0</span>
</pre></td></tr></tbody></table>
<p>在本章当中，请将所有撰写的 script 放置到你家目录的 ~/bin 这个目录内，未来比较好管理啦！上面的写法当中，鸟哥主要将整个程序的撰写分成数段，大致是这样：</p>
<ol>
<li><span class="text_import2">第一行 #!/bin/bash 在声明这个 script 使用的 shell 名称：</span><br>
因为我们使用的是 bash ，所以，必须要以『 <b>#!/bin/bash</b> 』来声明这个文件内的语法使用
bash 的语法！那么当这个程序被运行时，他就能够加载 bash 的相关环境设置档 (一般来说就是 <a href="0320bash.html#settings_bashrc_shell">non-login shell 的 ~/.bashrc</a>)，
并且运行 bash 来使我们底下的指令能够运行！这很重要的！(在很多状况中，如果没有设置好这一行，
那么该程序很可能会无法运行，因为系统可能无法判断该程序需要使用什么 shell 来运行啊！)<br><br></li>
<li><span class="text_import2">程序内容的说明：<br></span>
整个 script 当中，除了第一行的『 #! 』是用来声明 shell 的之外，其他的 # 都是『注解』用途！
所以上面的程序当中，第二行以下就是用来说明整个程序的基本数据。一般来说，
建议你一定要养成说明该 script 的：1. 内容与功能； 2. 版本信息； 3. 作者与联系方式；
4. 建档日期；5. 历史纪录 等等。这将有助于未来程序的改写与 debug 呢！<br><br></li>
<li><span class="text_import2">主要环境变量的声明：</span><br>
建议务必要将一些重要的环境变量设置好，鸟哥个人认为， PATH 与 LANG (如果有使用到输出相关的信息时) 是当中最重要的！
如此一来，则可让我们这支程序在进行时，可以直接下达一些外部指令，而不必写绝对路径呢！比较方便啦！<br><br></li>
<li><span class="text_import2">主要程序部分</span><br>
就将主要的程序写好即可！在这个例子当中，就是 echo 那一行啦！<br><br></li>
<li><span class="text_import2">运行成果告知 (定义回传值)</span><br>
是否记得我们在<a href="0320bash.html">第十章</a>里面要讨论一个指令的运行成功与否，可以使用
<a href="0320bash.html#redirect_com">$?</a> 这个变量来观察～
<span class="text_import2">那么我们也可以利用 exit 这个指令来让程序中断，并且回传一个数值给系统</span>。
在我们这个例子当中，鸟哥使用 exit 0 ，这代表<span class="text_import2">离开 script 并且回传一个 0 给系统</span>，
所以我运行完这个 script 后，若接着下达 echo $? 则可得到 0 的值喔！
更聪明的读者应该也知道了，呵呵！利用这个 exit n (n 是数字) 的功能，我们还可以自订错误消息，
让这支程序变得更加的 smart 呢！</li>
</ol>
<p>接下来透过刚刚上头介绍的运行方法来运行看看结果吧！</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study bin]$ <span class="term_command">sh hello.sh</span>
Hello World !
</pre></td></tr></tbody></table>
<p>你会看到屏幕是这样，而且应该还会听到『咚』的一声，为什么呢？还记得前一章提到的
<a href="0330regularex.html#printf">printf</a> 吧？用 echo 接着那些特殊的按键也可以发生同样的事情～
不过， echo 必须要加上 -e 的选项才行！呵呵！在你写完这个小 script 之后，你就可以大声的说：『我也会写程序了』！哈哈！
很简单有趣吧～ ^_^</p>
<p>另外，你也可以利用：『chmod a+x hello.sh; ./hello.sh』来运行这个 script 的呢！</p>
<br></div><br>
<a id="script_be"></a>
<div class="block2"><div class="gototop"><a href="0340bashshell-scripts.html#top">Top</a></div>
<h2>12.1.3 撰写 shell script 的良好习惯创建</h2>
<p>一个良好习惯的养成是很重要的～大家在刚开始撰写程序的时候，最容易忽略这部分，
认为程序写出来就好了，其他的不重要。其实，如果程序的说明能够更清楚，那么对你自己是有很大的帮助的。</p>
<p>举例来说，鸟哥自己为了自己的需求，曾经撰写了不少的 script 来帮我进行主机 IP 的侦测啊、
注册表分析与管理啊、自动上传下载重要设置档啊等等的，不过，早期就是因为太懒了，
管理的主机又太多了，常常同一个程序在不同的主机上面进行更改，到最后，到底哪一支才是最新的都记不起来，
而且，重点是，我到底是改了哪里？为什么做那样的修改？都忘的一干二净～真要命～</p>
<p>所以，后来鸟哥在写程序的时候，通常会比较仔细的将程序的设计过程给他记录下来，而且还会记录一些历史纪录，
如此一来，好多了～至少很容易知道我修改了哪些数据，以及程序修改的理念与逻辑概念等等，
在维护上面是轻松很多很多的喔！</p>
<p>另外，在一些环境的设置上面，毕竟每个人的环境都不相同，为了取得较佳的运行环境，
我都会自行先定义好一些一定会被用到的环境变量，例如 PATH 这个玩意儿！
这样比较好啦～所以说，建议你一定要养成良好的 script 撰写习惯，在每个 script 的档头处记录好：</p>
<ul class="text_import2">
<li>script 的功能；</li>
<li>script 的版本信息；</li>
<li>script 的作者与联系方式；</li>
<li>script 的版权声明方式；</li>
<li>script 的 History (历史纪录)；</li>
<li>script 内较特殊的指令，使用『绝对路径』的方式来下达；</li>
<li>script 运作时需要的环境变量预先声明与设置。</li></ul>
<p>除了记录这些信息之外，在较为特殊的代码部分，个人建议务必要加上注解说明，可以帮助你非常非常多！
此外，代码的撰写最好使用嵌套方式，在<span class="text_import2">包覆的内部代码最好能以 [tab] 按键的空格向后推</span>，
这样你的代码会显的非常的漂亮与有条理！在查阅与 debug 上较为轻松愉快喔！
另外，使用<span class="text_import2">撰写 script 的工具最好使用 vim 而不是 vi</span>
，因为 vim 会有额外的语法检验机制，能够在第一阶段撰写时就发现语法方面的问题喔！</p>
<br></div><br>
</div>
<a id="some_ex"></a>
<div class="block1">
<h2>12.2 简单的 shell script 练习</h2>
<p>在第一支 shell script 撰写完毕之后，相信你应该具有基本的撰写功力了。接下来，在开始更深入的程序概念之前，我们先来玩一些简单的小范例好了。
底下的范例中，达成结果的方式相当的多，建议你先自行撰写看看，写完之后再与鸟哥写的内容比对，
这样才能更加深概念喔！好！不啰唆，我们就一个一个来玩吧！</p>
<a id="some_ex_simple"></a>
<div class="block2"><div class="gototop"><a href="0340bashshell-scripts.html#top">Top</a></div>
<h2>12.2.1 简单范例</h2>
<p>底下的范例在很多的脚本程序中都会用到，而底下的范例又都很简单！值得参考看看喔！</p>
<a id="ex_read"></a>
<ul class="toplist"><li>对谈式脚本：变量内容由用户决定</li></ul>
<p>很多时候我们需要用户输入一些内容，好让程序可以顺利运作。
简单的来说，大家应该都有安装过软件的经验，安装的时候，他不是会问你『要安装到那个目录去』吗？
那个让用户输入数据的动作，就是让用户输入变量内容啦。</p>
<p>你应该还记得在<a href="0320bash.html">十章 bash</a> 的时候，我们有学到一个
<a href="0320bash.html#read">read</a> 指令吧？现在，请你以 read 指令的用途，撰写一个
script ，他可以让用户输入：1. first name 与 2. last name，
最后并且在屏幕上显示：『Your full name is: 』的内容：</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study bin]$ <span class="term_command">vim showname.sh</span>
<span class="term_write">#!/bin/bash
# Program:
# User inputs his first name and last name. Program shows his full name.
# History:
# 2015/07/16 VBird First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
read -p "Please input your first name: " firstname <span class="term_note"># 提示用户输入</span>
read -p "Please input your last name: " lastname <span class="term_note"># 提示用户输入</span>
echo -e "\nYour full name is: ${firstname} ${lastname}" <span class="term_note"># 结果由屏幕输出</span></span>
</pre></td></tr></tbody></table>
<p>将上面这个 showname.sh 运行一下，你就能够发现用户自己输入的变量可以让程序所取用，并且将他显示到屏幕上！
接下来，如果想要制作一个每次运行都会依据不同的日期而变化结果的脚本呢？</p>
<a id="ex_date"></a>
<ul class="toplist"><li>随日期变化：利用 date 进行文件的创建</li></ul>
<p>想像一个状况，假设我的服务器内有数据库，数据库每天的数据都不太一样，因此当我备份时，希望将每天的数据都备份成不同的文件名，
这样才能够让旧的数据也能够保存下来不被覆盖。哇！不同文件名呢！这真困扰啊？难道要我每天去修改 script ？</p>
<p>不需要啊！考虑每天的『日期』并不相同，所以我可以将文件名取成类似： backup.2015-07-16.data ，
不就可以每天一个不同文件名了吗？呵呵！确实如此。那个 2015-07-16 怎么来的？那就是重点啦！接下来出个相关的例子：
假设我想要创建三个空的文件 (透过 <a href="0220filemanager.html#touch">touch</a>)
，文件名最开头由用户输入决定，假设用户输入 filename 好了，那今天的日期是 2015/07/16 ，
我想要以前天、昨天、今天的日期来创建这些文件，亦即 filename_20150714, filename_20150715, filename_20150716 ，该如何是好？</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study bin]$ <span class="term_command">vim create_3_filename.sh</span>
<span class="term_write">#!/bin/bash
# Program:
# Program creates three files, which named by user's input and date command.
# History:
# 2015/07/16 VBird First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
<span class="term_say"># 1. 让用户输入文件名称，并取得 fileuser 这个变量；</span>
echo -e "I will use 'touch' command to create 3 files." <span class="term_note"># 纯粹显示信息</span>
read -p "Please input your filename: " fileuser <span class="term_note"># 提示用户输入</span>
<span class="term_say"># 2. 为了避免用户随意按 Enter ，利用<a href="0320bash.html#variable_other_re" style="color:white">变量功能</a>分析文件名是否有设置？</span>
filename=${fileuser:-"filename"} <span class="term_note"># 开始判断有否设置文件名</span>
<span class="term_say"># 3. 开始利用 date 指令来取得所需要的文件名了；</span>
date1=$(date --date='2 days ago' +%Y%m%d) <span class="term_note"># 前两天的日期</span>
date2=$(date --date='1 days ago' +%Y%m%d) <span class="term_note"># 前一天的日期</span>
date3=$(date +%Y%m%d) <span class="term_note"># 今天的日期</span>
file1=${filename}${date1} <span class="term_note"># 底下三行在设置文件名</span>
file2=${filename}${date2}
file3=${filename}${date3}
<span class="term_say"># 4. 将文件名创建吧！</span>
touch "${file1}" <span class="term_note"># 底下三行在创建文件</span>
touch "${file2}"
touch "${file3}"</span>
</pre></td></tr></tbody></table>
<p>上面的范例鸟哥使用了很多在<a href="0320bash.html">第十章</a>介绍过的概念：
包括小指令『 $(command) 』的取得消息、变量的设置功能、变量的累加以及利用 touch 指令辅助！
如果你开始运行这个 create_3_filename.sh 之后，你可以进行两次运行：一次直接按 [Enter] 来查阅文件名是啥？
一次可以输入一些字符，这样可以判断你的脚本是否设计正确喔！</p>
<a id="ex_cal"></a>
<ul class="toplist"><li>数值运算：简单的加减乘除</li></ul>
<p>各位看官应该还记得，我们可以使用 <a href="0320bash.html#declare">declare</a> 来定义变量的类型吧？
当变量定义成为整数后才能够进行加减运算啊！此外，我们也可以利用『 $((计算式)) 』来进行数值运算的。
可惜的是， bash shell 里头缺省仅支持到整数的数据而已。OK！那我们来玩玩看，如果我们要用户输入两个变量，
然后将两个变量的内容相乘，最后输出相乘的结果，那可以怎么做？</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study bin]$ <span class="term_command">vim multiplying.sh</span>
<span class="term_write">#!/bin/bash
# Program:
# User inputs 2 integer numbers; program will cross these two numbers.
# History:
# 2015/07/16 VBird First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
echo -e "You SHOULD input 2 numbers, I will multiplying them! \n"
read -p "first number: " firstnu
read -p "second number: " secnu
total=$((${firstnu}*${secnu}))
echo -e "\nThe result of ${firstnu} x ${secnu} is ==> ${total}"</span>
</pre></td></tr></tbody></table>
<p>在数值的运算上，我们可以使用『 <span class="text_import2">declare -i total=${firstnu}*${secnu}</span> 』
也可以使用上面的方式来进行！基本上，鸟哥比较建议使用这样的方式来进行运算：</p>
<blockquote class="text_import2">var=$((运算内容))</blockquote>
<p>不但容易记忆，而且也比较方便的多，因为两个小括号内可以加上空白字符喔！
未来你可以使用这种方式来计算的呀！至于数值运算上的处理，则有：『
<span class="text_import2" style="font-family: '细明体'">+, -, *, /, %</span> 』等等。
那个 % 是取余数啦～举例来说， 13 对 3 取余数，结果是 13=4*3+1，所以余数是 1 啊！就是：</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study bin]$ <span class="term_command">echo $(( 13 % 3 ))</span>
1
</pre></td></tr></tbody></table>
<p>这样了解了吧？另外，如果你想要计算含有小数点的数据时，其实可以透过 <a href="0160startlinux.html#bc">bc</a> 这个指令的协助喔！
例如可以这样做：</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study bin]$ <span class="term_command">echo "123.123*55.9" | bc</span>
6882.575
</pre></td></tr></tbody></table>
<p>了解了 bc 的妙用之后，来让我们测试一下如何计算 pi 这个东西呢？</p>
<a id="ex_pi"></a>
<ul class="toplist"><li>数值运算：透过 bc 计算 pi</li></ul>
<p>其实计算 pi 时，小数点以下位数可以无限制的延伸下去！而 bc 有提供一个运算 pi 的函数，只是想要使用该函数必须要使用 bc -l 来调用才行。
也因为这个小数点以下位数可以无线延伸运算的特性存在，所以我们可以透过底下这只小脚本来让用户输入一个『小数点为数值』，
以让 pi 能够更准确！</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study bin]$ <span class="term_command">vim cal_pi.sh</span>
<span class="term_write">#!/bin/bash
# Program:
# User input a scale number to calculate pi number.
# History:
# 2015/07/16 VBird First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
echo -e "This program will calculate pi value. \n"
echo -e "You should input a float number to calculate pi value.\n"
read -p "The scale number (10~10000) ? " checking
num=${checking:-"10"} <span class="term_note"># 开始判断有否有输入数值</span>
echo -e "Starting calcuate pi value. Be patient."
time echo "scale=${num}; 4*a(1)" | bc -lq</span>
</pre></td></tr></tbody></table>
<p>上述数据中，那个 4*a(1) 是 bc 主动提供的一个计算 pi 的函数，至于 scale 就是要 bc 计算几个小数点下位数的意思。当 scale 的数值越大，
代表 pi 要被计算的越精确，当然用掉的时间就会越多！因此，你可以尝试输入不同的数值看看！不过，最好是不要超过 5000 啦！因为会算很久！
如果你要让你的 CPU 随时保持在高负载，这个程序算下去你就会知道有多操 CPU 啰！ ^_^</p>
<fieldset class="vbirdface"><legend style="font-family: serif; font-size:12pt; color: darkblue;">Tips</legend><img src="./vbird_files/vbird_face.gif" alt="鸟哥的图标" title="鸟哥的图标" style="float: right;"> 鸟哥的实验室中，为了要确认虚拟机的效率问题，所以很多时候需要保持虚拟机在忙碌的状态～鸟哥的学生就是丢这只程序进去系统跑！
但是将 scale 调高一些，那计算就得要花比较多时间～用以达到我们需要 CPU 忙碌的状态喔！
</fieldset><br>
</div><br>
<a id="some_ex_run"></a>
<div class="block2"><div class="gototop"><a href="0340bashshell-scripts.html#top">Top</a></div>
<h2>12.2.2 script 的运行方式差异 (source, sh script, ./script)</h2>
<p>不同的 script 运行方式会造成不一样的结果喔！尤其影响 bash 的环境很大呢！脚本的运行方式除了<a href="0340bashshell-scripts.html#script_run">前面小节谈到的方式</a>之外，还可以利用 <a href="0320bash.html#source">source</a>
或小数点 (.) 来运行喔！那么这种运行方式有何不同呢？当然是不同的啦！让我们来说说！</p>
<ul class="toplist"><li>利用直接运行的方式来运行 script</li></ul>
<p>当使用前一小节提到的直接指令下达 (不论是绝对路径/相对路径还是 ${PATH} 内)，或者是利用 bash (或 sh) 来下达脚本时，
该 script 都会使用一个新的 bash 环境来运行脚本内的指令！也就是说，使用这种运行方式时，
其实 script 是在子进程的 bash 内运行的！我们在<a href="0320bash.html">第十章 BASH</a> 内谈到
<a href="0320bash.html#export">export</a> 的功能时，曾经就父进程/子进程谈过一些概念性的问题，
重点在于：『<span class="text_import2">当子进程完成后，在子进程内的各项变量或动作将会结束而不会传回到父进程中</span>』！
这是什么意思呢？</p>
<p>我们举刚刚提到过的 showname.sh 这个脚本来说明好了，这个脚本可以让用户自行设置两个变量，分别是 firstname 与
lastname，想一想，如果你直接运行该指令时，该指令帮你设置的 firstname 会不会生效？看一下底下的运行结果：</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study bin]$ <span class="term_command">echo ${firstname} ${lastname}</span>
<span class="term_note"><==确认了，这两个变量并不存在喔！</span>
[dmtsai@study bin]$ <span class="term_command">sh showname.sh</span>
Please input your first name: <span class="term_write">VBird</span> <span class="term_note"><==这个名字是鸟哥自己输入的</span>
Please input your last name: <span class="term_write">Tsai </span>
Your full name is: <u>VBird Tsai</u> <span class="term_note"><==看吧！在 script 运作中，这两个变量有生效</span>
[dmtsai@study bin]$ <span class="term_command">echo ${firstname} ${lastname}</span>
<span class="term_note"><==事实上，这两个变量在父进程的 bash 中还是不存在的！</span>
</pre></td></tr></tbody></table>
<p>上面的结果你应该会觉得很奇怪，怎么我已经利用 showname.sh 设置好的变量竟然在 bash 环境底下无效！怎么回事呢？
如果将进程相关性绘制成图的话，我们以下图来说明。当你使用直接运行的方法来处理时，系统会给予一支新的 bash
让我们来运行 showname.sh 里面的指令，因此你的 firstname, lastname 等变量其实是在下图中的子进程 bash 内运行的。
当 showname.sh 运行完毕后，子进程 bash 内的所有数据便被移除，因此上表的练习中，在父进程底下 echo ${firstname} 时，
就看不到任何东西了！这样可以理解吗？</p>
<a id="fig12.2.1"></a>
<div style="text-align:center; margin: 0 auto 0 auto; "><img src="./vbird_files/centos7_non-source.gif" alt="showname.sh 在子进程当中运作的示意图" title="showname.sh 在子进程当中运作的示意图" style="border: 1px solid black; padding: 10px "></div>
<div style="text-align: center;">图12.2.1、showname.sh 在子进程当中运作的示意图</div>
<ul class="toplist"><li class="text_import1">利用 source 来运行脚本：在父进程中运行</li></ul>
<p>如果你使用 source 来运行指令那就不一样了！同样的脚本我们来运行看看：</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study bin]$ <span class="term_command">source showname.sh</span>
Please input your first name: <span class="term_write">VBird</span>
Please input your last name: <span class="term_write">Tsai</span>
Your full name is: <u>VBird Tsai</u>
[dmtsai@study bin]$ <span class="term_command">echo ${firstname} ${lastname}</span>
VBird Tsai <span class="term_note"><==嘿嘿！有数据产生喔！</span>
</pre></td></tr></tbody></table>
<p>竟然生效了！没错啊！因为 source 对 script 的运行方式可以使用底下的图标来说明！
showname.sh 会在父进程中运行的，因此各项动作都会在原本的 bash 内生效！这也是为啥你不注销系统而要让某些写入 ~/.bashrc
的设置生效时，需要使用『 source ~/.bashrc 』而不能使用『 bash ~/.bashrc 』是一样的啊！</p>
<a id="fig12.2.2"></a>
<div style="text-align:center; margin: 0 auto 0 auto; "><img src="./vbird_files/centos7_source.gif" alt="showname.sh 在父进程当中运作的示意图" title="showname.sh 在父进程当中运作的示意图" style="border: 1px solid black; padding: 10px "></div>
<div style="text-align: center;">图12.2.2、showname.sh 在父进程当中运作的示意图</div>
<br></div>
</div>
<a id="dis"></a>
<div class="block1">
<h2>12.3 善用判断式</h2>
<p>在第十章中，我们提到过 <a href="0320bash.html#returnvar">$?</a> 这个变量所代表的意义，
此外，也透过 <a href="0320bash.html#redirect_com">&& 及 ||</a>
来作为前一个指令运行回传值对于后一个指令是否要进行的依据。第十章的讨论中，如果想要判断一个目录是否存在，
当时我们使用的是 ls 这个指令搭配数据流重导向，最后配合 $? 来决定后续的指令进行与否。
但是否有更简单的方式可以来进行『条件判断』呢？有的～那就是『 test 』这个指令。</p>
<a id="test"></a>
<div class="block2"><div class="gototop"><a href="0340bashshell-scripts.html#top">Top</a></div>
<h2>12.3.1 利用 test 指令的测试功能</h2>
<p>当我要检测系统上面某些文件或者是相关的属性时，利用 test 这个指令来工作真是好用得不得了，
举例来说，我要检查 /dmtsai 是否存在时，使用：</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study ~]$ <span class="term_command">test -e /dmtsai</span>
</pre></td></tr></tbody></table>
<p>运行结果并不会显示任何消息，但最后我们可以透过 $? 或 && 及 || 来展现整个结果呢！
例如我们在将上面的例子改写成这样：</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study ~]$ <span class="term_command">test -e /dmtsai && echo "exist" || echo "Not exist"</span>
Not exist <span class="term_note"><==结果显示不存在啊！</span>
</pre></td></tr></tbody></table>
<p>最终的结果可以告知我们是『exist』还是『Not exist』呢！那我知道 -e 是测试一个『东西』在不在，
如果还想要测试一下该文件名是啥玩意儿时，还有哪些标志可以来判断的呢？呵呵！有底下这些东西喔！</p>
<table class="news" style="width: 95%; font-family: '细明体'">
<tbody><tr class="theader"><td style="width: 140px">测试的标志</td><td>代表意义</td></tr>
<tr style="background-color: lightblue"><td colspan="2">1. 关于某个文件名的『文件类型』判断，如 test -e filename 表示存在否</td></tr>
<tr><td class="tcenter">-e</td><td>该『文件名』是否存在？(常用)</td></tr>
<tr><td class="tcenter">-f</td><td>该『文件名』是否存在且为文件(file)？(常用)</td></tr>
<tr><td class="tcenter">-d</td><td>该『文件名』是否存在且为目录(directory)？(常用)</td></tr>
<tr><td class="tcenter">-b</td><td>该『文件名』是否存在且为一个 block device 设备？</td></tr>
<tr><td class="tcenter">-c</td><td>该『文件名』是否存在且为一个 character device 设备？</td></tr>
<tr><td class="tcenter">-S</td><td>该『文件名』是否存在且为一个 Socket 文件？</td></tr>
<tr><td class="tcenter">-p</td><td>该『文件名』是否存在且为一个 FIFO (pipe) 文件？</td></tr>
<tr><td class="tcenter">-L</td><td>该『文件名』是否存在且为一个链接档？</td></tr>
<tr style="background-color: lightblue"><td colspan="2">2. 关于文件的权限侦测，如 test -r filename 表示可读否 (但 root 权限常有例外)</td></tr>
<tr><td class="tcenter">-r</td><td>侦测该文件名是否存在且具有『可读』的权限？</td></tr>
<tr><td class="tcenter">-w</td><td>侦测该文件名是否存在且具有『可写』的权限？</td></tr>
<tr><td class="tcenter">-x</td><td>侦测该文件名是否存在且具有『可运行』的权限？</td></tr>
<tr><td class="tcenter">-u</td><td>侦测该文件名是否存在且具有『SUID』的属性？</td></tr>
<tr><td class="tcenter">-g</td><td>侦测该文件名是否存在且具有『SGID』的属性？</td></tr>
<tr><td class="tcenter">-k</td><td>侦测该文件名是否存在且具有『Sticky bit』的属性？</td></tr>
<tr><td class="tcenter">-s</td><td>侦测该文件名是否存在且为『非空白文件』？</td></tr>
<tr style="background-color: lightblue"><td colspan="2">3. 两个文件之间的比较，如： test file1 -nt file2</td></tr>
<tr><td class="tcenter">-nt</td><td>(newer than)判断 file1 是否比 file2 新</td></tr>
<tr><td class="tcenter">-ot</td><td>(older than)判断 file1 是否比 file2 旧</td></tr>
<tr><td class="tcenter">-ef</td><td>判断 file1 与 file2 是否为同一文件，可用在判断 hard link 的判定上。
主要意义在判定，两个文件是否均指向同一个 inode 哩！</td></tr>
<tr style="background-color: lightblue"><td colspan="2">4. 关于两个整数之间的判定，例如 test n1 -eq n2</td></tr>
<tr><td class="tcenter">-eq</td><td>两数值相等 (equal)</td></tr>
<tr><td class="tcenter">-ne</td><td>两数值不等 (not equal)</td></tr>
<tr><td class="tcenter">-gt</td><td>n1 大于 n2 (greater than)</td></tr>
<tr><td class="tcenter">-lt</td><td>n1 小于 n2 (less than)</td></tr>
<tr><td class="tcenter">-ge</td><td>n1 大于等于 n2 (greater than or equal)</td></tr>
<tr><td class="tcenter">-le</td><td>n1 小于等于 n2 (less than or equal)</td></tr>
<tr style="background-color: lightblue"><td colspan="2">5. 判定字符串的数据</td></tr>
<tr><td class="tcenter">test -z string</td><td>判定字符串是否为 0 ？若 string 为空字符串，则为 true</td></tr>
<tr><td class="tcenter">test -n string</td><td>判定字符串是否非为 0 ？若 string 为空字符串，则为 false。<br>注： -n 亦可省略</td></tr>
<tr><td class="tcenter">test str1 == str2</td><td>判定 str1 是否等于 str2 ，若相等，则回传 true</td></tr>
<tr><td class="tcenter">test str1 != str2</td><td>判定 str1 是否不等于 str2 ，若相等，则回传 false</td></tr>
<tr style="background-color: lightblue"><td colspan="2">6. 多重条件判定，例如： test -r filename -a -x filename</td></tr>
<tr><td class="tcenter">-a</td><td>(and)两状况同时成立！例如 test -r file -a -x file，则 file 同时具有 r 与
x 权限时，才回传 true。</td></tr>
<tr><td class="tcenter">-o</td><td>(or)两状况任何一个成立！例如 test -r file -o -x file，则 file 具有 r 或
x 权限时，就可回传 true。</td></tr>
<tr><td class="tcenter">!</td><td>反相状态，如 test ! -x file ，当 file 不具有 x 时，回传 true</td></tr>
</tbody></table>
<p>OK！现在我们就利用 test 来帮我们写几个简单的例子。首先，判断一下，让用户输入一个文件名，我们判断：</p>
<ol>
<li>这个文件是否存在，若不存在则给予一个『Filename does not exist』的消息，并中断程序；</li>
<li>若这个文件存在，则判断他是个文件或目录，结果输出『Filename is regular file』或
『Filename is directory』</li>
<li>判断一下，运行者的身份对这个文件或目录所拥有的权限，并输出权限数据！</li>
</ol>
<p>你可以先自行创作看看，然后再跟底下的结果讨论讨论。注意利用 test 与 && 还有 || 等标志！</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study bin]$ <span class="term_command">vim file_perm.sh</span>
<span class="term_write">#!/bin/bash
# Program:
# User input a filename, program will check the flowing:
# 1.) exist? 2.) file/directory? 3.) file permissions
# History:
# 2015/07/16 VBird First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
<span class="term_say"># 1. 让用户输入文件名，并且判断用户是否真的有输入字符串？</span>
echo -e "Please input a filename, I will check the filename's type and permission. \n\n"
read -p "Input a filename : " filename
test -z ${filename} && echo "You MUST input a filename." && exit 0
<span class="term_say"># 2. 判断文件是否存在？若不存在则显示消息并结束脚本</span>
test ! -e ${filename} && echo "The filename '${filename}' DO NOT exist" && exit 0
<span class="term_say"># 3. 开始判断文件类型与属性</span>
test -f ${filename} && filetype="regulare file"
test -d ${filename} && filetype="directory"
test -r ${filename} && perm="readable"
test -w ${filename} && perm="${perm} writable"
test -x ${filename} && perm="${perm} executable"
<span class="term_say"># 4. 开始输出信息！</span>
echo "The filename: ${filename} is a ${filetype}"
echo "And the permissions for you are : ${perm}"</span>
</pre></td></tr></tbody></table>
<p>如果你运行这个脚本后，他会依据你输入的文件名来进行检查喔！先看是否存在，再看为文件或目录类型，最后判断权限。
但是你必须要注意的是，<span class="text_import2">由于 root 在很多权限的限制上面都是无效的，所以使用 root 运行这个脚本时，
常常会发现与 ls -l 观察到的结果并不相同</span>！所以，建议使用一般用户来运行这个脚本试看看。</p>
<br></div><br>
<a id="test_2"></a>
<div class="block2"><div class="gototop"><a href="0340bashshell-scripts.html#top">Top</a></div>
<h2>12.3.2 利用判断符号 [ ]</h2>
<p>除了我们很喜欢使用的 test 之外，其实，我们还可以利用判断符号『 [ ] 』(就是中括号啦) 来进行数据的判断呢！
举例来说，如果我想要知道 ${HOME} 这个变量是否为空的，可以这样做：</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study ~]$ <span class="term_command">[ -z "${HOME}" ] ; echo $?</span>
</pre></td></tr></tbody></table>
<p>使用中括号必须要特别注意，因为中括号用在很多地方，包括通配符与正规表示法等等，所以如果要在 bash
的语法当中使用中括号作为 shell 的判断式时，必须要注意<span class="text_import2">中括号的两端需要有空白字符来分隔喔</span>！
假设我空白键使用『□』符号来表示，那么，在这些地方你都需要有空白键：</p>
<table class="term"><tbody><tr><td class="term"><pre>[ "$HOME" == "$MAIL" ]
[□"$HOME"□==□"$MAIL"□]
↑ ↑ ↑ ↑
</pre></td></tr></tbody></table>
<fieldset class="vbirdface"><legend style="font-family: serif; font-size:12pt; color: darkblue;">Tips</legend><img src="./vbird_files/vbird_face.gif" alt="鸟哥的图标" title="鸟哥的图标" style="float: right;"> 你会发现鸟哥在上面的判断式当中使用了两个等号『 == 』。其实在 bash 当中使用一个等号与两个等号的结果是一样的！
不过在一般惯用程序的写法中，一个等号代表『变量的设置』，两个等号则是代表『逻辑判断 (是与否之意)』。
由于我们在中括号内重点在于『判断』而非『设置变量』，因此鸟哥建议您还是使用两个等号较佳！
</fieldset><br>
<p>上面的例子在说明，两个字符串 ${HOME} 与 ${MAIL} 是否相同的意思，相当于 test ${HOME} == ${MAIL} 的意思啦！
而如果没有空白分隔，例如 [${HOME}==${MAIL}] 时，我们的 bash 就会显示错误消息了！这可要很注意啊！
所以说，你最好要注意：</p>
<ul class="text_import2" style="font-family: '细明体'">
<li>在中括号 [] 内的每个组件都需要有空白键来分隔；</li>
<li>在中括号内的变量，最好都以双引号括号起来；</li>
<li>在中括号内的常数，最好都以单或双引号括号起来。</li>
</ul>
<p>为什么要这么麻烦啊？直接举例来说，假如我设置了 name="VBird Tsai" ，然后这样判定：</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study ~]$ <span class="term_command">name="VBird Tsai"</span>
[dmtsai@study ~]$ <span class="term_command">[ ${name} == "VBird" ]</span>
bash: [: too many arguments
</pre></td></tr></tbody></table>
<p>见鬼了！怎么会发生错误啊？bash 还跟我说错误是由于『太多参数 (arguments)』所致！
为什么呢？因为 ${name} 如果没有使用双引号刮起来，那么上面的判定式会变成：</p>
<blockquote class="text_import2" style="font-family: '细明体'">[ VBird Tsai == "VBird" ] </blockquote>
<p>上面肯定不对嘛！因为一个判断式仅能有两个数据的比对，上面 VBird 与 Tsai 还有 "VBird" 就有三个数据！
这不是我们要的！我们要的应该是底下这个样子：</p>
<blockquote class="text_import2" style="font-family: '细明体'">[ "VBird Tsai" == "VBird" ] </blockquote>
<p>这可是差很多的喔！另外，中括号的使用方法与 test 几乎一模一样啊～
只是中括号比较常用在<a href="0340bashshell-scripts.html#rule">条件判断式 if ..... then ..... fi</a> 的情况中就是了。
好，那我们也使用中括号的判断来做一个小案例好了，案例设置如下：</p>
<ol>
<li>当运行一个程序的时候，这个程序会让用户选择 Y 或 N ，</li>
<li>如果用户输入 Y 或 y 时，就显示『 OK, continue 』</li>
<li>如果用户输入 n 或 N 时，就显示『 Oh, interrupt ！』</li>
<li>如果不是 Y/y/N/n 之内的其他字符，就显示『 I don't know what your choice is 』</li>
</ol>
利用中括号、 && 与 || 来继续吧！<br>
<a id="sh06"></a>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study bin]$ <span class="term_command">vim ans_yn.sh</span>
<span class="term_write">#!/bin/bash
# Program:
# This program shows the user's choice
# History:
# 2015/07/16 VBird First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
read -p "Please input (Y/N): " yn
[ "${yn}" == "Y" -o "${yn}" == "y" ] && echo "OK, continue" && exit 0
[ "${yn}" == "N" -o "${yn}" == "n" ] && echo "Oh, interrupt!" && exit 0
echo "I don't know what your choice is" && exit 0</span>
</pre></td></tr></tbody></table>
<p>由于输入正确 (Yes) 的方法有大小写之分，不论输入大写 Y 或小写 y 都是可以的，此时判断式内就得要有两个判断才行！
由于是任何一个成立即可 (大写或小写的 y) ，所以这里使用 -o (或) 链接两个判断喔！
很有趣吧！利用这个字符串判别的方法，我们就可以很轻松的将用户想要进行的工作分门别类呢！
接下来，我们再来谈一些其他有的没有的东西吧！</p>
<br></div><br>
<a id="dis3"></a>
<div class="block2"><div class="gototop"><a href="0340bashshell-scripts.html#top">Top</a></div>
<h2>12.3.3 Shell script 的缺省变量($0, $1...)</h2>
<p>我们知道指令可以带有选项与参数，例如 ls -la 可以察看包含隐藏档的所有属性与权限。那么 shell script
能不能在脚本文件名后面带有参数呢？很有趣喔！举例来说，如果你想要重新启动系统的网络，可以这样做：</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study ~]$ <span class="term_command">file /etc/init.d/network</span>
/etc/init.d/network: Bourne-Again shell script, ASCII text executable
<span class="term_say"># 使用 file 来查找后，系统告知这个文件是个 bash 的可运行 script 喔！</span>
[dmtsai@study ~]$ <span class="term_command">/etc/init.d/network restart</span>
</pre></td></tr></tbody></table>
<p>restart 是重新启动的意思，上面的指令可以『重新启动 /etc/init.d/network 这支程序』的意思！
唔！那么如果你在 /etc/init.d/network 后面加上 stop 呢？没错！就可以直接关闭该服务了！这么神奇啊？
没错啊！如果你要依据程序的运行给予一些变量去进行不同的任务时，本章一开始是使用 <a href="0340bashshell-scripts.html#ex_read">read</a>
的功能！但 read 功能的问题是你得要手动由键盘输入一些判断式。如果透过指令后面接参数，
那么一个指令就能够处理完毕而不需要手动再次输入一些变量行为！这样下达指令会比较简单方便啦！</p>
<p>script 是怎么达成这个功能的呢？其实 script 针对参数已经有设置好一些变量名称了！对应如下：</p>
<table class="term"><tbody><tr><td class="term"><pre><span class="term_write">/path/to/scriptname opt1 opt2 opt3 opt4
$0 $1 $2 $3 $4</span>
</pre></td></tr></tbody></table>
<p>这样够清楚了吧？运行的脚本文件名为 $0 这个变量，第一个接的参数就是 $1 啊～
所以，只要我们在 script 里面善用 $1 的话，就可以很简单的立即下达某些指令功能了！除了这些数字的变量之外，
我们还有一些较为特殊的变量可以在 script 内使用来调用这些参数喔！</p>
<ul class="text_import2" style="font-family:'细明体'">
<li>$# ：代表后接的参数『个数』，以上表为例这里显示为『 4 』；</li>
<li>$@ ：代表『 "$1" "$2" "$3" "$4" 』之意，每个变量是独立的(用双引号括起来)；</li>
<li>$* ：代表『 "$1<u>c</u>$2<u>c</u>$3<u>c</u>$4" 』，其中 <u>c</u> 为分隔字符，缺省为空白键，
所以本例中代表『 "$1 $2 $3 $4" 』之意。</li>
</ul>
<p>那个 $@ 与 $* 基本上还是有所不同啦！不过，一般使用情况下可以直接记忆 $@ 即可！
好了，来做个例子吧～假设我要运行一个可以携带参数的 script ，运行该脚本后屏幕会显示如下的数据：</p>
<ul>
<li>程序的文件名为何？</li>
<li>共有几个参数？</li>
<li>若参数的个数小于 2 则告知用户参数数量太少</li>
<li>全部的参数内容为何？</li>
<li>第一个参数为何？</li>
<li>第二个参数为何</li>
</ul>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study bin]$ <span class="term_command">vim how_paras.sh</span>
<span class="term_write">#!/bin/bash
# Program:
# Program shows the script name, parameters...
# History:
# 2015/07/16 VBird First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
echo "The script name is ==> ${0}"
echo "Total parameter number is ==> $#"
[ "$#" -lt 2 ] && echo "The number of parameter is less than 2. Stop here." && exit 0
echo "Your whole parameter is ==> '$@'"
echo "The 1st parameter ==> ${1}"
echo "The 2nd parameter ==> ${2}"</span>
</pre></td></tr></tbody></table>
<p>运行结果如下：</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study bin]$ <span class="term_command">sh how_paras.sh theone haha quot</span>
The script name is ==> how_paras.sh <span class="term_note"><==文件名</span>
Total parameter number is ==> 3 <span class="term_note"><==果然有三个参数</span>
Your whole parameter is ==> 'theone haha quot' <span class="term_note"><==参数的内容全部</span>
The 1st parameter ==> theone <span class="term_note"><==第一个参数</span>
The 2nd parameter ==> haha <span class="term_note"><==第二个参数</span>
</pre></td></tr></tbody></table>
<a id="shift"></a>
<ul class="toplist"><li>shift：造成参数变量号码偏移</li></ul>
<p>除此之外，脚本后面所接的变量是否能够进行偏移 (shift) 呢？什么是偏移啊？我们直接以底下的范例来说明好了，
用范例说明比较好解释！我们将 how_paras.sh 的内容稍作变化一下，用来显示每次偏移后参数的变化情况：</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study bin]$ <span class="term_command">vim shift_paras.sh</span>
<span class="term_write">#!/bin/bash
# Program:
# Program shows the effect of shift function.
# History:
# 2009/02/17 VBird First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
echo "Total parameter number is ==> $#"
echo "Your whole parameter is ==> '$@'"
shift <span class="term_note"># 进行第一次『一个变量的 shift 』</span>
echo "Total parameter number is ==> $#"
echo "Your whole parameter is ==> '$@'"
shift 3 <span class="term_note"># 进行第二次『三个变量的 shift 』</span>
echo "Total parameter number is ==> $#"
echo "Your whole parameter is ==> '$@'"</span>
</pre></td></tr></tbody></table>
<p>这玩意的运行成果如下：</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study bin]$ <span class="term_command">sh shift_paras.sh one two three four five six</span> <span class="term_note"><==给予六个参数</span>
Total parameter number is ==> 6 <span class="term_note"><==最原始的参数变量情况</span>
Your whole parameter is ==> 'one two three four five six'
Total parameter number is ==> 5 <span class="term_note"><==第一次偏移，看底下发现第一个 one 不见了</span>
Your whole parameter is ==> 'two three four five six'
Total parameter number is ==> 2 <span class="term_note"><==第二次偏移掉三个，two three four 不见了</span>
Your whole parameter is ==> 'five six'
</pre></td></tr></tbody></table>
<p>光看结果你就可以知道啦，那个 shift 会移动变量，而且 shift 后面可以接数字，代表拿掉最前面的几个参数的意思。
上面的运行结果中，第一次进行 shift 后他的显示情况是『 <span style="text-decoration: line-through">one</span> two three
four five six』，所以就剩下五个啦！第二次直接拿掉三个，就变成『
<span style="text-decoration: line-through">two three four</span> five six 』啦！
这样这个案例可以了解了吗？理解了 shift 的功能了吗？</p>
<p>上面这几个例子都很简单吧？几乎都是利用 bash 的相关功能而已～
不难啦～底下我们就要使用条件判断式来进行一些分别功能的设置了，好好瞧一瞧先～</p>
<br></div>
</div>
<a id="rule"></a>
<div class="block1">
<h2>12.4 条件判断式</h2>
<p>只要讲到『程序』的话，那么条件判断式，亦即是『 if then 』这种判别式肯定一定要学习的！
因为很多时候，我们都必须要依据某些数据来判断程序该如何进行。举例来说，我们在上头的 <a href="0340bashshell-scripts.html#sh06">ans_yn.sh</a>
讨论输入回应的范例中不是有练习当用户输入 Y/N 时，必须要运行不同的消息输出吗？简单的方式可以利用 && 与
|| ，但如果我还想要运行一堆指令呢？那真的得要 if then 来帮忙啰～底下我们就来聊一聊！</p>
<a id="ifthen"></a>
<div class="block2"><div class="gototop"><a href="0340bashshell-scripts.html#top">Top</a></div>
<h2>12.4.1 利用 if .... then</h2>
<p>这个 if .... then 是最常见的条件判断式了～简单的说，就是当符合某个条件判断的时候，
就予以进行某项工作就是了。这个 if ... then 的判断还有多层次的情况！我们分别介绍如下：</p>
<a id="ifthen_simple"></a>
<ul class="toplist"><li>单层、简单条件判断式</li></ul>
<p>如果你只有一个判断式要进行，那么我们可以简单的这样看：</p>
<table class="term"><tbody><tr><td class="term"><pre><span class="term_command">if [</span> 条件判断式 <span class="term_command">]; then</span>
当条件判断式成立时，可以进行的指令工作内容；
<span class="term_command">fi</span> <span class="term_note"><==将 if 反过来写，就成为 fi 啦！结束 if 之意！</span>
</pre></td></tr></tbody></table>
<p>至于条件判断式的判断方法，与前一小节的介绍相同啊！较特别的是，如果我有多个条件要判别时，
除了 <a href="0340bashshell-scripts.html#sh06">ans_yn.sh</a> 那个案例所写的，也就是『将多个条件写入一个中括号内的情况』之外，
我还可以有多个中括号来隔开喔！而括号与括号之间，则以 && 或 || 来隔开，他们的意义是：</p>
<ul class="text_import2" style="font-family:'细明体'">
<li>&& 代表 AND ；</li>
<li>|| 代表 or ；</li>
</ul>
<p>所以，在使用中括号的判断式中， && 及 || 就与指令下达的状态不同了。举例来说，
ans_yn.sh 里面的判断式可以这样修改：</p>
<blockquote style="font-family:'细明体'">
[ "${yn}" == "Y" -o "${yn}" == "y" ]<br>上式可替换为<br>
[ "${yn}" == "Y" ] || [ "${yn}" == "y" ]</blockquote>
<p>之所以这样改，很多人是习惯问题！很多人则是喜欢一个中括号仅有一个判别式的原因。好了，
现在我们来将 ans_yn.sh 这个脚本修改成为 if ... then 的样式来看看：</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study bin]$ <span class="term_command">cp ans_yn.sh ans_yn-2.sh</span> <span class="term_note"><==用复制来修改的比较快！</span>
[dmtsai@study bin]$ <span class="term_command">vim ans_yn-2.sh</span>
<span class="term_write">#!/bin/bash
# Program:
# This program shows the user's choice
# History:
# 2015/07/16 VBird First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
read -p "Please input (Y/N): " yn
if [ "${yn}" == "Y" ] || [ "${yn}" == "y" ]; then
echo "OK, continue"
exit 0
fi
if [ "${yn}" == "N" ] || [ "${yn}" == "n" ]; then
echo "Oh, interrupt!"
exit 0
fi
echo "I don't know what your choice is" && exit 0</span>
</pre></td></tr></tbody></table>
<p>不过，由这个例子看起来，似乎也没有什么了不起吧？原本的 ans_yn.sh 还比较简单呢～
但是如果以逻辑概念来看，其实上面的范例中，我们使用了两个条件判断呢！明明仅有一个 ${yn} 的变量，为何需要进行两次比对呢？
此时，多重条件判断就能够来测试测试啰！</p>
<a id="ifthen_multi"></a>
<ul class="toplist"><li>多重、复杂条件判断式</li></ul>
<p>在同一个数据的判断中，如果该数据需要进行多种不同的判断时，应该怎么作？举例来说，上面的
<a href="0340bashshell-scripts.html#sh06">ans_yn.sh</a> 脚本中，我们只要进行一次 ${yn} 的判断就好 (仅进行一次 if )，不想要作多次 if 的判断。
此时你就得要知道底下的语法了：</p>
<table class="term"><tbody><tr><td class="term"><pre><span class="term_hd"># 一个条件判断，分成功进行与失败进行 (else)</span>
<span class="term_command">if [</span> 条件判断式 <span class="term_command">]; then</span>
当条件判断式成立时，可以进行的指令工作内容；
<span class="term_command">else</span>
当条件判断式不成立时，可以进行的指令工作内容；
<span class="term_command">fi</span>
</pre></td></tr></tbody></table>
<p>如果考虑更复杂的情况，则可以使用这个语法：</p>
<table class="term"><tbody><tr><td class="term"><pre><span class="term_hd"># 多个条件判断 (if ... elif ... elif ... else) 分多种不同情况运行</span>
<span class="term_command">if [</span> 条件判断式一 <span class="term_command">]; then</span>
当条件判断式一成立时，可以进行的指令工作内容；
<span class="term_command">elif [</span> 条件判断式二 <span class="term_command">]; then</span>
当条件判断式二成立时，可以进行的指令工作内容；
<span class="term_command">else</span>
当条件判断式一与二均不成立时，可以进行的指令工作内容；
<span class="term_command">fi</span>
</pre></td></tr></tbody></table>
<p>你得要注意的是， elif 也是个判断式，因此出现 elif 后面都要接 then 来处理！但是 else 已经是最后的没有成立的结果了，
所以 else 后面并没有 then 喔！好！我们来将 ans_yn-2.sh 改写成这样：</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study bin]$ <span class="term_command">cp ans_yn-2.sh ans_yn-3.sh</span>
[dmtsai@study bin]$ <span class="term_command">vim ans_yn-3.sh</span>
<span class="term_write">#!/bin/bash
# Program:
# This program shows the user's choice
# History:
# 2015/07/16 VBird First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
read -p "Please input (Y/N): " yn
if [ "${yn}" == "Y" ] || [ "${yn}" == "y" ]; then
echo "OK, continue"
elif [ "${yn}" == "N" ] || [ "${yn}" == "n" ]; then
echo "Oh, interrupt!"
else
echo "I don't know what your choice is"
fi</span>
</pre></td></tr></tbody></table>
<p>是否程序变得很简单，而且依序判断，可以避免掉重复判断的状况，这样真的很容易设计程序的啦！ ^_^！
好了，让我们再来进行另外一个案例的设计。一般来说，如果你不希望用户由键盘输入额外的数据时，
可以使用<a href="0340bashshell-scripts.html#dis3">上一节提到的参数功能 ($1)</a>！让用户在下达指令时就将参数带进去！
现在我们想让用户输入『 hello 』这个关键字时，利用参数的方法可以这样依序设计：</p>
<a id="check_1"></a>
<ol>
<li>判断 $1 是否为 hello，如果是的话，就显示 "Hello, how are you ?"；</li>
<li>如果没有加任何参数，就提示用户必须要使用的参数下达法；</li>
<li>而如果加入的参数不是 hello ，就提醒用户仅能使用 hello 为参数。</li>
</ol>
<p>整个程序的撰写可以是这样的：</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study bin]$ <span class="term_command">vim hello-2.sh</span>
<span class="term_write">#!/bin/bash
# Program:
# Check $1 is equal to "hello"
# History:
# 2015/07/16 VBird First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
if [ "${1}" == "hello" ]; then
echo "Hello, how are you ?"
elif [ "${1}" == "" ]; then
echo "You MUST input parameters, ex> {${0} someword}"
else
echo "The only parameter is 'hello', ex> {${0} hello}"
fi</span>
</pre></td></tr></tbody></table>
<p>然后你可以运行这支程序，分别在 $1 的位置输入 hello, 没有输入与随意输入，
就可以看到不同的输出啰～是否还觉得挺简单的啊！ ^_^。事实上，
学到这里，也真的很厉害了～好了，底下我们继续来玩一些比较大一点的计划啰～</p>
<a id="netstat"></a>
<p>我们在第十章已经学会了 <a href="0320bash.html#grep">grep</a>
这个好用的玩意儿，那么多学一个叫做 netstat 的指令，这个指令可以查找到目前主机有开启的网络服务端口口 (service ports)，
相关的功能我们会在<a href="http://linux.vbird.org/linux_server">服务器架设篇</a>继续介绍，这里你只要知道，我可以利用『
<span class="text_import2">netstat -tuln</span> 』来取得目前主机有启动的服务，
而且取得的信息有点像这样：</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study ~]$ <span class="term_command">netstat -tuln</span>
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address Foreign Address State
tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN
tcp 0 0 127.0.0.1:25 0.0.0.0:* LISTEN
tcp6 0 0 :::22 :::* LISTEN
tcp6 0 0 ::1:25 :::* LISTEN
udp 0 0 0.0.0.0:123 0.0.0.0:*
udp 0 0 0.0.0.0:5353 0.0.0.0:*
udp 0 0 0.0.0.0:44326 0.0.0.0:*
udp 0 0 127.0.0.1:323 0.0.0.0:*
udp6 0 0 :::123 :::*
udp6 0 0 ::1:323 :::*
<span class="term_say">#封包格式 本地IP:端口口 远程IP:端口口 是否监听</span>
</pre></td></tr></tbody></table>
<p>上面的重点是『Local Address (本地主机的IP与端口口对应)』那个字段，他代表的是本机所启动的网络服务！
IP的部分说明的是该服务位于那个接口上，若为 127.0.0.1 则是仅针对本机开放，若是 0.0.0.0 或 :::
则代表对整个 Internet 开放 (更多信息请参考服务器架设篇的介绍)。
每个端口口 (port) 都有其特定的网络服务，几个常见的 port 与相关网络服务的关系是：</p>
<ul class="text_import2" style="font-family:'细明体'">
<li>80: WWW</li>
<li>22: ssh</li>
<li>21: ftp</li>
<li>25: mail</li>
<li>111: RPC(远程进程调用)</li>
<li>631: CUPS(打印服务功能)</li>
</ul>
<p>假设我的主机有兴趣要侦测的是比较常见的 port 21, 22, 25及 80 时，那我如何透过 netstat
去侦测我的主机是否有开启这四个主要的网络服务端口口呢？由于每个服务的关键字都是接在冒号『 : 』后面，
所以可以借由截取类似『 :80 』来侦测的！那我就可以简单的这样去写这个程序喔：</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study bin]$ <span class="term_command">vim netstat.sh</span>
<span class="term_write">#!/bin/bash
# Program:
# Using netstat and grep to detect WWW,SSH,FTP and Mail services.
# History:
# 2015/07/16 VBird First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
<span class="term_say"># 1. 先作一些告知的动作而已～</span>
echo "Now, I will detect your Linux server's services!"
echo -e "The www, ftp, ssh, and mail(smtp) will be detect! \n"
<span class="term_say"># 2. 开始进行一些测试的工作，并且也输出一些信息啰！</span>
testfile=/dev/shm/netstat_checking.txt
netstat -tuln > ${testfile} <span class="term_note"># 先转存数据到内存当中！不用一直运行 netstat</span>
testing=$(grep ":80 " ${testfile}) <span class="term_note"># 侦测看 port 80 在否？</span>
if [ "${testing}" != "" ]; then
echo "WWW is running in your system."
fi
testing=$(grep ":22 " ${testfile}) <span class="term_note"># 侦测看 port 22 在否？</span>
if [ "${testing}" != "" ]; then
echo "SSH is running in your system."
fi
testing=$(grep ":21 " ${testfile}) <span class="term_note"># 侦测看 port 21 在否？</span>
if [ "${testing}" != "" ]; then
echo "FTP is running in your system."
fi
testing=$(grep ":25 " ${testfile}) <span class="term_note"># 侦测看 port 25 在否？</span>
if [ "${testing}" != "" ]; then
echo "Mail is running in your system."
fi</span>
</pre></td></tr></tbody></table>
<a id="retire"></a>
<p>实际运行这支程序你就可以看到你的主机有没有启动这些服务啦！是否很有趣呢？
条件判断式还可以搞的更复杂！举例来说，在台湾当兵是国民应尽的义务，不过，在当兵的时候总是很想要退伍的！
那你能不能写个脚本程序来跑，让用户输入他的退伍日期，让你去帮他计算还有几天才退伍？</p>
<p>由于日期是要用相减的方式来处置，所以我们可以透过使用 date 显示日期与时间，将他转为由 1970-01-01 累积而来的秒数，
透过秒数相减来取得剩余的秒数后，再换算为日数即可。整个脚本的制作流程有点像这样：</p>
<ol>
<li>先让用户输入他们的退伍日期；</li>
<li>再由现在日期比对退伍日期；</li>
<li>由两个日期的比较来显示『还需要几天』才能够退伍的字样。</li>
</ol>
<p>似乎挺难的样子？其实也不会啦，利用『 <span class="text_import2">date --date="YYYYMMDD"
+%s</span> 』转成秒数后，接下来的动作就容易的多了！如果你已经写完了程序，对照底下的写法试看看：</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study bin]$ <span class="term_command">vim cal_retired.sh</span>
<span class="term_write">#!/bin/bash
# Program:
# You input your demobilization date, I calculate how many days before you demobilize.
# History:
# 2015/07/16 VBird First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
<span class="term_say"># 1. 告知用户这支程序的用途，并且告知应该如何输入日期格式？</span>
echo "This program will try to calculate :"
echo "How many days before your demobilization date..."
read -p "Please input your demobilization date (YYYYMMDD ex>20150716): " date2
<span class="term_say"># 2. 测试一下，这个输入的内容是否正确？利用正规表示法啰～</span>
date_d=$(echo ${date2} |grep '[0-9]\{8\}') <span class="term_note"># 看看是否有八个数字</span>
if [ "${date_d}" == "" ]; then
echo "You input the wrong date format...."
exit 1
fi
<span class="term_say"># 3. 开始计算日期啰～</span>
declare -i date_dem=$(date --date="${date2}" +%s) <span class="term_note"># 退伍日期秒数</span>
declare -i date_now=$(date +%s) <span class="term_note"># 现在日期秒数</span>
declare -i date_total_s=$((${date_dem}-${date_now})) <span class="term_note"># 剩余秒数统计</span>
declare -i date_d=$((${date_total_s}/60/60/24)) <span class="term_note"># 转为日数</span>
if [ "${date_total_s}" -lt "0" ]; then <span class="term_note"># 判断是否已退伍</span>
echo "You had been demobilization before: " $((-1*${date_d})) " ago"
else
declare -i date_h=$(($((${date_total_s}-${date_d}*60*60*24))/60/60))
echo "You will demobilize after ${date_d} days and ${date_h} hours."
fi</span>
</pre></td></tr></tbody></table>
<p>瞧一瞧，这支程序可以帮你计算退伍日期呢～如果是已经退伍的朋友，
还可以知道已经退伍多久了～哈哈！很可爱吧～脚本中的 date_d 变量声明那个 /60/60/24
是来自于一天的总秒数 (24小时*60分*60秒) 。瞧～全部的动作都没有超出我们所学的范围吧～ ^_^
还能够避免用户输入错误的数字，所以多了一个正规表示法的判断式呢～
这个例子比较难，有兴趣想要一探究竟的朋友，可以作一下<a href="0340bashshell-scripts.html#ex">课后练习题</a>
关于计算生日的那一题喔！～加油！</p>
<br></div><br>
<a id="case"></a>
<div class="block2"><div class="gototop"><a href="0340bashshell-scripts.html#top">Top</a></div>
<h2>12.4.2 利用 case ..... esac 判断</h2>
<p>上个小节提到的『 if .... then .... fi 』对于变量的判断是以『比对』的方式来分辨的，
如果符合状态就进行某些行为，并且透过较多层次 (就是 elif ...) 的方式来进行多个变量的代码撰写，譬如
<a href="0340bashshell-scripts.html#check_1">hello-2.sh</a> 那个小程序，就是用这样的方式来撰写的啰。
好，那么万一我有多个既定的变量内容，例如 hello-2.sh 当中，我所需要的变量就是 "hello" 及空字符串两个，
那么我只要针对这两个变量来设置状况就好了，对吧？那么可以使用什么方式来设计呢？呵呵～就用
case ... in .... esac 吧～，他的语法如下：</p>
<table class="term"><tbody><tr><td class="term"><pre><span class="term_command">case $</span>变量名称 <span class="term_command">in</span> <span class="term_note"><==关键字为 case ，还有变量前有钱字号</span>
"第一个变量内容"<span class="term_command">)</span> <span class="term_note"><==每个变量内容建议用双引号括起来，关键字则为小括号 )</span>
程序段
<span class="term_command">;;</span> <span class="term_note"><==每个类别结尾使用两个连续的分号来处理！</span>
"第二个变量内容"<span class="term_command">)</span>
程序段
<span class="term_command">;;</span>
*<span class="term_command">)</span> <span class="term_note"><==最后一个变量内容都会用 * 来代表所有其他值</span>
不包含第一个变量内容与第二个变量内容的其他程序运行段
exit 1
<span class="term_command">;;</span>
<span class="term_command">esac</span> <span class="term_note"><==最终的 case 结尾！『反过来写』思考一下！</span>
</pre></td></tr></tbody></table>
<p>要注意的是，这个语法以 case (实际案例之意) 为开头，结尾自然就是将 case 的英文反过来写！就成为 esac 啰！
不会很难背啦！另外，每一个变量内容的程序段最后都需要两个分号 (;;) 来代表该程序段落的结束，这挺重要的喔！
至于为何需要有 * 这个变量内容在最后呢？这是因为，如果用户不是输入变量内容一或二时，
我们可以告知用户相关的信息啊！废话少说，我们拿 hello-2.sh 的案例来修改一下，他应该会变成这样喔：</p>
<table class="term"><tbody><tr><td class="term"><pre>[dmtsai@study bin]$ <span class="term_command">vim hello-3.sh</span>
<span class="term_write">#!/bin/bash
# Program:
# Show "Hello" from $1.... by using case .... esac
# History:
# 2015/07/16 VBird First release
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:~/bin
export PATH
case ${1} in
"hello")
You can’t perform that action at this time.