Shell(bash)编程

| 命令     | 说明                                     |
|----------|------------------------------------------|
| :        | 空，永远返回true                         |
| .        | 从当前shell中执行操作                    |
| break    |                                          |
| cd       |                                          |
| continue |                                          |
| echo     |                                          |
| eval     | 先扫描命令行进行所有的置换，然后执行命令 |
| exec     | 执行命令，不在当前shell                  |
| exit     |                                          |
| export   |                                          |
| pwd      |                                          |
| read     |                                          |
| readonly |                                          |
| return   |                                          |
| set      |                                          |
| shift    | 去除前n个输入参数                        |
| test     | 评估条件表达式                           |
| times    |                                          |
| trap     | 当捕获信号时执行指定命令                 |
| ulimit   | 显示或设置shell资源                      |
| umask    |                                          |
| unset    | 清除变量                                 |
| wait     | 等待子进程运行完毕                       |
| type     | 命令是否有效和在系统中的位置             |
| logger   | 写入系统日志文件                         |
| local    | 定义局部变量                             |

let arg [arg ...]
Each arg is an arithmetic expression to be evaluated (see ARITHMETIC EVALUATION above).
If the last arg evaluates to 0, let returns 1; 0 is returned otherwise.

+：对两个变量做加法。
-：对两个变量做减法。
*：对两个变量做乘法。
/：对两个变量做除法。
**：对两个变量做幂运算。
%：取模运算，第一个变量除以第二个变量求余数。
+=：加等于，在自身基础上加第二个变量。
-=：减等于，在第一个变量的基础上减去第二个变量。
*=：乘等于，在第一个变量的基础上乘以第二个变量。
/=：除等于，在第一个变量的基础上除以第二个变量。
%=: 取模赋值，第一个变量对第二个变量取模运算，再赋值给第一个变量

let a+=1        //echo $a: 1
let a+=1        //echo $a: 2

let a=2**2 b=1  //a=2^2 b=1

test expr  或者 [ expr ]
Return a status of 0 (true) or 1 (false) depending on the evaluation of the conditional expression expr.  

exec [-cl] [-a name] [command [arguments]]

If command is specified, it replaces the shell.  No new process is created.
-l: the shell places  a  dash  at the  beginning of  the  zeroth argument passed to command
-c: causes command to be executed with an empty environment
-a: passes name as the zeroth argument to the executed command ```

eval [arg ...]

The args are read and concatenated together into a single command.
This command is then read and executed by the shell, and its exit status is returned as the value of eval.  If there are no args, or only null arguments, eval returns 0

-c string:     从string读取命令
-i:            交互式运行
-r:            RESTRICTED SHELL
-O [options]:  设置shell内置命令的选项
+O [options]:  取消shell内置命令选项的设置
--:            表示Options结束, --之后的字符被当作文件名和传入参数

set [--abefhkmnptuvxBCHP] [-o option] [arg ...]

[time [-p]] [ ! ] command [ | command2 ... ]

time: 显示整个pipline的执行时间
-p:   指定输出格式
!:    对pipline的结果取反

set -o pipefail

;   &   &&   ||

;   &   <newline>

&    命令在后台的执行，前台shell不等待命令执行的完成，立即得到返回值0。
;    分割开的命令单独执行，前台等待每个命令完成，返回的是最后一个命令的退出状态。
&&   只有前面的命令的返回值是0，才会执行后面的命令，返回最后一个命令的退出状态。
||   只有前面的命令的返回值非0，才会执行后面的命令，返回最后一个命令的退出状态。

( list )
    list在一个独立的shell环境中运行，运行时对shell做的设置，在运行结束后失效。
    返回list的退出状态

{ list; }
    list在当前shell环境中运行，命令必须用换行符或者分号标记结束。
    返回list的退出状态
    注意`{`和`}`必须用空格与后面或者前面都字符区分开。

((expression))
    算术表达式计算，如果结果非0，返回0，否则返回1
    等同于 `let "expression"`

[[ expression ]]
    条件表达式计算，
    ==,!= :  检查左侧是否匹配了右侧的正则表达式(Pattern Matring)
             shell option nocasematch，设置是否忽略大小写
             如果匹配结果与表达式一致，返回0
    =~:      检查左侧是否匹配右侧的扩展的正则表达式(regex(3))
             匹配返回0，不匹配返回1
             正则表达式语法错误，返回2
             如果匹配结果与表达式一致，返回0
             表达式匹配的字符串存放在数组BASH_REMATCH
             BASH_REMATCH[0]: 整个表达式匹配的字符串
             BASH_REMATCH[n]: 第n个括号中的表达式匹配的字符串
   注意右侧的正则应当这么写:  if [[ "aaaa" == "a"* ]]

for name [ in word ] ; do list ; done
     如果没有`in word`，就遍历位置参数(positional parameter)
     返回最后一次list执行的退出状态
     如果word是空的，返回0

for (( expr1 ; expr2 ; expr3 )) ; do list ; done
     对表达式expr1执行算术运算
     对表达式expr2执行算术运算，如果结果非0，执行list，并对表达式expr3执行算数运算
     如果表达式为空，认为是1
     返回最后一次list的执行退出状态
     如果任意一个表达式错误，放回false

select name [ in word ] ; do list ; done
     在stderr列出所有的word，提示选择，name的值将为选择的字符串
     如果在list中，没有遇到`break`，重复这一个过程
     返回最后一个命令的退出状态
     如果没有命令被执行，返回0

case word in [ [(] pattern [ | pattern ] ... ) list ;; ] ... esac
     按照Pathname  Expansion的规则，寻找能够匹配word的pattern，执行后面的对应的list
     只有第一个匹配有效
     返回执行的命令的退出状态
     如果没有匹配，返回0

if list; then list; [ elif list; then list; ] ... [ else list; ] fi
     如果list退出状态为0，那么执行
     返回执行的命令的退出状态
     如果命令执行，返回0
      
while list; do list; done
until list; do list; done

[ function ] name () compound-command [redirection]

function a()  ( ls / ) >log

\a     alert (bell)
\b     backspace
\e     an escape character
\f     form feed
\n     new line
\r     carriage return
\t     horizontal tab
\v     vertical tab
\\     backslash
\'     single quote
\nnn   the eight-bit character whose value is the octal value nnn (one to three digits)
\xHH   the eight-bit character whose value is the hexadecimal value HH (one or two hex digits)
\cx    a control-x character

name=[value]
name+=[value]

alias
declare
typeset
export
readonly
local

When a positional parameter consisting of more than a single digit is expanded, it must be enclosed in braces (see EXPANSION below)

*:    如果位于双引号中(例如"$*")，value是将位置参数用$IFS链接起来后结果，整体是一个word
@:    如果位于双引号中(例如"$@")，每个位置参数被解读为一个word，是多个word
#:    位置参数的个数
?:    上一个前台命令状态
-:    已经设置了的option，通过通过set命令设置的，和shell启动时传入的
$:    当前shell的进程ID，如果是在子shell中，返回的也是当前shell的进程ID，不是子shell的
!:    上一个后台命令的进程ID
0:    shell或者shell脚本的名称，如果通过bash调用脚本，$0是脚本名，如果是`bash -c`的方式，$0是第一个参数
_:    shell或者shell脚本的绝对路径

for i in "$*" ;do echo a$i; done
for i in "$@" ;do echo b$i; done

bash ./a.sh  1 2 3 4 5
a1 2 3 4 5
b1
b2
b3
b4
b5

${parameter:-word}:  Use Default Values.
${parameter:=word}:  Assign  Default  Values.
${parameter:?word}:  Display Error if Null or Unset.
${parameter:+word}:  Use Alternate Value.
${parameter:offset}:        Substring  Expansion.
${parameter:offset:length}: Substring  Expansion.
${!prefix*}:   Expands to the names of variables whose names begin with prefix
               separated by the first character of the IFS special variable.
${!prefix@}:   Expands to the names of variables whose names begin with prefix
               separated by the first character of the IFS special variable.
${!name[@]}
${!name[*]}
${#parameter}
${parameter#word}
${parameter##word}
${parameter%word}
${parameter%%word}
${parameter/pattern/string}

-a file       True if file exists.
-b file       True if file exists and is a block special file.
-c file       True if file exists and is a character special file.
-d file       True if file exists and is a directory.
-e file       True if file exists.
-f file       True if file exists and is a regular file.
-g file       True if file exists and is set-group-id.
-h file       True if file exists and is a symbolic link.
-k file       True if file exists and its ``sticky'' bit is set.
-p file       True if file exists and is a named pipe (FIFO).
-r file       True if file exists and is readable.
-s file       True if file exists and has a size greater than zero.
-t fd         True if file descriptor fd is open and refers to a terminal.
-u file       True if file exists and its set-user-id bit is set.
-w file       True if file exists and is writable.
-x file       True if file exists and is executable.
-G file       True if file exists and is owned by the effective group id.
-L file       True if file exists and is a symbolic link.
-N file       True if file exists and has been modified since it was last read.
-O file       True if file exists and is owned by the effective user id.
-S file       True if file exists and is a socket.
file1 -ef file2  True if file1 and file2 refer to the same device and inode numbers.
file1 -nt file2  True if file1 is newer (according to modification date) than file2, 
                 or if file1 exists and file2 does not.
file1 -ot file2  True if file1 is older than file2, or if file2 exists and file1 does not.
-o optname       True if the shell option optname is enabled.  
                 See the list of options under the description of the -o option to the set builtin below.
-v varname       True if the shell variable varname is set (has been assigned a value).
-R varname       True if the shell variable varname is set and is a name reference.
-z string        True if the length of string is zero.
string /-n string    True if the length of string is non-zero.
string1 == string2
string1 = string2    True if the strings are equal.  = should be used with the test command for POSIX conformance.  
                     When used with the [[ command, this performs pattern matching as described above (Compound Commands).
string1 != string2   True if the strings are not equal.
string1 < string2    True if string1 sorts before string2 lexicographically.
string1 > string2    True if string1 sorts after string2 lexicographically.
arg1 OP arg2         OP  is  one  of  -eq, -ne, -lt, -le, -gt, or -ge.  
                     These arithmetic binary operators return true if arg1 is equal to, not equal to, 
                     less than, less than or equal to, greater than, or greater than or equal to arg2, respectively.  
                     Arg1 and arg2 may be positive or negative integers.

=     相等
!=    不相等
-z    空串
-n    非空串

-eq   equal
-ne   not equal
-gt   great
-lt   little
-le   litter or equal
-ge   great or littel

| 操作      | 测试条件                                 |
|-----------|------------------------------------------|
| -e        | 文件是否存在                             |
| -f        | 是一个标准文件                           |
| -d        | 是一个目录                               |
| -h        | 文件是一个符号链接                       |
| -L        | 文件是一个符号链接                       |
| -b        | 文件是一个块设备                         |
| -c        | 文件是一个字符设备                       |
| -p        | 文件是一个管道                           |
| -S        | 文件是一个socket                         |
| -t        | 文件与一个终端相关联                     |
| -N        | 从这个文件最后一次被读取之后, 它被修改过 |
| -O        | 这个文件的宿主是你                       |
| -G        | 文件的组id与你所属的组相同               |
| !         | "非" (反转上边的测试结果)                |
| -s        | 文件大小不为0                            |
| -r        | 文件具有读权限                           |
| -w        | 文件具有写权限                           |
| -x        | 文件具有执行权限                         |
| -g        | 设置了sgid标记                           |
| -u        | 设置了suid标记                           |
| -k        | 设置了"粘贴位"                           |
| F1 -nt F2 | 文件F1比文件F2新 *                       |
| F1 -ot F2 | 文件F1比文件F2旧 *                       |
| F1 -ef F2 | 文件F1和文件F2都是同一个文件的硬链接 *   |

yum install -y jq

BASIC FILTERS
   .
       The absolute simplest (and least interesting) filter is .. This is a filter that takes its input and produces it unchanged as output.
       Since jq by default pretty-prints all output, this trivial program can be a useful way of formatting JSON output from, say, curl.
           jq ´.´
              "Hello, world!"
           => "Hello, world!"

$ echo '{"age":"13" ,"name": "li"}'  |jq "."
{
  "age": "13",
  "name": "li"
}

$ echo '{"age":"13" ,"name": "li"}'  |jq ".name"
"li"

jq ´.[]´
   [{"name":"JSON", "good":true}, {"name":"XML", "good":false}]
=> {"name":"JSON", "good":true}, {"name":"XML", "good":false}

kubectl get ns | awk '{ if(NR>1) print $1 }

comm [-123i] file1 file2
 -1      Suppress printing of column 1.         
 -2      Suppress printing of column 2.         
 -3      Suppress printing of column 3.         
 -i      Case insensitive comparison of lines.

grep -v -f file1 file2

将一个数学运算写到$[]符号的中括号中，中括号中的内容将先进行数学运算，使用变量，以及赋值给变量:

echo $[1+1]
echo $[a=1]     //a=1
echo $[b=$a+1]  //b=2

man expr

expr 1 + 2

man sed

[address[,address]]function[arguments]

sed -e "1d"   ##d就是function,没有参数

man re_format

sed -n '2,4p' a.txt  
sed -n '/pattern/p' a.txt
sed -n '2,4/pattern/p' a.txt

sed '1,2l' a.txt 

sed -n '/pattern/=' a.txt
sed -n -e '/pattern/=' -e '/pattern/p' a.txt

sed '/pattern/a\new text' a.txt 

sed '/pattern/i\new text' a.txt 

sed '/pattern/c\new text' a.txt

sed '1,2d' a.txt 
sed '/pattern/d' a.txt

sed 's/pattern/newtext/'  a.txt          替换每行的第一个
sed 's/pattern/newtext/g'  a.txt         全局替换 
sed 's/pattern/newtext/p'  a.txt         显示到标准输出
sed 's/pattern/newtext/w file'  a.txt    将被替换后的行保存到file
sed 's/pattern/newtext &/p' a.txt        &代表的是pattern匹配的字符

sed '/pattern/r file2' file1    用file2中的内容替换file1中的pattern

sed '1,4 w filename'  a.txt

sed '/pattern/q' a.txt

Minimal Repetitions (available for enhanced extended REs only)

a*     匹配结果为： aaaaba
a*?    匹配结果为： a
.*?b   匹配结果为： aaaab

echo "aaaababb" |sed 's/[^b]*b/OOO/'  

可以看到“[^b]*b”的匹配效果与“.*?b”相同

find . -path '/src' -prune -o -print

find . -path '/src' -exec COMMAND {}+

http://churuimin425.blog.163.com/blog/static/341298772012230112956712/
方法一

    shell> sort -k2n file | uniq > a.out

方法二 

    shell> sort -k2n file | awk '{if ($0!=line) print;line=$0}'

方法三

    shell> sort -k2n file | sed '$!N; /^\(.*\)\n\1$/!P; D'

date [+FORMAT] 例如
    date %y-%m-%d-%H-%M-%S

set -n 读命令但不执行

set -v 显示读取的所有行

set -x 显示所有命令及其参数

set -m 监视器模式

set +x 关闭x选项

trap ""   signal   ## 忽略sginal
trap signal        ## 复位signal

var=xxxx

{var:-value}   如果定了变量var，则使用var，否则使用value
{var:=value}   如果没有定义var，定义并赋值value, 使用定以后的var
${var:offset}  var的值的子字符串
${var:offset:length} 

${!prefix*}
${!prefix@}

readonly var 
readonly 显示所有的只读变量

local [option] [name[=value]...]

option 
   -a  name is an array variable 
   -f  use function names only
   -i  name is an integer
   -r  name is readonly
   -t  give name the trace attribute
   -x  export name to subsequent commands via the environment

set  

unset

var=value
export var

env 

unset var 

HOME    home路径
LOGNAME 登录名
MAIL    邮箱路径名
PATH    查找目录顺序
PS1     shell提示符，缺省值为超级用户##，其他用户$
PS2     附属提示符，用于提示多行命令，缺省为>
SHELL   缺省shell
TERM    终端类型，vt100 vt200 linux等
PWD     当前路径

$0            参数0, 运行程序
$1-$9-${10}.. 参数
$##            参数个数
$*            所有参数，不包括$0
$@            所有参数，不包括$0
$$            当前进程ID 
$!            后台运行的最后一个进程的ID 
$?            最后命令的退出状态，0表示没有错误

declare -a array

array[index]= value

for i in ${array[@]}
do
    echo $i
done

for i in ${!array[@]}
do
    echo $i
done

echo ${!array[@]}

echo ${##array[@]}

echo ${##array[3]}

${!name[@]}
${!name[*]}
这个是针对name数组的，打印出来name数组有哪些下标

可解除字符$(美元符号) `(反引号)  \(反斜线) 外的任意字符

单引号忽略任何引用值 

反引号中的内容作为系统命令执行,在双引号内可照常使用

屏蔽特殊函数，可以屏蔽反引号`

case $var in
value) command
;;
value) command
;;
*) command
esac

for  var in values
do
    command
done

until  条件
do
    command
done

while  value
do
    command
done

i=0
while [ $i -lt 10 ];do
	let i+=1
	echo $i
done

跳出循环

立即开始下一个循环 

函数名()
{
    command
}

function 函数名()
{
    command
}

## 和向脚本传递参数相同，使用特殊变量$0 $1 ... $9 

## 函数返回值保存在$?中 

compare() $a $b $c     ## 调用
if[ $? = 0 ]           ## $?是函数的返回值

.   /path/function.sh    ## 引入了函数文件

将参数向左偏移一位 

eval echo \$$## 
shift 'expr $## -2'

分别处理 -a -h -f参数
$OPTARG是对应参数后面的值，必须使用$OPTARG
:表示前面的选项必须指定参数值
在最前面放置:,可屏蔽缺值提示，如:ah:f
while getopts ah:f OPTION
do
    case $OPTION in
    a)
     ;;
    h)
     ;;
    f)  echo $OPTARG
     ;;
    esac
done

cat -v
//输入F1等功能键

Generic method:   echo '<Ctrl-v><ESCAPE>[背景色编码;前景色编码m'
System V      :   echo '\033[背景色编码;前景色编码m'
Linux/bsd     :   echo -e '\033[背景色编码;前景色编码m]'

| 颜色 | 前景色编码 | 背景色编码 |
|------|------------|------------|
| 黑色 | 30         | 40         |
| 红色 | 31         | 41         |
| 绿色 | 32         | 42         |
| 黄色 | 33         | 43         |
| 蓝色 | 34         | 44         |
| 紫色 | 35         | 45         |
| 青色 | 36         | 46         |
| 白色 | 37         | 47         |

echo $((16##a));将十六进制数a转换为十进制数表示出来 
echo $((5##3));将5进制数3转换为十进制数表示出来 

${parameter##word}
${parameter###word}

##为最短匹配，##为最长匹配

${parameter%word}
${parameter%%word}

%为最短匹配，%%为最长匹配

${parameter/pattern/string}
${parameter//pattern/string}
将parameter对应值的pattern字符串替换成为string字符串

/表示只替换一次
//表示全部替换

修改 /etc/default/sysstat 文件， 将 ENABLED 设置为 true.

## 每秒钟统计一次，统计四次
sar -n DEV 1 4

-d  指定域分隔符
-f n,m  剪切域n-m,从1开始编号
-c n,m  第n-m个字符，注意不能和-f一起使用

getopt ab:cd -a -b he free cat

 -a -b he -- free cat

getopts  "参数说明"  变量名   

while getopts ":abc" opt ; do
	case $opt in
		a)
			echo $opt
			;;
		b)
			echo $opt
			;;
		c)
			echo $opt
			;;
		\?)
			echo Invalid
			exit 1
			;;
	esac
done