BashShell基础

基础

30
1
# 注释
2
:<<EOF，冒号在shell中也是命令，表示什么都不做。
3
echo "I am oldboy"
4
echo "I am oldboy"
5
echo "I am oldboy"
6
EOF #必须顶格写
7

8
# 井号作为注释
9
在目前的Linux中用bash和sh都是一样的，因为sh是bash的软连接。
10

11
shell脚本的执行
12
1. bash script-name
13
2. path/to/script-name或./script-name
14
3. source script-name或. script-name
15
4. sh<script-name或cat script-name|sh
16

17
bash script_name        # 新开启一个子shell
18
.或者source              # 不会新开一个子shell
19

20
bash脚本的一些规范化建议：
21
1.开头加脚本解释器
22
2.附带作者及版权信息
23
3.脚本扩展名为*.sh
24
4.脚本存放在固定的目录下
25
5.脚本中不用中文
26
6.成对的符号一次书写完成
27
7.循环格式一次性输入完成
28

29
登录shell：优先/etc/profile,然后加载~/.bash_profile ，再次加载~/.bashrc，最后加载/etc/bashrc
30
非登录shell：/etc/bashrc，~/.bashrc在执行一个非登录shell时调用

登录shell：优先/etc/profile,然后加载~/.bash_profile ，再次加载~/.bashrc，最后加载/etc/bashrc

非登录shell：/etc/bashrc，~/.bashrc在执行一个非登录shell时调用

变量

xxxxxxxxxx
30
1
定义环境变量
2
export TEST=1
3
TEST=1
4
export TEST
5
declare -x TEST=1
6

7
shell变量的使用和命名规范建议：
8
针对变量名：（一般驼峰法则或者是下划线分隔都行）
9
1）变量名的定义要有一定的命令规范，并且要见名知意
10
2）变量名仅能使用字母，数字，下划线中的任意多个字符，并且以字母开头
11
针对变量内容：
12
3）在脚本汇总定义普通字符串变量，精良把变量的内容用双引号括起来
13
4）单独数字的变量内容可以不加引号
14
5）希望变量的内容原样输出要加单引号
15
6）希望变量的值应用命令并获取命令的结果就用反引号或${}
16
针对赋值符号：
17
7）变量定义使用赋值符号=，赋值符号的两端不要有空格
18
针对变量输出：
19
8）使用或者输出变量的内容，可用$变量名，例如echo $PATH
20
9）拖用变量名db和面有其它字符连接的时候，就必须给变量名加上大括号{}，如$db_t改为${db}_t
21

22

23
普通变量（局部变量）
24
当前用户或者脚本中生效，离开当前用户或者脚本就会失效。
25
变量的名称：遵循驼峰法则或者下划线分隔单词
26
变量内容：
27
变量名=value    #<==不加引号。 ##解析变量或者命令，然后输出，纯数字选择不加引号。
28
变量名='value'  #<==加单引号。 ###所见即所得
29
变量名="value"  #<==加双引号。 ##解析变量或者命令，然后输出，字符串默认选择双引号，可以把要定义的内容作为一个整体。
30
变量名=`ls` 或变量名=$(ls)

xxxxxxxxxx
56
1
# 变量引用和变量替换
2
`command_name_str`      反引号强引用，和$()等同var_name=`ls`
3

4
$(command_name_str)     $()，命令置换  var_name=$(ls)
5

6
${var_name}             变量引用 ${var_name}_d
7

8
$var_name               变量引用  $var_name_d ≠ ${var_name}_d
9

10

11
位置变量    描述
12
$0  脚本的路径或名称
13
$n  n的范围是0~9，表示传入的第n个参数的值
14
$#  脚本中传入参数的个数
15
$*  传入的所有参数，但合并为一个参数
16
$@  传入的所有参数，不合并为一个参数
17
状态变量    描述
18
$?  上一次执行程序的返回结果
19
$$  当前执行脚本的进程号
20
$!  获取上一个后台工作进程的进程号
21
$_  获取上一个执行脚本的最后一个参数
22

23

24
变量子串                       描述
25
${parameter}                 返回变量的内容
26
${#parameter}                返回变量的长度，也适合特殊变量。
27
                             echo ${#TEST}
28
                             expr length "${TEST}"
29
                             echo $TEST|awk '{print length ($0)}'
30
${parameter:offset}          从offset开始取字串到结尾
31
${parameter:offset:length}   从offset开始取length长度的字串
32
${parameter#word}            从变量开头开始删除最短匹配的word字串，可用通配符
33
${parameter##word}           从变量开头开始删除最长匹配的word字串，可用通配符
34
${parameter%word}            从变量结尾开始删除最短匹配的word字串，可用通配符
35
${parameter%%word}           从变量结尾开始删除最长匹配的word字串，可用通配符
36
${parameter/pattern/string}  使用string代替第一个匹配的pattern，可用通配符
37
${parameter//pattern/string} 使用string代替所有匹配的pattern，可用通配符
38

39
# shell特殊变量扩展（冒号可以省略）   
40
${parameter:-word}  result=${var:-word}
41
                    如果变量var值为空或未赋值，那么就把值word赋值给result，但是不复制给var变量
42
                    find $path -name "*.log" -mtime +7 | xargs rm -rf
43
                    find ${path:-/tmp} -name "*.log" -mtime +7 | xargs rm -rf
44
                    典型应用：httpd的启动脚本
45

46
${parameter:=word}  result=${var:-word}
47
                    如果变量var值为空或未赋值，那么就把值word赋值给result，然后再赋值给变量var
48

49

50
${parameter:?word}  result=${var:-word}
51
                    如果变量var值为空或未赋值，那么就把值word当做bash错误提示输出
52
                    -bash: var:word
53

54
${parameter:+word}  result=${var:-word}
55
                    如果变量var值为空或未赋值，那么无操作，如果变量var不为空，就把值赋值给result，但是不赋值给var变量
56

运算符号

xxxxxxxxxx
14
1
常见的运算符           描述
2
+、-                      # 加法、减法
3
*、/、%                   # 乘法、除法、取余（模）
4
**                   # 幂运算
5
++、--               # 增加或减少，前置和后置表达式的结果是不一样的
6
!、&&、||            # 逻辑非、逻辑与、逻辑或
7
<、<=、>、>=          # 小于、小于等于、大于、大于等于
8
==、!=、=             # 相等、不相等、对于字串可表示相当
9
<<、>>               # 左移位、右移位
10
~、&、|、^             # 按位取反、按位与、按位或、安慰异或
11
=、+=、-=、*=、/=、%=   # 赋值、增强赋值
12
                      # 在强类型语言（Java）中，a+=b和a=a+b是有区别的，
13
                      # 他们的区别是：在处理过程中各自数据类型有转换，a+=b<=>a=(a+b)，它是做了数据类型强制转换的
14

运算方法

xxxxxxxxxx
37
1
shell中常用的数学运算方法     描述
2
(())                   整数计算，效率高
3
let                    整数运算，类似(())
4
expr                   可用于整数运算，但是还有很多其它的功能
5
bc                     适合整数和小数运算
6
$[]                    整数计算
7
awk                    适合整数和小数运算
8
                       echo 2.1 1.4|awk '{print $1*$2}'
9
declare                定义变量值和属性，-i参数用于定义整型变量，做运算
10
                       declare -i a=4+5
11
                       
12
表达式                      描述
13
$(i=i+1)        运算后赋值，即将i+1的运算结果复制给变量i。注意不能用echo ((i=i+1))来输出表达式的值，但是可以用echo $((i=i+1))来输出。
14
i=$((i+))       可以在(())前加$符号，将表达式运算后复制给i
15
((8>7&&5==5))   可以进行比较运算，还可以加入逻辑与和逻辑或，用于条件判断
16
echo $((2+1))   需要直接输出运算表达式结果时可以在(())前面加上$符号
17

18

19
expr判断一个变量是否为整数
20
#!/bin/bash
21
expr 2 + $1 &>/dev/null
22
if [ $? -eq 0 ];then
23
    echo "$1 is integer"
24
else
25
    echo "$1 is not integer"
26
fi
27

28
判断扩展名
29
#!/bin/bash
30
expr "$1" : ".*\.txt" &>/dev/null
31
if [ $? -eq 0 ];then
32
        echo "file extension is txt"
33
else
34
        echo "file extension not is txt"
35
fi
36
计算字符长度
37
expr length "str"

用户交互

xxxxxxxxxx
53
1
#!/bin/bash
2
a=$1
3
b=$2
4
echo "a-b=$(($a-$b))"
5
echo "a+b=$(($a+$b))"
6
echo "a*b=$(($a*$b))"
7
echo "a/b=$(($a/$b))"
8
echo "a**b=$(($a**$b))"
9
echo "a%b=$(($a%$b))"
10

11
-p 提示
12
-t 等待用户输入的时间
13
read -t 30 -p "请输入一个数字:"
14
#!/bin/bash
15
read -p "请输入两个数字：" a b
16
echo "a-b=$(($a-$b))"
17
echo "a+b=$(($a+$b))"
18
echo "a*b=$(($a*$b))"
19
echo "a/b=$(($a/$b))"
20
echo "a**b=$(($a**$b))"
21
echo "a%b=$(($a%$b))"
22

23
#!/bin/bash
24
cat <<EOF
25
  1.install lamp
26
  2.install lnmp
27
  3.exit
28
EOF
29
read -p "请选择一个序号（必须是数字）：" num
30
#1.判断是否为整数
31
expr 2 + $num &>/dev/null
32
if [ $? -ne 0 ]
33
then
34
    echo "Usage:$0 {1|2|3}"
35
    exit 1
36
fi
37

38
#2.判断执行处理
39
if [ $num -eq 1 ]
40
then
41
    echo "install lamp..."
42
elif [ $num -eq 2 ]
43
then
44
    echo "install lnmp..."
45
elif [ $num -eq 3 ]
46
then
47
    echo "bye."
48
    exit 
49
else
50
    echo "Usage:$0 {1|2|3}"
51
    exit 1
52
fi
53

条件测试

xxxxxxxxxx
133
1
条件表达式6种写法：if,while
2
        语法1: test <测试表达式>
3
        语法2: [ <测试表达式> ]    #两端有空格
4
        语法3：[[ <测试表达式> ]]  #两端有空格
5
        语法4：((<测试表达式>))    #不需要空格
6

7
        语法5：(命令表达式) 
8
        语法6：`命令表达式`
9

10
编程语法：
11
[ <测试表达式> ] && 命令1
12
如果前面表达式成功，那么就执行后面命令。
13

14
[ <测试表达式> ] || 命令1
15
如果前面表达式失败，那么就执行后面命令。
16

17
[ <测试表达式> ] && {
18
命令1
19
命令2
20
命令3
21
}
22
如果前面表达式成功，那么就执行后面命令。
23

24
[ <测试表达式> ] && 命令1 || 命令2
25
如果前面表达式成功，那么就执行命令1，否则执行命令2。
26

27
[ <测试表达式> ] && {
28
命令1
29
命令2
30
}||{
31
命令3
32
命令4
33
}
34
如果前面表达式成功，那么就执行命令1,2，否则执行命令3,4。
35

36

37
常用文件测试表达式   描述
38
-d 文件，directory 
39
-f 文件，file  
40
-e 文件，exist 
41
-r 文件，read  
42
-s 文件，size  
43
-w 文件，write 
44
-x 文件，executable    
45
-L 文件，link  
46
f1 -nt f2，newer than    
47
其它内容可以直接man test 查找。
48

49

50
在[]以及test中使用    在(())和[[]]中使用   描述
51
-eq ==或=    equal，等于
52
-ne !=  not equal，不等于
53
-gt >   greater than，大于
54
-ge >=  greater equal，大于等于
55
-lt <   less than，小于
56
-le <=  less equal，小于等于
57

58
注：[ ]是比较老旧的写法，[[ ]]是比较新的用法，它支持[ ]中的写法
59

60
字符串测试表达式
61
[ -n "字符串" ]    字符串长度[不]为0，表达式为真。 not zero。
62
[ -z "字符串" ]    字符串长度为0，表达式为真。 zero。
63
[ "字符串1" == "字符串2" ]  两个字符串相同则为真。
64
[ "字符串1" !== "字符串2" ] 两个字符串不相同则为真。
65

66
#!/bin/bash
67
read -p "pls input two num:" a b
68

69
if [ -z "$b" ]
70
then
71
    echo "请输入两个数"
72
    exit 1
73
fi
74
expr $a + $b + 1 &>/dev/null
75
if [ $? -ne 0 ]
76
then
77
    echo "Usage:$0 num1 num2"
78
    exit 1
79
fi
80

81

82
#!/bin/bash
83
read -p "please input two integer number." a b
84

85
[ -z "$b" ] &&{
86
        echo "please input two integer number."
87
        exit 1
88
}
89

90
expr $a + $b + 1 &>/dev/null
91
[ $? -ne 0 ] &&{
92
        echo "please input two integer number."
93
        exit 2
94
}
95

96
if [ $a -gt $b ];then
97
   echo "$a>$b"
98
   exit 0
99
elif [ $a -eq $b ];then
100
   echo "$a=$b"
101
   exit 0
102
else
103
        echo "$a<$b"
104
        exit 0
105
fi
106

107

108
在[ ]和test中  在[[]]和(())中     描述
109
-a                 &&          and，与
110
-o                 ||          or，或
111
!                  !           not，非
112
注：[ ]是比较老旧的写法，[[ ]]是比较新的用法，它支持[ ]中的写法
113
[] [[]] (()) 这些符号之间连接 使用&& ||
114

115

116
+-----------------+----------------+------------------+-----------------+-------------------+
117
| 条件表达式符号            []               test              [[]]              (())
118
+-----------------+----------------+------------------+-----------------+-------------------+
119
| 边界是否需要空格          需要              需要               需要              不需要
120
+-----------------+----------------+------------------+-----------------+-------------------+
121
| 逻辑操作符               !、-a、-o       !、-a、-o          !、&&、||          !、&&、||
122
+-----------------+----------------+------------------+-----------------+-------------------+
123
| 整数比较操作符           -eq、-gt        -eq、-gt           -eq、-gt           =、>、<
124
|                       -lt、-ge        -lt、-ge           -lt、-ge、-le       >=、<=
125
|                       -le             -le                   或
126
|                                                           =、>、<
127
|                                                           >=、<=
128
+-----------------+----------------+------------------+-----------------+-------------------+
129
| 字符串比较操作符        =、==、!=          =、==、!=         =、==、!=          =、==、!=
130
+-----------------+----------------+------------------+-----------------+-------------------+
131
| 是否支持通配符          不支持             不支持              支持              不支持
132
+-----------------+----------------+------------------+-----------------+-------------------+
133

vim配置

xxxxxxxxxx
68
1
set nocompatible 
2
set history=100
3
filetype on
4
filetype plugin on
5
filetype indent on 
6
set autoread 
7
set mouse=c
8
syntax enable 
9
set cursorline
10
hi cursorline guibg=#00ff00
11
hi CursorColumn guibg=#00ff00
12
set foldenable
13
set foldmethod=manual
14
set foldcolumn=0
15
setlocal foldlevel=3
16
set foldclose=all           
17
nnoremap <space> @=((foldclosed(line('.')) < 0) ? 'zc' : 'zo')<CR>
18
set expandtab
19
set tabstop=4
20
set shiftwidth=4
21
set softtabstop=4
22
set smarttab
23
set ai  
24
set si 
25
set wrap 
26
set sw=4                
27
set wildmenu 
28
set ruler 
29
set cmdheight=1 
30
set lz 
31
set backspace=eol,start,indent 
32
set whichwrap+=<,>,h,l 
33
set magic 
34
set noerrorbells
35
set novisualbell
36
set showmatch 
37
set mat=4 
38
set hlsearch
39
set ignorecase
40
set encoding=utf-8
41
set fileencodings=utf-8
42
set termencoding=utf-8
43
set smartindent
44
set cin
45
set showmatch
46
set guioptions-=T
47
set guioptions-=m
48
set vb t_vb=
49
set laststatus=4
50
set pastetoggle=<F9>
51
set background=dark
52
highlight Search ctermbg=black  ctermfg=white guifg=white guibg=black
53
autocmd BufNewFile *.py,*.cc,*.sh,*.java exec ":call SetTitle()"
54
func SetTitle()  
55
    if expand("%:e") == 'sh'  
56
        call setline(1, "#!/bin/bash")
57
        call setline(2, "##############################################################")  
58
        call setline(3, "# File Name: ".expand("%"))
59
        call setline(4, "# Version: V1.0")
60
        call setline(5, "# Author: meizy")
61
        call setline(6, "# Organization: ")
62
        call setline(7, "# Contact: [email protected]")
63
        call setline(8, "# Created Time : ".strftime("%F %T"))
64
        call setline(9, "# Description:")
65
        call setline(10, "##############################################################")
66
    endif  
67
endfunc
68

流程控制语句语法

xxxxxxxxxx
223
1
if statement
2
if <condition>;then
3
    statement
4
fi
5
if <condition>;then
6
    statement
7
else
8
    statement
9
fi
10
if <condition>;then
11
   statement
12
elif <condition>;then
13
   statement
14
elif <condition>;then
15
   statement
16
...
17
else
18
    statement
19
fi
20

21
例1：如果不存在/backup目录就创建。
22
考查if单分支
23
例2：开发Shell脚本判断系统剩余内存的大小，如果低于100MB就提示内存不足，否则提示内存充足。
24
例3：分别使用变量定义、read读入及脚本传参方式实现比较2个整数的大小。
25
例4：打印一个菜单如下，当用户选择对应的数字时，就执行对应项的应用。
26
  1.install lamp
27
  2.install lnmp
28
  3.exit
29

30
#!/bin/bash
31
cat <<EOF
32
  1.install lamp
33
  2.install lnmp
34
  3.exit
35
EOF
36
read -p "请选择一个序号（必须是数字）：" num
37
#1.判断是否为整数
38
expr 2 + $num &>/dev/null
39
if [ $? -ne 0 ]
40
then
41
    echo "Usage:$0 {1|2|3}"
42
    exit 1
43
fi
44

45
#2.判断执行处理
46
if [ $num -eq 1 ]
47
then
48
    echo "install lamp..."
49
elif [ $num -eq 2 ]
50
then
51
    echo "install lnmp..."
52
elif [ $num -eq 3 ]
53
then
54
    echo "bye."
55
    exit 
56
else
57
    echo "Usage:$0 {1|2|3}"
58
    exit 1
59
fi
60

61
# case语句
62
case statement
63
case variable in
64
    value1)
65
        statement
66
        ;;
67
    value2)
68
        statement
69
        ;;
70
    ...
71
    valuen)
72
        statement
73
        ;;
74
    *)
75
        statement
76
        ;; #这里可以省略，前面都不可以省略
77
esac
78

79
#!/bin/bash
80
cat <<EOF-
81
1.apple
82
2.pear
83
3.banana
84
4.cherry
85
        EOF
86

87

88
#!/bin/bash
89
cat <<EOF
90
1.apple
91
2.pear
92
3.banana
93
4.cherry
94
EOF
95

96
#!/bin/bash
97
cat <<'EOF'
98
$PATH
99
EOF
100

101
#!/bin/bash
102
cat <<EOF
103
$PATH
104
EOF
105

106

107
rsyncd启动脚本
108

109
#!/bin/bash
110
start(){
111
    rsync --daemon
112
    retval=$?
113
    if [ $retval -eq 0 ]
114
    then
115
        echo "rsync startup ok"
116
        return $retval
117
    else
118
        echo "rsync startup fail"
119
        return $retval
120
    fi
121
}
122
stop(){
123
    killall rsync
124
    retval=$?
125
    if [ $retval -eq 0 ]
126
    then
127
        echo "rsync stop ok"
128
        return $retval
129
    else
130
        echo "rsync stop fail"
131
        return $retval
132
    fi
133
}
134
case "$1" in
135
    start)
136
        start
137
        retval=$?
138
        ;;
139
    stop)
140
        stop
141
        retval=$?
142
        ;;
143
    restart)
144
        stop
145
        sleep 1
146
        start
147
        retval=$?
148
        ;;
149
    *)
150
        echo "usage:$0 {start|stop|restart}"
151
        exit 1
152
esac
153
exit $retval
154

155
输出内容时可以调用系统函数库
156
#!/bin/bash
157
. /etc/init.d/functions
158
action "service starting " /bin/ture
159
action "service staring" /bin/false
160

161
rsyncd启动脚本
162
#!/bin/bash
163
. /etc/init.d/functions
164
lockfile=/var/lock/subsys/rsyncd
165
rsyncd_pid_file_path=/var/run/rsyncd.pid
166

167
start(){
168
    rsync --daemon
169
    retval=$?
170
    if [ $retval -eq 0 ]
171
    then
172
        action "rsync startup" /bin/true
173
                touch $lockfile
174
        return $retval
175
    else
176
        action "rsync startup" /bin/false
177
        return $retval
178
    fi
179
}
180
stop(){
181
        if test -s "$rsyncd_pid_file_path";then
182
                rsyncd_pid=`cat $rsyncd_pid_file_path`
183
                if (kill -0 $rsyncd_pid &>/dev/null);then        # pid对应的进程是否真实存在
184
                        kill $rsyncd_pid
185
                        rm -f $lockfile >/dev/null
186
                        retval=$?
187
                    if [ $retval -eq 0 ]
188
                    then
189
                        action "rsync stop" /bin/true
190
                        return $retval
191
                    else
192
                        action "rsync stop" /bin/false
193
                        return $retval
194
                    fi
195
                else
196
                        echo "rsyncd process is no exists."
197
                        return 2
198
                fi
199
        else
200
                echo "$rsyncd_pid_file_path is not exists,or rsyncd not start."
201
        fi
202
}
203
case "$1" in
204
    start)
205
        start
206
        retval=$?
207
        ;;
208
    stop)
209
        stop
210
        retval=$?
211
        ;;
212
    restart)
213
        stop
214
        sleep 1
215
        start
216
        retval=$?
217
        ;;
218
    *)
219
        echo "usage:$0 {start|stop|restart}"
220
        exit 1
221
esac
222
exit $retval
223

xxxxxxxxxx
110
1
for statement syntax
2
for variable in list
3
do
4
    statement
5
done
6
for ((控制变量初始化;条件判断表达式;控制变量的修正表达式))
7
do
8
    statement
9
done
10

11
获取列表
12
(1) 直接给出列表；
13
(2) 整数列表：
14
(a) {start..end}
15
(b) $(seq [start [step]] end) 
16
(3) 返回列表的命令；
17
$(COMMAND)
18
(4) glob 通配的方式
19
(5) 变量引用；
20
$@, $*
21
 
22
 
23
        #!/bin/bash
24
        for((j=1;j<=9;j++));do
25
                for((i=1;i<=j;i++))do
26
                    echo -e -n "${i}X${j}=$[$i*$j]\t"
27
                done        
28
                echo        
29
        done
30
 
31
将文件中的finished去掉
32
        准备文件touch stu_{1..10}_finished.jpg
33
         
34
        ls *.jpg|awk -F "_finished" '{print "mv",$0,$1$2}'|bash
35
         
36
        rename "_finished" "" *.jpg    #rename to file
37
         
38
        #!/bin/bash
39
        for file in `ls ./*.jpg`
40
        do
41
            mv $file `echo ${file/_finished/}`
42
        done
43
信号编号    短名称 定义
44
1   HUP 挂起
45
2   INT 键盘中断
46
3   QUIT    键盘退出
47
9   KILL    中断（无法拦截
48
15  TERM    终止
49
18  CONT    继续
50
19  STOP    停止（无法拦截）
51
20  TSTP    键盘停止
52
note:先用SIGTERM   再用  SIGKILL 以避免SIGKILL可能造成的误用
53

54

55
sh while1.sh &
56

57
把脚本while1.sh放到后台执行（后台运行脚本时常用）*
58

59
nohup while1.sh &
60

61
使用nohup把脚本while1.sh放到后台执行，但消息会输出到标准输出
62

63
ctl+c
64

65
停止执行当前脚本或任务
66

67
ctl+z
68

69
暂停执行当前脚本或任务
70

71
bg
72

73
把当前脚本或任务放到后台执行，bg可以理解为background
74

75
fg
76

77
把当前脚本或任务拿到前台执行，如果有多个任务，可以使用fg加任务编号调出对应脚本任务，如fg 2，调出第二个脚本任务，fg可以理解为frontground
78

79
jobs
80

81
查看当前执行的脚本或任务
82

83
kill
84

85
关闭执行的脚本任务，即以“kill %任务编号”的形式关闭脚本，这个任务编号，可以通过jobs获得
86

87

88
常用进程管理命令
89

90
后台运行 &、nohup、screen（运维人员）
91

92
l kill、killall、pkill：杀掉进程。
93
l ps：查看进程。
94
l pstree：显示进程状态树。
95
l top：显示进程。
96
l renice：改变优先权。 
97
l nohup：用户退出系统之后继续工作。
98
l pgrep：查找匹配条件的进程。
99
l strace：跟踪一个进程的系统调用情况。
100
l ltrace：跟踪进程调用库函数的情况。
101

102

103
nohup和&U区别
104

105
no hangup的缩写，意即“不挂断”， 忽略所有挂断（SIGHUP）信号，不挂断的运行，注意没有后台运行功能，用nohup运行命令可以使命令永久的执行下去，和用户终端没有关系，例如我们断开SSH连接都不会影响他的运行，注意了nohup没有后台运行的意思；&才是后台运行。&是指在后台运行，但当用户退出(挂起)的时候，命令自动也跟着退出，那么把nohup和&结合起来用nohup COMMAND &这样就能使命令永久的在后台执行
106

107
&：放入后台，当session断掉，会受到SIGHUP信号，直接关闭，Ctrl+C无法关闭，输出会放到前台。
108
nohup：nohup: ignoring input and appending output to ‘nohup.out’，Ctrl+C程序收到SIGINT信号后，直接关闭，session断掉进程会自动把进程ID为1的进程当做父进程仍然运行，输出不会放到前台，。
109
nohup和&：键入Ctrl + C，发送SIGINT信号和关闭session，发送SIGHUP信号都不能关闭。
110

xxxxxxxxxx
75
1
while condition|true|false  while read line
2
do  do
3
    statement       statement
4
done    done < /path/to/filename
5

6
cat /path/to/filename | while read line exec </path/to/filename
7
do  while read line
8
    statement   do
9
done        statement
10
这里会开启一个子shell，所以while外无法使用while中处理的变量。  done
11
#!/bin/bash
12
        #
13
        read -p "Enter a user name: " username
14
         
15
        while true; do
16
            if who | grep "^$username" &> /dev/null; then
17
                break       
18
            fi
19
            sleep 3
20
        done
21
         
22
        echo "$username logged on." >> /tmp/user.log
23
 
24
        #!/bin/bash
25
        read -p "Enter a option: " option
26
        while [ "$option" != 'cpu' -a "$option" != 'mem' -a "$option" != 'disk' -a "$option" != 'quit' ]; do
27
        read -p "Wrong option, Enter again: " option
28
        done
29
         
30
        #!/bin/bash
31
        while read line;do
32
                if [ $[`echo $line | cut -d: -f3` % 2] -eq 0 ];then
33
                        echo -e -n "username: `echo $line | cut -d: -f1`\t" 
34
                        echo "uid: `echo $line | cut -d: -f3 `"
35
                fi
36
        done < /etc/passwd
37
 
38
        #!/bin/sh
39
        while true 
40
        do
41
            uptime >>/tmp/uptime.log
42
            sleep 2    # usleep微妙
43
        done
44
 
45
 
46
猜数字游戏。首先让系统随机生成一个数字，给这个数字定一个范围（1-60），让用户输入猜的数字，对输入进行判断，如果不符合要求，就给予高或低的提示，猜对后则给出猜对用的次数，请用while语句实现。
47
提示：可以赋予一个猜水果的价格游戏。
48
分析：
49
1）给这个数字定一个范围（1-60）
50
        echo $((RANDOM%60)) 执行脚本后是固定的，例如；50
51
 
52
2)read -p "输入猜数字：" num
53
用户输入的数字和已知的随机数比较。
54
 
55
3）连续猜就需要用while
56
        random="$((RANDOM%60))"
57
        count=0
58
        while true
59
        do
60
             ((count++))
61
            read -p "请猜数字：" num
62
            if [ $num -gt $random ]
63
            then
64
                echo "猜高了。"
65
            elif [ $num -eq $random ]
66
            then
67
                echo "牛啊，猜对了，一共猜了${count}次。"
68
                exit
69
            else
70
                echo "猜低了。"
71
            fi
72
        done
73
 
74
Apache访问日志(access_2010-12-8.log)，把日志中每行的访问字节数对应字段数字相加，计算出总的访问量。给出实现程序，请用while循环实现。（3分钟）
75

xxxxxxxxxx
28
1
 until statement syntax
2
until condition|true|false
3
do
4
    statement
5
done
6
#!/bin/bash
7
#
8
declare -i j=1
9
declare -i i=1
10
 
11
until [ $j -gt 9 ]; do
12
    until [ $i -gt $j ]; do 
13
        echo -n -e "${i}X${j}=$[$i*$j]\t"
14
        let i++
15
    done
16
    echo
17
    let i=1
18
    let j++
19
done
20
 
21
#!/bin/bash
22
#
23
read -p "Enter a user name: " username
24
 
25
until who | grep "^$username" &> /dev/null; do
26
    sleep 3
27
done
28

select

xxxxxxxxxx
62
1
select statement
2
select variable in list
3
do
4
    statement
5
done
6
#!/bin/bash
7
echo "Which car do you prefer?"
8
select CAR in Benz Audi VolksWagen
9
do
10
        break
11
done
12
echo "You chose $CAR"
13
 
14
 
15
#!/bin/bash
16
select DAY in Mon Tue Wed Thu Fri Sat Sun
17
do
18
        case $DAY in
19
        Mon)
20
                echo "Today is Monday";;
21
        Tue)
22
                echo "Today is Tuesday";;
23
        Wed)
24
                echo "Today is Wednesday";;
25
        Thu)
26
                echo "Today is Thursday";;
27
        Fri)
28
                echo "Today is Friday";;
29
        Sat|Sun)
30
                echo "You can have a rest today";;
31
        *)
32
                echo "Unknown input ,exit now" && break;;
33
        esac
34
done
35

36

37

38
 命令 说明
39
break n 如果省略n表示跳出整个循环，n 表示跳出循环的层数
40
continue n  如果省略n表示跳过本次循环，忽略本次循环的剩余代码，进入循环的下一次循环。n 表示退到第n层继续循环
41
exit n  退出当前shell程序，n为上一次程序执行的状态返回值。n也可以省略，再下一个shell里可通过$?接收exit n的n值
42
return n    用于在函数里，作为函数的返回值，用于判断函数执行是否正确。再下一个shell里可通过$?接收exit n的n值
43

44
break[n]和continue[n]都是在循环语句中使用，break 结束整个循环，continue退出当次循环，进入下次循环。
45
 
46
#!/bin/bash
47
#
48
declare -i i=0
49
declare -i sum=0
50
 
51
until [ $i -gt 100 ]; do
52
    let i++
53
    if [ $[$i%2] -eq 1 ]; then
54
        continue    
55
    fi
56
    let sum+=$i 
57
done
58
 
59
echo "Even sum: $sum"
60
 
61
break、continue在条件语句及循环语句（for、while、if等）中用于控制程序的走向，而exit则用于终止所有语句并退出当前脚本，除此之外，exit还可以返回上一次程序或命令的执行状态值给当前Shell；return类似exit，只不过return仅用于在函数内部返回函数执行的状态值。
62

xxxxxxxxxx
124
1
是函数的返回值，它返回值给调用者。
2

3
函数调用和传参
4
#!/bin/bash
5
function test(){
6
        local name="test"        #仅在函数内生效
7
        id="id_test"        # 在函数内外都生效，不建议使用
8
    echo "The test function \$1 is $1"        #这里的$1是传入函数的参数
9
        return 1
10
}
11

12
# 函数一定要先定义后调用
13
test args
14
test $1        #这里的$1是传入脚本的参数
15
echo $?        # 获取函数return的值
16
echo ${id}
17
# echo ${name}  #获取不到
18

19
其它脚本中调用函数
20
#!/bin/bash
21
. /path/to/func_filename
22
source /path/to/func_filename
23
test args
24
test $1        #这里的$1是传入脚本的参数
25

26

27
企业案例：通过脚本传参的方式，检查Web 网站URL是否正常。
28
wget命令：
29
        --spider 模拟爬虫
30
        -q 安静访问
31
        -o /dev/null 不输出
32
        -T --timeout 超时时间
33
        -t --tries 重试次数
34
~]# wget --spider -T 5 -q -o /dev/null -t 2 www.baidu.com
35
~]# echo $?
36
0
37
curl命令：
38
        -I 看响应头
39
        -s 安静的
40
        -o /dev/null 不输出
41
        -w %{http_code} 返回状态码，200
42
            -m 超时时间
43

44
~]# curl www.baidu.com -s &>/dev/null
45
~]# echo $?
46
0
47
~]# curl -I -m 5 -s -w "%{http_code}\n" -o /dev/null  www.baidu.com
48
200
49

50

51
不用函数的实现写法
52
#!/bin/sh
53
if [ $# -ne 1 ]
54
  then
55
    echo $"usage:$0 url"
56
    exit 1
57
fi
58
wget --spider -q -o /dev/null --tries=1 -T 5 $1 #<==-T指定超时时间，这里的$1为脚本的参数。
59
if [ $? -eq 0 ]
60
  then
61
    echo "$1 is yes."
62
else
63
    echo "$1 is no."
64
fi
65
高端专业的函数写法：
66

67
cat checkurl.sh 
68
#!/bin/bash
69
##############################################################
70
# File Name: checkurl.sh
71
# Version: V1.0
72
# Author: oldboy
73
# Organization: www.oldboyedu.com
74
# Created Time : 2018-06-07 18:29:19
75
# Description:
76
##############################################################
77
usage(){
78
    echo "Usage:$0 url"
79
    exit 1
80
}
81
checkurl(){
82
    wget -q -o /dev/null -t 2 -T 5 $1
83
    if [ $? -eq 0 ]
84
    then
85
        echo "$1 is ok"
86
    else
87
        echo "$1 is fail"
88
    fi
89
}
90
main(){
91
    if [ $# -ne 1 ]
92
    then
93
        usage
94
    fi
95
    checkurl $1
96
}
97
main $*
98

99
[root@oldboy scripts]# cat 8_5_1.sh   
100
#!/bin/sh
101
function usage() {     #<==帮助函数
102
    echo $"usage:$0 url"
103
    exit 1
104
}
105

106
function check_url() { #<==检测URL函数。
107
  wget --spider -q -o /dev/null --tries=1 -T 5 $1 #<==这里的$1就是函数传参。
108
  if [ $? -eq 0 ]
109
   then
110
     echo "$1 is yes."
111
  else
112
    echo "$1 is no."
113
  fi
114
}
115

116
function main() {   #<==主函数。
117
  if [ $# -ne 1 ]  #<==如果传入的多个参数，则打印帮助函数，提示用户。
118
  then
119
    usage
120
  fi
121
  check_url $1     #<==接收函数的传参，即把结尾的$*传到这里。
122
}
123
main $*            #<==这里的$*就是把命令行接收的所有参数作为函数参数传给函数内部，常用手法。
124

array

xxxxxxxxxx
50
1
Shell数组的定义
2
Shell数组的定义有多种方法，列举如下。
3
方法1：用小括号将变量值括起来赋值给数组变量，每个变量值之间要用空格分隔。
4
语法如下：
5
array=(value1 value2 value3 ... ) 
6
此为常用定义方法，需重点掌握。
7
示例如下：
8
~]# array=(1 2 3)    #<==用小括号将数组内容赋值给数组变量，数组元素用“空格”分隔开。
9
~]# echo ${array[*]} #<==输出上面定义的数组的所有元素值，注意语法。
10
1 2 3
11
方法2：用小括号将变量值括起来，同时采用键值对的形式赋值。
12
语法如下：
13
array=([1]=one [2]=two [3]=three) 
14
此种方法为key-value键值对的形式，小括号里对应的数字为数组下标，等号后面的内容为下标对应的数组变量的值，此方法比较复杂，不推荐使用。
15
示例如下：
16
~]# array=([1]=one [2]=two [3]=three)
17
~]# echo ${array[*]} #<==输出上面定义的数组的所有元素值。 
18
one two three
19
~]# echo ${array[1]} #<==输出上面定义的数组的第一个元素值。
20
one
21
~]# echo ${array[2]} #<==输出上面定义的数组的第二个元素值。
22
two
23
~]# echo ${array[3]} #<==输出上面定义的数组的第三个元素值。
24
three
25
方法3：通过分别定义数组变量的方法来定义。
26
语法如下：
27
array[0]=a;array[1]=b;array[2]=c
28
此种定义方法比较麻烦，不推荐使用。
29
示例如下：
30
~]# array[0]=a
31
~]# array[1]=b
32
~]# array[2]=c
33
~]# echo ${array[0]}
34
a
35
方法4：动态地定义数组变量，并使用命令的输出结果作为数组的内容。
36
语法为：
37
array=($(命令))
38
或
39
array=(`命令`)
40
示例如下：
41
data]# mkdir /array/ -p
42
data]# touch /array/{1..3}.txt
43
data]# ls /array/
44
1.txt 2.txt 3.txt
45
data]# array=($(ls /array))
46
data]# echo ${array[*]}
47
1.txt 2.txt 3.txt
48
说明：还可以使用declare -a array来定义数组类型，但是比较少这样用。
49

50

xxxxxxxxxx
150
1
Shell数组的打印及输出
2
1. 打印数组元素
3
此为常用知识点，需重点掌握。示例如下：
4
data]# array=(one two three)
5
data]# echo ${array[0]}
6
#<==打印单个数组元素用${数组名[下标]}，当未指定数组下标时，数组的下标是从0开始。
7
one
8
data]# echo ${array[1]}
9
two
10
data]# echo ${array[2]}
11
three
12
data]# echo ${array[*]}   #<==使用*或者@可以得到整个数组内容。
13
one two three
14
data]# echo ${array[@]}   #<==使用*或者@可以得到整个数组内容。
15
one two three
16
2. 打印数组元素的个数
17
此为常用知识点，需重点掌握。示例如下：
18
data]# echo ${array[*]}   #<==使用*或者@可以得到整个数组内容。
19
one two three
20
data]# echo ${#array[*]}  #<==用${#数组名[@或*]}可以得到数组长度，这和前文讲解的变量子串知识是一样的，因为数组也是变量，只不过是特殊的变量，因此也适合变量的子串替换等知识。
21
3
22
data]# echo ${array[@]}   #<==使用*或者@可以得到整个数组内容。
23
one two three
24
data]# echo ${#array[@]}  #<==用${#数组名[@或*]}可以得到数组长度，这和前文讲解的变量子串知识是一样的，因为数组也是变量，只不过是特殊的变量，因此也适合变量的子串替换等知识。
25
3
26
3. 数组赋值
27
此知识不常用，了解即可。可直接通过“数组名[下标] ”对数组进行引用赋值，如果下标不存在，自动添加新一个数组元素，如果下标存在就覆盖原来的值。
28
示例如下：
29
data]# array=(one two three)
30
data]# echo ${array[*]}
31
one two three
32
data]# array[3]=four       #<==增加下标为3的数组元素。
33
data]# echo ${array[*]}
34
one two three four
35
data]# array[0]=oldboy
36
data]# echo ${array[*]}
37
oldboy two three four
38
~]# array[0]=mei        #<==修改数组元素。
39
~]# echo ${array[@]}
40
mei 2 3 4
41
4. 数组的删除
42
因为数组本质上还是变量，因此可通过“unset 数组[下标]”清除相应的数组元素，如果不带下标，表示清除整个数组的所有数据。
43
示例如下：
44
data]# echo ${array[*]}
45
oldboy two three four
46
data]# unset array[1]   #<==取消下标为1的数组元素。
47
data]# echo ${array[*]} #<==打印输出后发现数组元素“two”，不见了。
48
oldboy three four
49
data]# unset array      #<==删除整个数组。
50
data]# echo ${array[*]}
51
#<==没有任何内容了。
52
5. 数组内容的截取和替换
53
这里和前文变量子串的替换是一样的，因为数组是特殊的变量。数组元素部分内容截取的示例如下：
54
~]# array=(1 2 3 4 5)
55
~]# echo ${array[@]:1:3}          #<==从下标为1的元素开始截取，共取3个数组元素。
56
2 3 4
57
data]# array=({a..z})             #<==将变量的结果赋值给数组变量。
58
data]# echo ${array[@]}
59
a b c d e f g h i j k l m n o p q r s t u v w x y z
60
data]# echo ${array[@]:1:3}       #<==从下标为1的元素开始截取，共取3个数组元素。
61
b c d
62
data]# echo ${array[@]:0:2}       #<==从下标为0的元素开始截取，共取2个数组元素。
63
a b
64
数组元素部分内容的替换如下：
65
data]# array=(1 2 3 1 1)   
66
data]# echo ${array[@]/1/b}    #<==把数组中的1替换成b，原数组未被修改,和sed很像。
67
b 2 3 b b
68
提示：调用方法是：${数组名[@或*]/查找字符/替换字符} 该操作不会改变原先数组内容，如果需要修改，可以看上面例子，重新定义数组。
69
数组元素部分内容的删除如下：
70
data]# array=(one two three four five)
71
data]# echo ${array[@]}               
72
one two three four five
73
data]# echo ${array[@]#o*}    #<==从左边开始匹配最短的，并删除。 
74
ne two three four five
75
data]# echo ${array1[@]##o*}  #<==从左边开始匹配最长的，并删除。 
76
two three four five
77
data]# echo ${array[@]%f*}    #<==从右边开始匹配最短的，并删除。 
78
one two three
79
data]# echo ${array[@]%%f*}   #<==从右边开始匹配最长的，并删除。
80
one two three
81
提示：数组也是变量，因此也适合于前面讲解过的变量的子串处理的功能应用。
82
数组的其他相关知识通过man bash然后搜Arrays来了解。
83

84

85
范例：使用循环批量输出数组的元素。
86
方法1：通过C语言型的for循环语句打印数组元素。
87
#!/bin/sh
88
array=(1 2 3 4 5)
89
for((i=0;i<${#array[*]};i++))  #<==从数组的第一个小标0开始，循环数组的所有下标。
90
do
91
    echo ${array[i]}            #<==打印数组元素。
92
done
93
方法2：通过普通for循环语句打印数组元素。
94
#!/bin/sh
95
array=(1 2 3 4 5)
96
for n in ${array[*]}  #<==${array[*]}表示输出数组所有元素，相当于列表数组元素。
97
do
98
    echo $n           #<==这里就不是直接去数组里取元素了，而是变量n的值。
99
done
100
输出结果同方法1，此处略过。
101
方法3：使用while循环语句打印数组元素。
102
#!/bin/sh
103
array=(1 2 3 4 5)
104
i=0
105
while ((i<${#array[*]}))
106
do
107
    echo ${array[i]}
108
    ((i++))
109
done
110
输出结果同方法1，此处略过。
111

112
范例：通过竖向列举法定义数组元素并批量打印。
113
#!/bin/sh
114
array=(         #<==对于元素特别长的时候，例如URL地址，竖向列出来看起来舒服和规范。
115
    oldboy
116
    oldgirl
117
    xiaoting
118
    bingbing
119
)
120
for ((i=0; i<${#array[*]}; i++))
121
do
122
    echo "This is num $i,then content is ${array[$i]}"
123
done
124
echo ----------------------
125
echo "array len:${#array[*]}"
126
输出结果如下：
127
This is num 0,then content is oldboy
128
This is num 1,then content is oldgirl
129
This is num 2,then content is xiaoting
130
This is num 3,then content is bingbing
131
----------------------
132
array len:4
133
范例：把命令结果作为数组元素定义并打印。
134
准备数据：
135
scripts]# mkdir -p /array/
136
scripts]# touch /array/{1..3}.txt
137
scripts]# ls /array/
138
1.txt  2.txt  3.txt
139
以下为开发脚本：
140
#!/bin/bash
141
dir=($(ls /array))              #<==把ls /array命令结果放数组里。
142
for ((i=0; i<${#dir[*]}; i++))  #<==${#dir[*]}为数组的长度。
143
do
144
    echo "This is NO.$i,filename is ${dir[$i]}"
145
done
146
输出结果如下：
147
This is NO.0,filename is 1.txt
148
This is NO.1,filename is 2.txt
149
This is NO.2,filename is 3.txt
150