Shell

2019独角兽企业重金招聘Python工程师标准>>>

Shell 诞生于 Unix，是与 Unix/Linux 交互的工具,是Unix的第一个脚本语言。Shell在编程方面比Windows批处理强大很多，无论是在循环、运算。
Unix/Linux上常见的Shell脚本解释器有bash、sh、csh、ksh等，习惯上把它们称作一种Shell。我们常说有多少种Shell，其实说的是Shell脚本解释器。

注释

以“#”开头的行就是注释，会被解释器忽略。

#!/bin/bash
echo "Hello World !"
“#!” 是一个约定的标记，它告诉系统这个脚本需要什么解释器来执行，即使用哪一种Shell。echo命令用于向窗口输出文本。

chmod +x ./hello.sh  #使脚本具有执行权限
./hello.sh  #执行脚本

cd /home/shell/
# vi hello.sh
# chmod +x hello.sh
# ./hello.sh
Hello World !

变量
再看一个例子。下面的脚本使用 read 命令从 stdin 获取输入并赋值给 PERSON 变量，最后在 stdout 上输出：
#!/bin/bash
echo "What is your name?"
read PERSON
echo "Hello, $PERSON"

[root@iZ28afl817lZ shell]# vi read.sh
[root@iZ28afl817lZ shell]# chmod +x read.sh
[root@iZ28afl817lZ shell]# ./read.sh
What is your name?
ken
Hello, ken

定义使用变量
定义变量时，变量名不加美元符号（$）， 使用变量，只要在变量名前面加美元符号（$）即可
推荐给所有变量加上花括号，这是个好的编程习惯，帮助解释器识别变量的边界。
your_name="ken"
echo $your_name
echo ${your_name}

只读变量    readonly ，可以将变量定义为只读变量，只读变量的值不能被改变。readonly myUrl
删除变量 unset 命令可以删除变量。   unset variable_name

Shell特殊变量：Shell $0, $#, $*, $@, $?, $$和命令行参数
echo $$   $ 表示当前Shell进程的ID，即pid，看下面的代码：
    $0     当前脚本的文件名
    $n     传递给脚本或函数的参数。n 是一个数字，表示第几个参数。例如，第一个参数是$1，第二个参数是$2。
    $#     传递给脚本或函数的参数个数。
    $*     传递给脚本或函数的所有参数。
    $@     传递给脚本或函数的所有参数。被双引号(" ")包含时，与 $* 稍有不同，下面将会讲到。
    $?     上个命令的退出状态，或函数的返回值。
    $$     当前Shell进程ID。对于 Shell 脚本，就是这些脚本所在的进程ID。

转义字符
\\     反斜杠
\a     警报，响铃
\b     退格（删除键）
\f     换页(FF)，将当前位置移到下页开头
\n     换行
\r     回车
\t     水平制表符（tab键）
\v     垂直制表符
echo 命令的 -E 选项禁止转义，默认也是不转义的；使用 -n 选项可以禁止插入换行符。
-e 表示对转义字符进行替换。如果不使用 -e 选项，将会原样输出
echo "Value of a is a\n"
echo -e "Value of a is a\n"
echo -E "Value of a is a\n"

命令替换   命令替换是指Shell可以先执行命令，将输出结果暂时保存，在适当的地方输出。
#!/bin/bash
DATE=`date`
echo "Date is $DATE"
USERS=`who | wc -l`
echo "Logged in user are $USERS"
UP=`date ; uptime`
echo "Uptime is $UP"

Shell运算符：Shell算数运算符、关系运算符、布尔运算符、字符串运算符
val=`expr 2 + 2`

#!/bin/sh
a=10
b=20
val=`expr $a + $b`
echo "a + b : $val"
val=`expr $a - $b`
echo "a - b : $val"
val=`expr $a \* $b`
echo "a * b : $val"
val=`expr $b / $a`
echo "b / a : $val"
val=`expr $b % $a`
echo "b % a : $val"
if [ $a == $b ]
then
   echo "a is equal to b"
fi
if [ $a != $b ]
then
   echo "a is not equal to b"
fi

#relation
a=10
b=20
if [ $a -eq $b ]
then
   echo "$a -eq $b : a is equal to b"
else
   echo "$a -eq $b: a is not equal to b"
fi
if [ $a -ne $b ]
then
   echo "$a -ne $b: a is not equal to b"
else
   echo "$a -ne $b : a is equal to b"
fi
if [ $a -gt $b ]
then
   echo "$a -gt $b: a is greater than b"
else
   echo "$a -gt $b: a is not greater than b"
fi
if [ $a -lt $b ]
then
   echo "$a -lt $b: a is less than b"
else
   echo "$a -lt $b: a is not less than b"
fi
if [ $a -ge $b ]
then
   echo "$a -ge $b: a is greater or  equal to b"
else
   echo "$a -ge $b: a is not greater or equal to b"
fi
if [ $a -le $b ]
then
   echo "$a -le $b: a is less or  equal to b"
else
   echo "$a -le $b: a is not less or equal to b"
fi

#boolean
if [ $a != $b ]
then
   echo "$a != $b : a is not equal to b"
else
   echo "$a != $b: a is equal to b"
fi
if [ $a -lt 100 -a $b -gt 15 ]
then
   echo "$a -lt 100 -a $b -gt 15 : returns true"
else
   echo "$a -lt 100 -a $b -gt 15 : returns false"
fi
if [ $a -lt 100 -o $b -gt 100 ]
then
   echo "$a -lt 100 -o $b -gt 100 : returns true"
else
   echo "$a -lt 100 -o $b -gt 100 : returns false"
fi
if [ $a -lt 5 -o $b -gt 100 ]
then
   echo "$a -lt 100 -o $b -gt 100 : returns true"
else
   echo "$a -lt 100 -o $b -gt 100 : returns false"
fi

a="abc"
b="efg"
if [ $a = $b ]
then
   echo "$a = $b : a is equal to b"
else
   echo "$a = $b: a is not equal to b"
fi
if [ $a != $b ]
then
   echo "$a != $b : a is not equal to b"
else
   echo "$a != $b: a is equal to b"
fi
if [ -z $a ]
then
   echo "-z $a : string length is zero"
else
   echo "-z $a : string length is not zero"
fi
if [ -n $a ]
then
   echo "-n $a : string length is not zero"
else
   echo "-n $a : string length is zero"
fi
if [ $a ]
then
   echo "$a : string is not empty"
else
   echo "$a : string is empty"
fi

+     加法     `expr $a + $b` 结果为 30。
-     减法     `expr $a - $b` 结果为 10。
*     乘法     `expr $a \* $b` 结果为  200。
/     除法     `expr $b / $a` 结果为 2。
%     取余     `expr $b % $a` 结果为 0。
=     赋值     a=$b 将把变量 b 的值赋给 a。
==     相等。用于比较两个数字，相同则返回 true。     [ $a == $b ] 返回 false。
!=     不相等。用于比较两个数字，不相同则返回 true。     [ $a != $b ] 返回 true。

-eq     检测两个数是否相等，相等返回 true。     [ $a -eq $b ] 返回 true。
-ne     检测两个数是否相等，不相等返回 true。     [ $a -ne $b ] 返回 true。
-gt     检测左边的数是否大于右边的，如果是，则返回 true。     [ $a -gt $b ] 返回 false。
-lt     检测左边的数是否小于右边的，如果是，则返回 true。     [ $a -lt $b ] 返回 true。
-ge     检测左边的数是否大等于右边的，如果是，则返回 true。     [ $a -ge $b ] 返回 false。
-le     检测左边的数是否小于等于右边的，如果是，则返回 true。     [ $a -le $b ] 返回 true。

!     非运算，表达式为 true 则返回 false，否则返回 true。     [ ! false ] 返回 true。
-o     或运算，有一个表达式为 true 则返回 true。     [ $a -lt 20 -o $b -gt 100 ] 返回 true。
-a     与运算，两个表达式都为 true 才返回 true。     [ $a -lt 20 -a $b -gt 100 ] 返回 false。

字符串运算符列表 运算符  
=     检测两个字符串是否相等，相等返回 true。     [ $a = $b ] 返回 false。
!=     检测两个字符串是否相等，不相等返回 true。     [ $a != $b ] 返回 true。
-z     检测字符串长度是否为0，为0返回 true。     [ -z $a ] 返回 false。
-n     检测字符串长度是否为0，不为0返回 true。     [ -z $a ] 返回 true。
str     检测字符串是否为空，不为空返回 true。     [ $a ] 返回 true。

 文件测试运算符
文件测试运算符用于检测 Unix 文件的各种属性。
例如，变量 file 表示文件“/home/shell/calc.sh”，它的大小为**字节，具有 rwx 权限。下面的代码，将检测该文件的各种属性：

#!/bin/sh
file="/home/shell/calc.sh"
if [ -r $file ]
then
   echo "File has read access"
else
   echo "File does not have read access"
fi
if [ -w $file ]
then
   echo "File has write permission"
else
   echo "File does not have write permission"
fi
if [ -x $file ]
then
   echo "File has execute permission"
else
   echo "File does not have execute permission"
fi
if [ -f $file ]
then
   echo "File is an ordinary file"
else
   echo "This is sepcial file"
fi
if [ -d $file ]
then
   echo "File is a directory"
else
   echo "This is not a directory"
fi
if [ -s $file ]
then
   echo "File size is zero"
else
   echo "File size is not zero"
fi
if [ -e $file ]
then
   echo "File exists"
else
   echo "File does not exist"
fi

-b file     检测文件是否是块设备文件，如果是，则返回 true。     [ -b $file ] 返回 false。
-c file     检测文件是否是字符设备文件，如果是，则返回 true。     [ -b $file ] 返回 false。
-d file     检测文件是否是目录，如果是，则返回 true。     [ -d $file ] 返回 false。
-f file     检测文件是否是普通文件（既不是目录，也不是设备文件），如果是，则返回 true。     [ -f $file ] 返回 true。
-g file     检测文件是否设置了 SGID 位，如果是，则返回 true。     [ -g $file ] 返回 false。
-k file     检测文件是否设置了粘着位(Sticky Bit)，如果是，则返回 true。     [ -k $file ] 返回 false。
-p file     检测文件是否是具名管道，如果是，则返回 true。     [ -p $file ] 返回 false。
-u file     检测文件是否设置了 SUID 位，如果是，则返回 true。     [ -u $file ] 返回 false。
-r file     检测文件是否可读，如果是，则返回 true。     [ -r $file ] 返回 true。
-w file     检测文件是否可写，如果是，则返回 true。     [ -w $file ] 返回 true。
-x file     检测文件是否可执行，如果是，则返回 true。     [ -x $file ] 返回 true。
-s file     检测文件是否为空（文件大小是否大于0），不为空返回 true。     [ -s $file ] 返回 true。
-e file     检测文件（包括目录）是否存在，如果是，则返回 true。     [ -e $file ] 返回 true。

字符串
shell编程中最常用最有用的数据类型（除了数字和字符串，也没啥其它类型好用了），字符串可以用单引号，也可以用双引号，也可以不用引号。单双引号的区别跟PHP类似。
单引号   
    str='this is a string'
    单引号里的任何字符都会原样输出，单引号字符串中的变量是无效的；
    单引号字串中不能出现单引号（对单引号使用转义符后也不行）。

双引号
    your_name='qinjx'
    str="Hello, I know your are \"$your_name\"! \n"：
    双引号里可以有变量
    双引号里可以出现转义字符

拼接字符串
    your_name="qinjx"
    greeting="hello, "$your_name" !"
    greeting_1="hello, ${your_name} !"
    echo $greeting $greeting_1

获取字符串长度
    string="abcd"
    echo ${#string} #输出 4

提取子字符串
    string="alibaba is a great company"
    echo ${string:1:4} #输出liba

查找子字符串
    string="alibaba is a great company"
    echo `expr index "$string" is`   expr index 只输出查到到的第一个字符， i 和 a 的位置分别是 3和5. l

array_name=(value0 value1 value2 value3)
array_name[0]=value0
array_name[1]=value1
array_name[2]=value2
valuen=${array_name[2]}
echo "Second Index: ${NAME[1]}"
使用@ 或 * 可以获取数组中的所有元素，例如：
    ${array_name[*]}
    ${array_name[@]}
echo "First Method: ${NAME[*]}"
echo "Second Method: ${NAME[@]}"
# 取得数组元素的个数
length=${#array_name[@]}
# 或者
length=${#array_name[*]}
# 取得数组单个元素的长度
lengthn=${#array_name[n]}

printf 命令用于格式化输出， 是echo命令的增强版。它是C语言printf()库函数的一个有限的变形，并且在语法上有些不同。
$ printf "%d %s\n" 1 "abc"
根据POSIX标准，浮点格式%e、%E、%f、%g与%G是“不需要被支持”。这是因为awk支持浮点预算，且有它自己的printf语句。

Shell 有三种 if ... else 语句：
if ... fi 语句；
if ... else ... fi 语句；
if ... elif ... else ... fi 语句。

case 语句匹配一个值或一个模式，如果匹配成功，执行相匹配的命令。case语句格式如下：
echo 'Your number is:\c'
read aNum
case $aNum in
    1)  echo 'You select 1'
    ;;
    2)  echo 'You select 2'
    ;;
    3)  echo 'You select 3'
    ;;
    4)  echo 'You select 4'
    ;;
    *)  echo 'You do not select a number between 1 to 4'
    ;;
esac

for循环一般格式为：
for 变量 in 列表
do
    command
done

for loop in 1 2 3 4 5
do
    echo "The value is: $loop"
done

for FILE in $HOME/.bash*
do
   echo $FILE
done

while循环用于不断执行一系列命令，也用于从输入文件中读取数据；命令通常为测试条件。其格式为：
while command
do
   Statement(s) to be executed if command is true
done

COUNTER=0
while [ $COUNTER -lt 5 ]
do
    COUNTER='expr $COUNTER+1'
    echo $COUNTER
done
    
    
until 循环执行一系列命令直至条件为 true 时停止。until 循环与 while 循环在处理方式上刚好相反。一般while循环优于until循环，但在某些时候，也只是极少数情况下，until 循环更加有用。
until 循环格式为：
until command
do
   Statement(s) to be executed until command is true
done
command 一般为条件表达式，如果返回值为 false，则继续执行循环体内的语句，否则跳出循环。
使用 until 命令输出 0 ~ 9 的数字：
#!/bin/bash
a=0
until [ ! $a -lt 10 ]
do
   echo $a
   a=`expr $a + 1`
done

break命令允许跳出所有循环（终止执行后面的所有循环）。
break n   表示跳出第 n 层循环。
#!/bin/bash
for var1 in 1 2 3
do
   for var2 in 0 5
   do
      if [ $var1 -eq 2 -a $var2 -eq 0 ]
      then
         break 2
      else
         echo "$var1 $var2"
      fi
   done
done
    
 continue命令
continue命令与break命令类似，只有一点差别，它不会跳出所有循环，仅仅跳出当前循环。
continue 后面也可以跟一个数字，表示跳出第几层循环。

 

Shell 函数的定义格式如下：
function_name () {
    list of commands
    [ return value ]
}
也可以在函数名前加上关键字 function：
function function_name () {
    list of commands
    [ return value ]
}

函数返回值，可以显式增加return语句；如果不加，会将最后一条命令运行结果作为返回值。
Shell 函数返回值只能是整数，一般用来表示函数执行成功与否，0表示成功，其他值表示失败。
如果 return 其他数据，比如一个字符串，往往会得到错误提示：“numeric argument required”。

在Shell中，调用函数时可以向其传递参数。在函数体内部，通过 $n 的形式来获取参数的值，
例如，$1表示第一个参数，$2表示第二个参数...  $10 不能获取第十个参数，获取第十个参数需要${10}。当n>=10时，需要使用${n}来获取参数。
#!/bin/bash
funWithParam(){
    echo "The value of the first parameter is $1 !"
    echo "The value of the second parameter is $2 !"
    echo "The value of the tenth parameter is $10 !"
    echo "The value of the tenth parameter is ${10} !"
    echo "The value of the eleventh parameter is ${11} !"
    echo "The amount of the parameters is $# !"  # 参数个数
    echo "The string of the parameters is $* !"  # 传递给函数的所有参数
}
funWithParam 1 2 3 4 5 6 7 8 9 34 73
$#     传递给函数的参数个数。
$*     显示所有传递给函数的参数。
$@     与$*相同，但是略有区别，请查看Shell特殊变量。
$?     函数的返回值。

 输出重定向
命令的输出不仅可以是显示器，还可以很容易的转移向到文件，这被称为输出重定向。
命令输出重定向的语法为：
    $ command > file
这样，输出到显示器的内容就可以被重定向到文件。
例如，下面的命令在显示器上不会看到任何输出：
    $ who > users
打开 users 文件，可以看到下面的内容：
$ cat users
oko         tty01   Sep 12 07:30
ai          tty15   Sep 12 13:32
ruth        tty21   Sep 12 10:10
pat         tty24   Sep 12 13:07
steve       tty25   Sep 12 13:03
$

 输入重定向
和输出重定向一样，Unix 命令也可以从文件获取输入，语法为：
    command < file
这样，本来需要从键盘获取输入的命令会转移到文件读取内容。
注意：输出重定向是大于号(>)，输入重定向是小于号(<)。

默认情况下，command > file 将 stdout 重定向到 file，command < file 将stdin 重定向到 file。
如果希望 stderr 重定向到 file，可以这样写：
    $command 2 > file
如果希望 stderr 追加到 file 文件末尾，可以这样写：
    $command 2 >> file

全部可用的重定向命令列表
command > file     将输出重定向到 file。
command < file     将输入重定向到 file。
command >> file     将输出以追加的方式重定向到 file。
n > file     将文件描述符为 n 的文件重定向到 file。
n >> file     将文件描述符为 n 的文件以追加的方式重定向到 file。
n >& m     将输出文件 m 和 n 合并。
n <& m     将输入文件 m 和 n 合并。
<< tag     将开始标记 tag 和结束标记 tag 之间的内容作为输入。

 /dev/null 文件
如果希望执行某个命令，但又不希望在屏幕上显示输出结果，那么可以将输出重定向到 /dev/null：
    $ command > /dev/null
/dev/null 是一个特殊的文件，写入到它的内容都会被丢弃；如果尝试从该文件读取内容，那么什么也读不到。但是 /dev/null 文件非常有用，将命令的输出重定向到它，会起到”禁止输出“的效果。
如果希望屏蔽 stdout 和 stderr，可以这样写：
    $ command > /dev/null 2>&1
    
    
Shell 也可以包含外部脚本，将外部脚本的内容合并到当前脚本。
Shell 中包含脚本可以使用：
    . filename
或
    source filename
两种方式的效果相同，简单起见，一般使用点号(.)，但是注意点号(.)和文件名中间有一空格。
例如，创建两个脚本，一个是被调用脚本 subscript.sh，内容如下：
    url="http://www.baidu.com"
一个是主文件 main.sh，内容如下：
    #!/bin/bash
    . ./subscript.sh
    echo $url
注意：被包含脚本不需要有执行权限。

 

转载于:https://my.oschina.net/kenzheng/blog/857019