一、这里都是一个个独立的小例子

1、遇到一个诡异的问题

目标：将文件名后缀去掉，然后在上层目录下，建立一个同名目录，然后将.zip压缩包的内容全部解压过去

# echo 文件名.zip | sed -e 's/\.zip$//' 这是将后缀名去掉
# echo 文件名.zip | sed -e 's/\.zip$//' | xargs -i mkdir ../unzipPath/{}

此时试图在上层目录创建一个文件夹，但是｛｝的内容为空，将其打印出来显示也为空
# echo 文件名.zip | sed -e 's/\.zip$//' | xargs -i echo ../unzipPath/{}

==>>试图变通，未果：
# echo 文件名.zip | sed -e 's/\.zip$//' | xargs -i mkdir -p {} && mv {} ../unzipPath/

继续尝试，将  xargs -i mkdir ../unzipPath/{} 改为  xargs -i mkdir ‘../unzipPath/{}’，则在目标文件夹发现，新增了一个目录，名称为随机乱码

但是 xargs -i mkdir ‘../unzipPath/{}’ 显示的却是预期的文件名

再次尝试： xargs -i mkdir ../unzipPath/\{\} 同样增加了一个乱码目录名，而 xargs -i echo ../unzipPath/\{\} 却是预期的文件名

第二个困惑，大目录查询报错问题，不知道如何解决
对查询全部项目中的文件，搜索关键字
grep -rni keyWords `find ../../ -name *.c`

这种格式很漂亮，能找出对应C文件，在哪行有关键字。
但是当目录下C文件太多时，会报错：
-sh: /usr/bin/grep: Arguments list too long

此时只能换一种写法：
find ../../ -name *.c | xargs -i grep -rni keyWords {} -color
此方法虽然也能查找到几个调用，但是却无法显示相应文件。
无法让人满意

二、linux shell 显示风格

PS1="\[\e37;40\] [\[\e[32;40m\] \u \[\e[37;40m\] @\h\[\e[36;40m\]\W\[\e[0m\]]\\$"
最后的\\$ 可以替换为 #，如果是\\#则会发生转意，打印操作行数

I、字符串替换小工具

[zhoujinhua@ prj] vi replace.sh

#显然 $# 表示参数的个数
if [ "$#" -lt "2" ];then
    echo 'error, please input src_str dst_str'
    exit
fi

# $1 表示第一个参数e
echo $1
echo $2

#先把包含关键字 $1 的文件打印出来
echo `grep -rn $1 ./ -rl`

# 所所有包含关键字 $1 的文件，里面的 $1 都替换成 $2
sed -i -e 's/$1/$2/g' `grep -rn $1 ./ -rl`

此脚本调用方法：
[zhoujinhua@ prj] ./replace.sh str_source str_dest

II、 shell 下程序级联调用

#!/bin/sh
python a.py

# 如果 a.py 返回值大于等于128，则执行 b.py
if [ $? -ge 128 ]; then
    python b.py
fi

二、patsubst 函数的级联使用方法

obj = $(patsubst %.c,%.o, $(patsubst %.S, %.o, $(patsubst %.s, %.o，$(DIR))))

解释：
1、$(DIR) 为一个目录，是一个路径变量，其展开后，可以是 *.c *.h *.s *.S ...
2、先执行第三个 patsubst:
      $(patsubst %.s, %.o，$(DIR)) 将其中所有 *.s 变成 *.o
3、再执行第二个 patsubst:
      $(patsubst %.S, %.o, $(patsubst %.s, %.o，$(DIR))) 将所有 *.S 变成 *.o
4、最后执行第一个patsubst，将所有 *.c 变成 *.o

三、echo -e的作用,man帮助的解释是，允许后面的输出进行转义

假设你是 echo -e "i will use \n $HOME" 输出的将是
i will use
/root(当前用户的主目录)

如果是 echo "i will use \n $HOME" 则输出是：
i will use \n $HOME

四、tar命令的使用

1、正常打包

tar -cvf ./abc.tar ./

2、排除某个目录打包

tar -vcf ./abc.tar ./  --exclude=./dir1 --exclude=./dir2/release
注意最后一个字符：
   是 --exclude=./dir1 而不是 --exclude=./dir1/

五、shell调试手段

1、相关资源

https://blog.csdn.net/u013516966/article/details/50913770

2、行号$LINENO，类似C语言LINE

3、函数名FUNCNAME，类似C语言func

    它是一个数组，${FUNCNAME[0]}为正在执行的函数名。而[1]是[0]的使用者，其余可以类推

4、为sh -x a.sh调试加上行号和函数名

“` PS4 第四级提示符变量，实际调试 sh -x 时，每行前打印的就是 PS4，在 Bash Shell 中，缺省的 PS4 值为 ‘+’号。 利用此特性，通过一些内置变量重定义 PS4 的值，即可达到增加调试的目的。

如： export PS4='+{LINENO:{FUNCNAME[0]}}'
然后在调试时添加 -x 选项执行脚本，就能得到第一句执行的行号及函数名

<pre><code class="">## 5、调试技巧set -v
“`c
在每次执行语句时，希望看到执行的具体内容，当然采用 sh -x a.sh 的办法也是可以的
这里介绍 set -v； xxx ; set +v
如：
set -v
echo good
set +v

六、shell 脚本参数

$# 表示参数个数
$1 表示第一个参数，$2 表示第二个参数 ...
$@ 表示参数列表，可以不做改动，继续向下面的函数传递

七、 shell脚本 shift命令的作用

1、shift 作用解释

如 shell 脚本的传入参数为 a b c d e
在脚本中执行一句 shift 2
则将会把入参变成： c d e

2、脚本样例

八、强制执行 shell 脚本生效

shell 脚本下，a.sh 中有一句：
cd ../../xx
切换到其它目录的语句。但是执行结束后，仍然在本地，没有实际切换过去
因为在 shell 脚本 a.sh 中，这一句执行完成之后，环境变量就释放了
如果需要使退出后仍然生效，可以这样写：
source cd ../../xx
然后再干别的操作。

或者另一种写法： cd ../../xx ; b.sh  也能达到效果，因为在同一行，环境变量还没有释放

九、获取 python 脚本的返回值，用于逻辑判断

1、例1

A、python 脚本的内容，返回一个值128

pi@raspberrypi:~/study/python $ cat a.py
exit(128)
pi@raspberrypi:~/study/python $

B、shell 脚本，判断其是否大于等于128

#!/bin/sh
python ./a.py
tmp=$?
echo ==$tmp==
if [$tmp -ge 128]; then  # 这里是错误语法
    echo "great or equal to 128"
else
    echo "little than 128"
fi
pi@raspberrypi:~/study/python $

C、注意事项，以上代码为错误代码，需要更正

pi@raspberrypi:~/study/python $ cat b.sh
#!/bin/dash
python ./a.py
tmp=$?
echo ==python return value : $tmp==
if [ "$tmp" -ge "128" ]; then
    echo "great or equal to 128"
else
    echo "little than 128"
fi
pi@raspberrypi:~/study/python $

i、注意1

“`shell 赋值语句，变量和值之间不能有空格，用等号直接相连
tmp = ? ==>> 这是错误的写法 tmp=? ==>> 正确写法

<pre><code class="">### ii、判断语句，中括号与变量之间，必须有空格，否则报错
“`c
if [tmp -ge 128]; then ==>> 写法错误，因为 tmp 与 [ 之间没有空格
if [ $tmp -ge 128 ]; then ==>> 正确写法

iii、大小符号意义

-eq  等于,如:if [ "$a" -eq "$b" ]
-ne  不等于,如:if [ "$a" -ne "$b" ]
-gt  大于,如:if [ "$a" -gt "$b" ]
-ge  大于等于,如:if [ "$a" -ge "$b" ]
-lt  小于,如:if [ "$a" -lt "$b" ]
-le  小于等于,如:if [ "$a" -le "$b" ]
<    小于(需要双括号),如:(("$a" < "$b"))
<=   小于等于(需要双括号),如:(("$a" <= "$b"))
>    大于(需要双括号),如:(("$a" > "$b"))
>=   大于等于(需要双括号),如:(("$a" >= "$b"))

iv、注意，raspBeryyPi推荐系统，运行的脚本是 /bin/dash

#!/bin/dash 而不是 #!/bin/sh
但是后来为什么两者效果没有差别？

D、最终执行效果

pi@raspberrypi:~/study/python $ cat a.py
exit(138)
pi@raspberrypi:~/study/python $ sh b.sh
==python return value : 138==
great or equal to 128
pi@raspberrypi:~/study/python $

pi@raspberrypi:~/study/python $ sh b.sh
==python return value : 118==
little than 128
pi@raspberrypi:~/study/python $

十、采用歪点子隐藏 shell 脚本输出

1、故意grep 查找一个不存在的字符串

cd -                  这条语句会打印新路径
cd - | grep error     这样就不会有输出

十一、shell 循环

1、for循环，算术类循环

A、风格一

#!/bin/bash
for((i=1;i<=10;i++));
do
    echo $(expr $i \* 3 + 1);
done

B、风格二

#!/bin/bash

for i in $(seq 1 10)
do
    echo $(expr $i \* 3 + 1);
done

C、风格三

#!/bin/bash

for i in {1..10}
do
    echo $(expr $i \* 3 + 1);
done

D、风格四

awk 'BEGIN{for(i=1; i<=10; i++) print i}'

2、字符性质循环

A、将当前目录的所有文件采用ls列出，然后逐一打印出来

#!/bin/bash

for i in `ls`;
do
    echo $i is file name\! ;
done

运行效果：
15900@DESKTOP-CGPRCF3 /cygdrive/d/bbbbbbbbb
$ sh test.sh
get_pic.bat is file name!
IMG_20181205_201517.jpg is file name!
IMG_20181207_195704.jpg is file name!
IMG_20181207_195721.jpg is file name!
IMG_20181207_195736.jpg is file name!
IMG_20181207_195749.jpg is file name!
IMG_20181207_195751.jpg is file name!
IMG_20181207_195755.jpg is file name!
IMG_20181208_123555.jpg is file name!
IMG_20181208_123826.jpg is file name!
IMG_20181208_184448.jpg is file name!
IMG_20181208_184458.jpg is file name!
IMG_20181208_184506.jpg is file name!
test.sh is file name!

B、将 shell 脚本参数逐个打印出来

$ cat test.sh
#!/bin/bash

echo para num is $#;
for i in $* ;
do
    echo $i is input chart\! ;
done

执行效果：
$ sh test.sh para1 para2 para3
para num is 3
para1 is input chart!
para2 is input chart!
para3 is input chart!

C、数组、列表类循环

#!/bin/bash

for i in f1 f2 f3 ;
do
    echo $i is appoint ;
done

运行效果：
15900@DESKTOP-CGPRCF3 /cygdrive/d/bbbbbbbbb
$ sh test.sh
f1 is appoint
f2 is appoint
f3 is appoint

D、字符串中的变量循环

15900@DESKTOP-CGPRCF3 /cygdrive/d/bbbbbbbbb
$ cat test.sh
#!/bin/bash

list="rootfs usr data data2"
for i in $list;
do
    echo $i is appoint ;
done

15900@DESKTOP-CGPRCF3 /cygdrive/d/bbbbbbbbb
$ sh test.sh
rootfs is appoint
usr is appoint
data is appoint
data2 is appoint

3、路径查找类循环

A、查找用户wishcell下所有文件，不进行遍历

#!/bin/bash

for file in /home/wishcell/*;
do
    echo $file is file path \! ;
done

[root@localhost server]# sh test.sh
/home/wishcell/app-debug.apk is file path !
/home/wishcell/jquery-3.1.1.js is file path !
/home/wishcell/jquery-3.1.1.min.js is file path !
/home/wishcell/ngrok.exe is file path !
/home/wishcell/poc_new.py is file path !
/home/wishcell/poc.py is file path !
[root@localhost server]#

B、查找当前目录下的所有.sh文件

[root@localhost server]# cat test.sh
#!/bin/bash

for file in $(ls *.sh)
do
    echo $file is file path \! ;
done
[root@localhost server]#

[root@localhost server]# ls
a.c  a.c~  a.sh  b.sh  server.c  server.c~  test.sh

[root@localhost server]# sh test.sh
a.sh is file path !
b.sh is file path !
test.sh is file path !
[root@localhost server]#

4、for循环嵌套

for file in `cat file_list`
do
    for line in `cat $file`
    do
        echo $line;
    done
done

十二、坑

1、变量初始化，赋值

a=3    成功
a = 3  失败

2、变量在双引号中能正常替换，在单引号中变成了常量

a=3
echo "$a" 正常显示3
echo '$a' 显示$a，是一个字符串，十分坑人

3、超级巨坑

本以为只有单引号才是坑。
没想到双绰号的坑更大，坑了好长时间才回过味来，多少个夜晚AO过了。

linux命令行输入如下内容，反应完全不同：
[wishcell@localhost config]$ ls
db.cfg  grpc.cfg

加了双引号这是普通字符串
[wishcell@localhost config]$ echo "a *"
a *

不加双引号，就变成了 ls 的作用。做梦也没想到。尤其是在脚本程序中：
[wishcell@localhost config]$ echo a *
a db.cfg grpc.cfg

十三、实际项目

1、项目名称：自动匹配IP，然后登录到相应的linux服务器

A、基础知识：字符串比较玩法

i、判断字符串的包含关系

15900@DESKTOP-CGPRCF3 /cygdrive/d/sync_picture
$ if [ "abcd"=~"abc" ];then  echo "good"; fi
good

ii、判断字符串是否为空(1)

15900@DESKTOP-CGPRCF3 /cygdrive/d/sync_picture
$ mystr=

15900@DESKTOP-CGPRCF3 /cygdrive/d/sync_picture
$ if [ $mystr -eq ]
> then
> echo "mystring is empty";
> fi
mystring is empty

15900@DESKTOP-CGPRCF3 /cygdrive/d/sync_picture
$ if [ $mystr -eq ]; then echo "mystring is empty"; fi
mystring is empty

iii、判断字符串是否为空(2)

15900@DESKTOP-CGPRCF3 /cygdrive/d/sync_picture
$ if [ -n $mystr ]; then echo "mystring is empty"; fi
mystring is empty

iv、判断字符串为空(3)

15900@DESKTOP-CGPRCF3 /cygdrive/d/sync_picture
$ if [ "$mystr"=="" ]; then echo "mystring is empty"; fi
mystring is empty

15900@DESKTOP-CGPRCF3 /cygdrive/d/sync_picture
$ if [ x"$mystr"==x ]; then echo "mystring is empty"; fi
mystring is empty

B、基础知识：函数的定义与用法

i、函数定义

function Match_and_connect(){
    echo "file name   : $1"
    echo "line content: $2"
    echo "file name key    : $3"
    echo "line content key : $4"
    return
}

ii、函数的调用

# $(Match_and_connect "file_name" "line_content" "file_name_key" "line_content");

不需要考虑返回值的调用方法：
Match_and_connect "file_name" "line_content" "file_name_key" "line_content"

2、具体的项目代码

A、项目脚本用法

$ sh auto_login.sh j_masterstart.sh

B、auto_login.sh 源码

# 首先执行传进来的确参数(其实是一个脚本)
sh $1 ; echo $?
sleep 1s
script_name=`echo $1 | tr a-z A-Z`
old_IFS=$IFS
IFS=

C、README.txt中内容的样子

......
I_server
master ip:192.168.0.60
slave ip:192.168.0.61
lineone ip:192.168.0.78
linetwo ip:192.168.0.70
USER

J_server
master ip:192.168.0.100
slave ip:192.168.0.101
lineone ip:192.168.0.88
linetwo ip:192.168.0.80
USER

K_server
master ip:192.168.0.110
slave ip:192.168.0.111
lineone ip:192.168.0.98
linetwo ip:192.168.0.90
USER
......

D、脚本的样子

......
i-masterstart.sh i-slavestart.sh i-lineonestart.sh i-linetwostart.sh
......

4、运行效果

十四、向批量文件中插入内容

1、需求描述

有134个`.c`文件，需要向各个文件中插入一个`aa.h`，将其插入在第一行即可。

2、解决办法及步骤

A、将所有文件集中到一个文件中

find ./ name "*.c" > list

B、对list中的文件逐一操作，134个文件瞬间完成

cat list | xargs sed -i '1i\#include \"aa.h\"'

十五、快速解决编译错误，进入编译状态

1、需求描述

编译过程中，由于依赖某个头文件。造成整个目录中百余个文件都需要添加一行头文件引用。
但是每次改完之后，都需要重新编译，才会知道下一个文件是什么名字。大量的编译和查找时间浪费，
人肉操作极其耗时、枯燥、乏味

2、自制工具，编译失败时自别哪个文件缺少头文件。主动打开，等待手工操作，这是半自动化。手工添加后保存退出

touch qmake.sh
chmode +x qmake.sh

qmake.sh 中的内容如下
clear; make > log 2>&1

注释：先把保存的 log 打印出来，然后过滤掉包含有 BOOL 行，因为具体项目中有干扰。最后再把包含有 error 关键字的行及其前一行打印打印出来。正好作为字符串变量，赋值给 str
str=cat log | grep -v BOOL | grep error -B 1

这里是一个调试打印
echo “str is :str” filter_name_and_line(){ 这是调试打印，正式代码不能存在，否则就是错误代码 # echo “para num:# / all paras:@ / para1:1 / para2:$2…”
ret_str=echo $2 | tr -s "[:]" "[ ]"; echo ret_str } 将字符串全局变量输入后，得到一个 文件名，空格，行数，这是一个调试打印 echo (filter_name_and_line str) vim 已经可以粗略的对这个字符串进行编辑了，但是实上它带了两个参数，vim误把它当成两个文件。所以这个需要改进 vim (filter_name_and_line str) 把文件名、空格、等号的字符串，仅仅提取出文件名。只需要一个函数，把这个字符串当成参数传入，然后在函数体内，会把它当成多个参数，仅仅打印第一个参数就能够达到目标 filter_only_file(){ echo 1
}

注释：把之前的结果，filter_name_only 的参数，即达到目标。这是一个调试打印
echo (filter_only_file (filter_name_and_line str)) 最终成品的样子 vim (filter_only_file (filter_name_and_line str))

3、实际使用

每次输入 sh ./qmake.sh 后就会进入到一个 `.c`的打开状态，手动在里面添加一个头引用后。保存退出。
再次执行 ./qmake.sh，周而复始...

十六、快速用vimdiff对比目录，其中有大量同名文件

1、需求描述

有两个目录，存在大量同名文件，需要逐一对比，但是手工执行 `vimdiff /path1/file1 /path2/file1`效率很低，
不符合一个程序员的工作风格

2、思路

一个目录，经过不同人员修改，现在需要合并而已
 首先获得文件列表。`ls /path/`得到全都是不带路径的文件名
 ls /path/
 file1 file2 file3 file4 file5 ...
然后每次对比一对文件。根据输入的索引不同，对比的文件名不同

3、根据BDD思想，需要先确定业务的使用方式，最后开发

用法:

“`perl
./qvimdiff.sh 报错，提示需要带一个索引参数。表示第几个文件 ./qvimdiff.sh 1
然后进入 vimdiff ,对比两个文件 /path1/file1 和 /path2/file1

$ ./qvimdiff.sh 2
然后进入 vimdiff ,对比两个文件 /path1/file2 和 /path2/file2

4、代码实现

if [ $# -lt 1];
 then
     echo "please input at least 2 parameter"
     echo "usage: ./qvimdiff.sh 1"
     exit
 fi

 此函数有两个参数，第一参数为索引，第二个是文件列表
 show_nth_para(){
     因为函数有两个参数，但是第二个参数是以空格相隔的字符中。所以对于 shell 函数来说，实际上是有N+1个参数的，N是文件列表的个数。所以真正的file1，它的索引为2，以此类推
     file_idx=$(($1+1))
     I=0
     while 后面的中括号，必须和参数之间保留一个空格，否则报错
     while [ $I -lt $file_idx ]
     do
         把后面的参数转移到最前而，shift 执行一次，转一下
         shift
         变量I自加操作
         I=$(($I+1))
     done
     这就是转了N次之后，所得到的第N个文件名，把它打印出来，供函数调用都提取返回值
     echo "/path1/$1 /path2/$1"
 }

 print_dir_nth_file(){
     ls 是一个函数，/path1/ 是一个参数，返回值赋值给 ls_list
     ls_list="$(ls /path1/)"

     这里的$1是函数调用者传递过来的，表示文件名索引，第几个文件
     show_nth_para $1 $ls_list
 }

 这里的 $1 是linux 命令行传递进来的，表示文件名索引
 vimdiff $(print_dir_nth_file $1)

5、对qvimdiff.sh进行升级

A、需求描述

“`由于对比的目录太多。一个大目录./root下有许多小文件夹。以上脚本不够强大，无法支持。

<blockquote>
<h4>现在希望，在<code>./root</code>下执行脚本，能把<code>root/dir1/source/a.c</code>,<code>root/dir1/include/a.h</code>以及<code>./root/dir2/source/b.c</code>,<code>./root/dir2/include/b.h</code> 都列举出来，并采用 <code>vimdiff</code>打开。</h4>

<h4>如果<code>./root/dir2/source/a.c</code>不存在，则将<code>./root/dir1/source/a.c</code>删除</h4>
</blockquote>

<pre><code class="">### B、按照BDD设计思想，先把产品用法列出，列出实例化用例
“`c
> case 1: 仅仅在命令行输入 ./qvimdiff.sh ，后面不带文件索引参数，脚本应该报错并退出
>
> case 2，两个文件都存在，则用 vimdiff 打开两个文件,并处于编辑状态
> ./qvimdiff 1 > ./qvimdiff 2
> ./qvimdiff 3 > ./qvimdiff 4
>
> case 3: ./root/dir2/source/a.c 不存在，则要求删除 ./root/dir1/source/a.c，给出提示并退出

C、代码实现

第一部分，参数检查

if [ $# -lt 1 ]; then
    echo "error , please input file_idx"
    echo "usage: ./qvimdiff.sh 1"
    exit
fi

show_nth_para(){
    str_idx=$(($1+1))
    临时变量只能采用大写字母，不能小写
    I=0
    while [ $I -lt $str_idx ]
    do
        shift
        I=$(($I+1))
    done
    file1=$1
    这是一个 shell 正则表达式，将变量 file1 中的字符串 vomci 替换为 vomci2
    file2=${file1/vomci/vomci2}

    判断，如何第二个文件不存在
    if [ ! -f $file2 ]; then
        rm $file1
        echo "$file1 is removed"
        exit
    fi
    echo "$file1 file2"
}

print_nth_file(){
    find_str=`find $PWD/dir -name "*.[c|h]"`
    show_nth_para $1 $find_str
}

调试打印，看看输出是否符合预期
# print_nth_file $1

正式代码，这个 $1 是命令行传进来的第一个参数
vimdiff $(print_nth_file $1)

D、对qvimdiff.sh再次升级，只列列出不同文件，跳过相同文件

用到的知识点：
shell 下如何判断文件是否相同
首先看两个文件是否都存在`if  [ ! -f file_1 ]; then`
 然后用`md5sum`命令对两个文件计算，输出一个32位的字符串，后跟文件名
   sum1=`md5sum -t $file1`
   sum2=`md5sum -t $file2`

`md5sum`工具需要`root`权限才能使用
`md5sum`工具得到的字符串，前 32 位可以用来做对比，决断文件是否相
将前面`md5sum`
得到的字符串进行截取前`32`位。`id=${sum1:0:32}`

遍历函数所所有入参:
myFunc() {
   for i in $@
   do
      file1=$i
      shift
    done
}
myFunc aa bb cc dd

也可以写成
myFunc(){
    for i in $@ ;
    do {
        file1=$i
        shift
        echo $file1 is file name
    }
    done
 }
 myFunc "a b c d"

 还可以写成
 myFunc() {
     for i in $@ ; do {
         file1=$i
         shift
         echo $file1 is file name
     }
     done
 }
 myFunc "a b c d"

 myFunc() {
     for i in $@ ; do
     {
         file1=$i
         shift
         echo $file1 is file name
     } done
 }
 myFunc "a b c d"

利用函数返回值对比，而不采用中间变量
isFileSame $file1 $file2
if [ "$?" == "0" ]; then
    echo "file not same"
fi

完整的升级代码，实现对目录./下所有不同文件用vimdiff打开，相同文件跳过

十六、shell字符串正则表达式

1、采用grep来给搜索的内容上色

grep -rni xxx ./ --color

十七、shell字符串截取

假设有变量 var=http://www.aaa.com/123.htm

1. ‘#’ 号截取，删除左边字符，保留右边字符。

echo ${var#*//}

其中 var 是变量名，\# 号是运算符，*// 表示从左边开始删除第一个 // 号及左边的所有字符
即删除 http://
结果是 ：www.aaa.com/123.htm

2. “##” 号截取，删除左边字符，保留右边字符。

`echo ${var##*/}`

##*/ 表示从左边开始删除最后（最右边）一个 / 号及左边的所有字符
即删除 http://www.aaa.com/

结果是 123.htm

3. “%”号截取，删除右边字符，保留左边字符

echo ${var%/*}

%/* 表示从右边开始，删除第一个 / 号及右边的字符
结果是：http://www.aaa.com

4. “%%” 号截取，删除右边字符，保留左边字符

echo ${var%%/*}

%%/* 表示从右边开始，删除最后（最左边）一个 / 号及右边的字符
结果是：http:

5. 从左边第几个字符开始，及字符的个数

echo ${var:0:5}
其中的 0 表示左边第一个字符开始，5 表示字符的总个数。
结果是：http:

6. 从左边第几个字符开始，一直到结束。

echo ${var:7}

其中的 7 表示左边第8个字符开始，一直到结束。
结果是 ：www.aaa.com/123.htm

7. 从右边第几个字符开始，及字符的个数

echo ${var:0-7:3}

其中的 0-7(其实是负7)表示右边算起第七个字符开始，3 表示字符的个数。
结果是：123

8. 从右边第几个字符开始，一直到结束。

echo ${var:0-7}

表示从右边第七个字符开始，一直到结束。
结果是：123.htm

9、获取全路径中，文件名的方法:basename

# ls study/c/aa.c
study/c/aa.c

# basename study/c/aa.c
aa.c

十八、shell调试报错

1、括号不配对情况，关键字不配对情况

syntax error:unexpected end of file

十九、项目尝试自动删除多余的头文件。保证编译成功

>  但是此方案有一个缺陷，会造成某些重要函数声明丢失，进而引起严重故障，而且难查
>
> 优点：对于一个成熟项目，重复文件越少，检查越快，因为每个都是必不可少的引用，缺少则编译失败。而垃圾引用越多，检查就越慢，因为垃圾引用去除后，还要完整编译。不能增量编译

# 针对当前目录下所有源文件
list=`find ./ -name "*.c"`
for file_name in ${list}; do
    # 逐个文件提取 #include 的头文件行数。并将行号倒序，从大到小排列，
    # 方便从大到小行删除试错
    lines=`cat -n ${file_name} | grep '#include' | awk '{print $1}' | tac`
    tmp_content=''
    # 对单个 #include 进行尝试
    for line in ${lines}; do
        # 首先把这一行的 #include 内容原样保存，以防编译失败
        tmp_content=`sed -n "${line}p" ${file_name}`
        # 然后删除当前行的 #include 语句
        sed -i "${line}d" ${file_name}
        # 开始版本编译
        make rm
        if [ $? -eq 0 ]; then
            # 如果编译成功，则提示通过
            echo "pass"
        else
            # 如果编译失败，则将之前保存的当前 #include 内容插回到文件，将其恢复
            sed -i "${line} i${tmp_centent}" ${file_name}
        fi
     done
done

二十、采用sed实现的删除代码注释的功能（不够强大）

0、shell 基础判断

if [ -n ${str} ] 如果字符串长度大于 0
if [ -z ${str} ] 如果字符串长度等于 0
if [ str1 != str2 ]
if [ str1 == str2 ]

1、第一种实现方案

full_name=$1
dst_file=$2
if [ -z ${full_name} ]; then
    echo "no source file input"
    exit
fi

# 将完整路径以 / 分割，提取文件名，/home/path/abc.sh，则得到 abc.sh
short_name=`echo ${full_name} | tr -s '/' '[ ]' | awk '{print $NF}'`
# 把短文件名以'.' 分割，取第二段，即文件类型后缀，得到 sh
#`echo look.abc.sh.as.k | cut -f 1 -d '.'` ==>> look
#`echo look.abc.sh.as.k | cut -f 2 -d '.'`   ==>> abc
#`echo look.abc.sh.as.k | cut -f 3 -d '.'`   ==>> sh
post_fix=`echo ${short_name} | cut -f 2 -d '.' `

# 如果指定的接收注释后的文件名为空
if [ "${dst_file}" == "" ]; then
    #得到以'.'分割的完整路径的倒数第二段。若是 ./path/a.c 则得到 /path/a
    prefix=`echo ${full_name} | tr -s '[.]' '[ ]' | awk '{print $(NF - 1)}' `
    # 判断是否是以 / 开头
    first_char=`echo ${pre_fix}|grep ^\/`
    if [ -n ${first_char} ]; then
        #如果是以 / 开头，需要把 "."添加回去
        prefix="."${prefix}
    fi
    #得到一个临时文件
    target_file=${prefix}.temp
    touch ${target_file}
fi

case "${post_fix}" in
sh )
    sed "s/[[:space]]#.*//g" ${full_name} | sed '/^#/d' | \
    sed '/^[[:space:]]*$/g' | sed '/^$/d' > ${target_file}
    ;;
h | c | java )
    sed 's/\/\*.*\*\///g' ${full_name} | sed '/\/\*/,/.*\*\//d' | \
    sed 's/\/\/.*//g' | \
    sed '/s^[[:space:]]*$/d' | sed '/^$/d' > ${target_file}
    ;;
* )
   echo 'unknown file type'
   rm ${target_file}
esac

2、第二种实现方案

function delete_comment_file()
{
    file_name=$1
    #删除可能以空格开头的， //风格的注释
    sed -i '/^[ \t]*\/\//d' ${file_name}

    # 试图删除半路 // 风格的代码，但是保留例个，如代码中存在ftp://www.baidu.com 这种代码时
    # 但是实际效果没有保留成功
    sed -i 's/\/\/[^"]*//' ${file_name}

    # 删除C语言最基本的单行注释 /* assd */
    sed -i 's/\/\*.*\*\///' ${file_name}

    # 删除C语言块注释
    # /* adi
    # adf */
    sed -i 's/^[ \t]*\/\*,/.*\*\//d' ${file_name}
}

function delete_comment()
{
    for file in `ls`; do
        case ${file} in
          *.c )
              delete_comment_file ${file} ;;
          *.cpp ）
              delete_comment_file ${file} ;;
          *.h )
              delete_comment_file ${file} ;;
          * )
              if [ -d ${file} ]; then
                 cd ${file}; delete_comment; cd ..
              fi ;;
         esac
     done
}

my_dir=$1
if [ ! -e ${my_dir} ]; then
    echo "empty dir"
else
    cd ${my_dir}
    delete_comment
fi

二十、数组

1、数组定义

[root@localhost shell]$foo=(a b c)
[root@localhost shell]$echo ${foo[@]}
a b c
[root@localhost shell]$echo ${foo[0]}
a
[root@localhost shell]$echo ${foo[1]}
b
[root@localhost shell]$echo ${foo[2]}
c

2、数组追加元素

[root@localhost shell]$foo+=(d e f)
[root@localhost shell]$echo ${foo[5]}
f
[root@localhost shell]$echo ${foo[@]}
a b c d e f
[root@localhost shell]$echo ${foo[*]}
a b c d e f
[root@localhost shell]$echo ${#foo[*]}
6
[root@localhost shell]$echo ${#foo}
1
[root@localhost shell]$echo ${foo}
a
[root@localhost shell]$echo ${#foo[*]}
6
[root@localhost shell]$echo ${#foo[1]}
1
[root@localhost shell]$echo ${#foo[6]}
0
[root@localhost shell]$echo ${#foo[2]}
1
[root@localhost shell]$echo ${#foo[@]}
6

3、数组用法，引用元素和全部数组

[root@localhost shell]$echo ${foo[5]}
f
[root@localhost shell]$echo ${foo[@]}
a b c d e f
[root@localhost shell]$echo ${foo[*]}
a b c d e f

4、数组长度

[root@localhost shell]$echo ${#foo[*]}
6
[root@localhost shell]$echo ${#foo[1]}
1
[root@localhost shell]$echo ${#foo[6]}
0
[root@localhost shell]$echo ${#foo[2]}
1
[root@localhost shell]$echo ${#foo[@]}
6

5、数组所有元素，两种表示方法{foo[@]}和{foo[*]}的区别

[root@localhost study]$echo "${foo[@]}"
a b c d e f
[root@localhost study]$for i in "${foo[@]}"; do echo $i;done
a
b
c
d
e
f
[root@localhost study]$ for i in "${foo[*]}"; do echo $i; done
a b c d e f
[root@localhost study]$

6、数组的删除

[root@localhost study]$echo ${foo[@]}
a b c d e f
[root@localhost study]$unset foo
[root@localhost study]$echo ${foo[@]}
[root@localhost study]$

二十一、ls的乐趣

1、同时查看多个目录

[root@localhost study]$ls c/ tmp/
c/:
a.out       ftp          gtest-1.7.0.zip  option    ss.c            tt.c
find_ip     ftp2         hello.c          option.c  test_readdir    webserver
find_ip.c   ftp3         ip_result        pipe.c    test_readdir.c
find_ip.sh  gtest-1.7.0  massif.out.7238  ss.b      tt

tmp/:
wine-3.0.tar.xz
[root@localhost study]$

2、长格式查看

[root@localhost study]$ls c -l
total 1324
-rwxrwxrwx.  1 wishcell wishcell    8824 Jun 18  2018 a.out
-rwxrwxr-x.  1 wishcell wishcell    8560 Nov 24 14:01 find_ip
-rw-rw-r--.  1 wishcell wishcell     150 Nov 24 14:01 find_ip.c
-rw-rw-r--.  1 wishcell wishcell    6194 Nov 24 14:02 find_ip.sh
drwxrwxrwx.  4 wishcell wishcell      34 Jun 19  2018 ftp
drwxrwxrwx.  3 wishcell wishcell      17 Jun 19  2018 ftp2
[root@localhost study]$

关键字说明：
[root@localhost study]$ls c -l
total 1324
-rwxrwxrwx.  1 wishcell wishcell    8824 Jun 18  2018 a.out
-rwxrwxr-x.  1 wishcell wishcell    8560 Nov 24 14:01 find_ip
-rw-rw-r--.  1 wishcell wishcell     150 Nov 24 14:01 find_ip.c
-rw-rw-r--.  1 wishcell wishcell    6194 Nov 24 14:02 find_ip.sh
drwxrwxrwx.  4 wishcell wishcell      34 Jun 19  2018 ftp
drwxrwxrwx.  3 wishcell wishcell      17 Jun 19  2018 ftp2

第一列第一个字符，表示类型。
    `-`表示普通文件
    `d`表示目录
    `l`表示链接

二十二、cp/mv查漏补缺

1、-r参数，表示递归

2、-u参数，表示只复制目标文件夹中不存在的文件

3、-i参数，提醒用户确认，是否覆盖f

二十三、alias命令

1、查看系统中的别名

[wishcell@localhost tmp]$ alias
alias docker-machine='__docker_machine_wrapper'
alias egrep='egrep --color=auto'
alias fgrep='fgrep --color=auto'
alias grep='grep --color=auto'
alias l.='ls -d .* --color=auto'
alias ll='ls -l --color=auto'
alias ls='ls --color=auto'
alias vi='vim'
alias which='alias | /usr/bin/which --tty-only --read-alias --show-dot --show-tilde'

2、自己定义一个别名

[wishcell@localhost tmp]$ alias foo='cd /usr;ls;cd -'
[wishcell@localhost tmp]$ foo
bin  games    lib    libexec  sbin   src
etc  include  lib64  local    share  tmp
/home/wishcell/study/tmp
[wishcell@localhost tmp]$
[wishcell@localhost tmp]$ type foo
foo is aliased to `cd /usr;ls;cd -`
[wishcell@localhost tmp]$

3、删除别名

[wishcell@localhost tmp]$ unalias foo
[wishcell@localhost tmp]$ type foo
-bash: type: foo: not found
[wishcell@localhost tmp]$

二十四、head/tail命令

1、默认指定文件的前/后 10行

首先创建一个101行的文本文件：
[wishcell@localhost dir2]$ echo -e {1..100}"\n" >b.txt

确认文件行数：
[wishcell@localhost dir2]$ cat b.txt | wc -l
101

[wishcell@localhost dir2]$ head b.txt
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
[wishcell@localhost dir2]$ tail b.txt
 92
 93
 94
 95
 96
 97
 98
 99
 100

2、-n参数指定行数

[wishcell@localhost dir2]$ head -n 5 b.txt
 1
 2
 3
 4
 5
[wishcell@localhost dir2]$ tail -n 5 b.txt
 97
 98
 99
 100

[wishcell@localhost dir2]$

二十五、花括号{}扩展

1、基础示例

[wishcell@localhost dir2]$ echo front_{A,B,C}_back
front_A_back front_B_back front_C_back
[wishcell@localhost dir2]$

2、数字展开

[wishcell@localhost dir2]$ echo number_{1..5}
number_1 number_2 number_3 number_4 number_5
[wishcell@localhost dir2]$

3、字母展开

[wishcell@localhost dir2]$ echo {Z..A}
Z Y X W V U T S R Q P O N M L K J I H G F E D C B A
[wishcell@localhost dir2]$

4、复合展开

[wishcell@localhost dir2]$ echo a{A{1,2},B{3,4}}b
aA1b aA2b aB3b aB4b
[wishcell@localhost dir2]$

二十六、linux 命令行，光标控制

1、ctrl+A 光标移到行首
2、ctrl+E光标移到行尾
3、ctrl+L清除屏幕，保留当前行

二十七、程序由后台转到前台执行

1、示例

[wishcell@localhost dir2]$ vim &
[1] 29650
[wishcell@localhost dir2]$ fg vim
vim
或者执行 bg %1 也能达到同样效果。但是对后面数字没有把握

二十八、uniq命令

1、显示重复的内容

[wishcell@localhost dir2]$ cat b.txt
line 1
line 2
line 2
line 3
line 3
line 4
line 5
[wishcell@localhost dir2]$ uniq -d b.txt
line 2
line 3
[wishcell@localhost dir2]$

2、显示不重复的内容，-c参数可以看到行重复的次数

[wishcell@localhost dir2]$ uniq b.txt
line 1
line 2
line 3
line 4
line 5
[wishcell@localhost dir2]$

[wishcell@localhost dir2]$ uniq b.txt -c
      1 line 1
      2 line 2
      2 line 3
      1 line 4
      1 line 5
[wishcell@localhost dir2]$

二十九、shell printf与C语言十分相似

[wishcell@localhost dir2]$ printf "%d,%f,%o,%s,%x,%X\n" 380 380 380 380 380 380
380,380.000000,574,380,17c,17C
[wishcell@localhost dir2]$

带上类似C语言的控制字符.
[wishcell@localhost dir2]$ printf "%05d,%05.5f,%o,%s,%#x,%#X\n" 380 380 380 380 380 380
00380,380.00000,574,380,0x17c,0X17C

三十、 shell here 文档

[wishcell@localhost shell]$ cat ad.sh
report_uptime(){
        cat <<- _EOF_
            <H2> System Uptime</H2>
            <PRE>$(df -h; uptime)</PRE>
_EOF_
}
report_uptime
[wishcell@localhost shell]$

[wishcell@localhost shell]$ sh ad.sh
            <H2> System Uptime</H2>
            <PRE>Filesystem               Size  Used Avail Use% Mounted on
/dev/mapper/centos-root   41G   27G   15G  64% /
devtmpfs                 905M     0  905M   0% /dev
tmpfs                    920M     0  920M   0% /dev/shm
tmpfs                    920M  8.9M  911M   1% /run
tmpfs                    920M     0  920M   0% /sys/fs/cgroup
/dev/sda1               1014M  179M  836M  18% /boot
/dev/mapper/centos-home   20G  2.2G   18G  11% /home
tmpfs                    184M   32K  184M   1% /run/user/1000
 23:47:55 up 13:29,  5 users,  load average: 0.08, 0.03, 0.05</PRE>

三十一、常用条件表达式

1、文件比较

file1 -ef file2    file1 和 file2拥有相同的信息节点和编号(这两个文件通过硬链接指向同一个文件)
file1 -nt file2    file1 比 file2 新
file1 -ot file2    file1 比 file2 旧
-b file            file 存在而且是一个块（设备）文件
-c file            file 存在而且是一个字符（设备）文件
-d file            file 存在而且是一个目录
-e file            file 存在
-f file            file 存在而且是普通文件
...
-L file            file 存在而且是一个符号链接
...
-r file            file 存在而且可读
-s file            file 存在并且长度大于0
...
-w file            file 存在且可定
-x file            file 存在且可执行

2、字符串比较

[ string ]         string 不为空
-n string          长度大于0
-z strig           长度等于0
string1=string2
string1==string2
string1!=string2
string1>string2   排序时，string1 在 string2 之后 。实际使用时，">","<"都需要斜杠转意
string1<string2

3、整数比较

a -eq b   相等
a -ne b   不等
a -le b   小于等于
a -lt b   小于
a -ge b   大于等于
a -gt b   大于

三十二、case语句

case $(var) in
   a)              echo '关键字为 a 则成立'     ;;
   [[:alpha]] )    echo '关键字为单个字母则吻合' ;;
   ???)            echo '关键字为三个字符则吻合' ;;
   *.txt)          echo '以 .txt 结尾则吻合'    ;;
   *)              echo '其余条件吻合'          ;;
esac

三十三、强大的搜索应用

1、shell搜索函数在哪个文件中定义

# 比如要搜索 sleep 函数在当前目录哪个文件中定义：
[wishcell@localhost shell]$ cat aa.sh
funName=sleep
grep -rn "\w\+[ ]\+${funName}([^()]*)[ ]*{\?$" ./

# 带调度信息的调用：
[wishcell@localhost shell]$ sh -x aa.sh
+ funName=sleep
+ grep -rn '\w\+[ ]\+sleep([^()]*)[ ]*{\?

2、对文件进行优化，仅搜索 C文件，加快搜索速度

cat file.txt | xargs -i grep -rl {} ../bami/ -type f | grep \.c$
说明： -rl  只显示文件名
       -rni既有文件名，又有函数名

3、利用正则表达式，由 C 直接生成头文件（此例完美工作）

[wishcell@localhost shell]$ cat get_head.sh
#!/bin/bash
source_file=$1
if [[ -f ${source_file} ]]; then
    grep "\w\+[ ]\+\w\+([^()]*)[ ]*{\?$" ${source_file} | \
    grep -v "main" | sed -e 's/{\?$/;/' > ${source_file%.*}.h
fi

# 注释：
#   \w\+ 表示多个字符，至少一个，这是函数的返回值类型
#   [ ]\+ 表示多个空格，至少一个
#   ([^()*]) 这个没有理解
#       ==>>>>> [^()]*表示不包含左右小括号(、)的任意字符
#       ==>>>>> 最外层的()是函数体的格式，函数名后面的小括号。
#       ==>>>>> 就是函数定义的括号内，不能再有括号, 非常正确
#   [ ]* 表示任意多个空格，可以是0个
#   {\?$ 表示以0个或者一个 '{' 结束，
#      就是说函数定义的行尾是否有半个花括号
#   % 符号把匹配成功的东西丢弃掉，这里显然是把文件的后缀丢掉，
#      然后重新添加后缀 .h

4、利用正则表达式，对 lcov 产生的网页操作

进行函数提取，可以感知函数是否被覆盖
[wishcell@localhost c]$ grep -o "[0-9]\+[ ]\+:[ ]\+\w\+[ ]\+\w\+([^()]*)[ ]*{\?" a.c.gcov.html
1 : int add(int a, int b)
1 : int sub(int a, int b)
1 : int main()
[wishcell@localhost c]$

# 故意把 C 函数的花括号放在函数定义的地方，重新实验，效果仍然满意
[wishcell@localhost c]$ grep -o "[0-9]\+[ ]\+:[ ]\+\w\+[ ]\+\w\+([^()]*)[ ]*{\?" a.c.gcov.html
1 : int add(int a, int b){
1 : int sub(int a, int b){
1 : int main() {
[wishcell@localhost c]$

综合应用

1、一个编译脚本，有各种场景

#!/bin/bash
currDir=`pwd`
# 利用项目名称,进行字符串分割，保留项目所在路径
prjHome=${currDir%%prjName*}

buildFlag=$1
if [ -z $buildFlag ]; then
    buildFlag="help"
fi

# $1 is color, and $2 is content string
function colorPrint(){
    stringContent=$2
    if [ "$1" == "red" ]; then
        echo -e "\033[41m $stringContent \033[\m"
    elif [ "$1" == "green" ]; then
        echo -e "\033[42m $stringContent \033[\m"
    elif [ "$1" == "yellow" ]; then
        echo -e "\033[43m $stringContent \033[\m"
    elif [ "$1" == "gray" ]; then
        echo -e "\033[47m $stringContent \033[\m"
    fi
}
function quitBecauseFail() {
    if [ "$1" == "0" ]; then
        colorPrint green "$2 build succeed!"
    else
        colorPrint red   "$2 build failed!"
    fi
}

if [ "${buildFlag}" == "help" ]; then
    set -v
    echo "usage: sh buildPrjUT.sh"
    echo "       sh buildPrjUT.sh gdb"
    echo "       sh buildPrjUT.sh run"
    echo "       sh -x buildPrjUT.sh run"
    echo "       export PS4='+\${LINENO:\${FUNCNAME[0]}}-->>  '"
    echo "       date>mytime; sh buildPrjUT.sh flag 2>&1 | tee myLog; date>>mytime"
    set +v
elif [ "${buildFlag}" == "all" ] || [ "${buildFlag}" == "All" ] ; then
    set -v
    buildFlag="all"
    echo "para is ${buildFlag}"
    set +v
elif [ "${buildFlag}" == "gdb" ] || [ "${buildFlag}" == "GDB" ] ; then
    set -v
    buildFlag="gdb"
    echo "para is ${buildFlag}"
    set +v
else [ "${buildFlag}" == "gdb" ] || [ "${buildFlag}" == "GDB" ] ; then
    set -v
    buildFlag="gdb"
    echo "para is ${buildFlag}"
    set +v
fi

cpuNum=$((`grep -c "processor" /proc/cpuinfo` - 1))
echo "cpuNum is only : ${cpuNum}"

buildPath=${prjHome}/buildDir
destFile=${prjHome}/build/tt
toBeChange=${prjHome}/source/src3/aa.c
excludeDir=(${prjHome}/source/src1 \
            ${prjHome}/source/src2)

if [ "${buildFlag}" == "run" ]; then
    if [ -e "${destFile}" ]; then
        ${destFile}  # 如果目标文件已经生成，直接运行
    else
        colorPrint 'red' "${destFile} not exist" # 否则报错
    fi
elif [ "${buildFlag}" == "gdb" ]; then
    if [ -e "${destFile}" ]; then
        gdb ${destFile}  # 如果目标文件已经生成，直接运行
    else
        colorPrint 'red' "${destFile} not exist" # 否则报错
    fi
fi

echo currDir=${currDir}
echo buildPath=${buildPath}
echo toBeChange=${toBeChange}
echo "exclude dir Array:"
for i in "${excludeDir[@]}"; do colorPrint yellow "  ${i}";done

set -v
# 将此文件 30~40 行删除
cd $(dirname ${toBeChange}) && git checkout $(basename ${toBeChange}) && sed -i '30,40d' $(basename ${toBeChange})
# 在此文件某关键字处，其后追加几行内容，先找到关键字所在行
lineNum=`sed -n '/keyWord/= ' ${toBeChange}` \
echo ${lineNum}
sed -i "${lineNum}aThis\ is \ New\ content\ string1" ${toBeChange}
sed -i "${lineNum}aThis\ is \ New\ content\ string2" ${toBeChange}

# 删除多余文件，排除干扰
for i in "${excludeDir[@]}"; do rm ${i} -rf; done
set +v

if [ "${buildFlag}" == "all" ]; then
    make all
fi

if [ "${buildFlag}" != "all" ]; then
    echo "now is building module: ${buildFlag}"
    cd ${buildPath}
    if [ "${buildFlag}" == "module_1" ]; then
        make module_1
        quitBecauseFail $? ${buildFlag}
    elif [ "${buildFlag}" == "module_2" ]; then
        make module_2
        quitBecauseFail $? ${buildFlag}
    fi
fi

rm ${destFile} -rf
cd ${buildPath} && make all
quitBecauseFail $? ${buildFlag}

if [ -e ${destFile} ] ; then
    # 恢复之前临时修改的文件
    cd $(dirname ${toBeChange}) && git checkout $(basename ${toBeChange})
    for i in "${excludeDir[@]}"; do cd $(dirname ${i}) && git checkout $(basename ${i})"; done

    echo "${destFile} build succeed!"
    ${destFile}
else
    colorPrint gray "${targetFile} build failed"
    colorPrint red  "${targetFile} build failed"
fi

shell数组倒序打印
一、方法一：使用字符串切片
#! /bin/bash
read -p "请输入倒序内容:" str
len=${#str} # 获取字符串长度
for((i=$len;i>=0;i--))
do
        echo -e "${str:$i:1}\c"  # 其中 -e 是开启转义 \c 取消echo的换行
done
echo ""

二、第二种：利用shell中的数组

#! /bin/bash
read -p "请输入倒序内容:" s
str=`echo $s | sed 's/./& /g'` # 这里将字符串转化为数组格式 h e l l e v e r y o n e
array=($str)    # 将字符串转化为数组(h e l l e v e r y o n e)
len=${#array[@]}    # 获取数组长度 还有一种方式 len=${#array[*]}
for ((i=$len - 1;i>=0;i--))
do
        echo -e "${array[$i]}\c" # 其中 -e 是开启转义 \c 取消echo的换行
done
echo ""

特定场景：将关键字前面的内容复制到其后面

1、需求说明，对于跳转代码的情形

A、无返回值的情况

程序中，存在如下代码：
{
   ...
   return;
   //----可能存在若干空行
ERR:
    return;
}

####Ｂ、返回变量

程序中，存在如下代码：
{
   ...
   return ret;
   //----可能存在若干空行
ERR:
    a=3;
    return ret;
}

Ｃ、无返常数

程序中，存在如下代码：
{
   ...
   return OK;
   //----可能存在若干空行
ERR:
    printf("error...\n")
    return OK;
}

2、现在需要只要遇到 ERR: 就立即返回错误

但是不能一概而论，直接写死返回某种形式，因为这样可能造成返回值错误，从而编译失败理想做法，是根据规律，将 "ERR:"上面的一行返回值语句复制到它下面

3、解决思路

1、将 ERR: 之前，可能的空行删除，确保其上紧接的是一条　return 语句
2、利用 sed 工具，获取所有 ERR: 所在行的行号数组
3、将 shell数组倒序处理
   3.1 利用　sed -n 3p file　语法，将上一行字符串获取到
   3.2 利用 sed -i "3istr" 的方法，将　str 追加到指定行后

4、具体实现代码

1、删除所有可能的空行(更多的删除方法，参看sed.html)

sed -i "/^[[:space:]]*$/d" ${fileName}

2、利用 sed 工具，获取所有 ERR: 所在行的行号数组

lineNum=`sed -n /ERR:/=` ${fileName}
lineNumArray=(${lineNum}) # 其实即使不这么操作，${lineNum}　自身还是数组
len=${#lineNumArray[@]}   #数组长度还有一种表示方法：${#lineNumArray[*]}

3、利用循环语句，对各个行分别处理

for ((i=$len - 1; i>=0; i--))
do
     #　获取 `ERR:`　所在行前一行的内容
     pre_line_content=`sed -n $((${lineNumArray[$i]}-1))`p  ${fileName}
     echo "pre_line_content=${pre_line_content}
     # 将 ERR: 前一行的内容，追加到其后
     sed -i　"${lineNumArray[$i]}a${pre_line_content}"  ${fileName}
done

大段代码注入到文件中

1、基础用法

cat <<- MyEndFlag  > index.html
<html>
<body> this is a tst </body>
</html>
MyEndFlag

其中，MyEndFlag是自己定义的一个开始结束语标志，当然一般规范的写法，都是采取 END 或者EOF.

[Administrator.WINDOWS-LGJ801D] ➤ sh inject.sh
[Administrator.WINDOWS-LGJ801D] ➤ ls
index.html  inject.sh
[Administrator.WINDOWS-LGJ801D] ➤ cat index.html
<html>
<body> this is a tst </body>
</html>

2、追加内容到指定文件

只要将重定向符号改为追加即可：
cat <<- MyEndFlag  >> index.html

3、空行也直接原样追加，超级省心

[Administrator.WINDOWS-LGJ801D] ➤ cat index.html

<html>
<body> this is a tst </body>
</html>

this is the end

4、此功能对项目工程的应用价值

可以将某段代码直接写入功能代码，毕竟这样写出来的测试用例，编译成本最低。
否则需要解决大量的头文件引用问题，数据结构重定义，等等十分繁琐的事情。
   用完之后，清理也十分简单，因为在注入时，脏代码前面都加上了标志。

function hasInjected(){
    fileName=$1
    injectFlag=`sed -n "/DIRTY_CODE_BEGIN/=" ${fileName}`
    if [[ "${injectFlag}" =="" ]]; then
        echo "${fileName} has not inject testcase"
        return 0
    else
        echo "${fileName} has inject testcase"
        return 1
    fi
}

function injectTesting(){
fileName=$1
# judge if dirty code has injected
hasInjected $fileName
if [[ "$?" =="1"]]; then
    return  # if code has injected, return directively
fi

cat <<- MyEndFlag  >> ${fileName}
#define DIRTY_CODE_BEGIN
void dirTest()
{
    int para = 3;
    funcAtest(para);
}
MyEndFlag
}

#using it like this
injectTesting  ${projectHome}/module/funcA.c

5、shell整块输出到屏幕，而不是输出到文件

cat <<- MyEndFlag
#define DIRTY_CODE_BEGIN
void dirTest()
{
    int para = 3;
    funcAtest(para);
}
MyEndFlag
}

6、既输出到文件，又打印到屏幕

cat <<- MyEndFlag | tee ${fileName}
#define DIRTY_CODE_BEGIN
void dirTest()
{
    int para = 3;
    funcAtest(para);
}
MyEndFlag
}

shell脚本延时
秒级延时 : sleep 1
延时 10ms: sleep 10
延时 10ms: usleep 1000

一键恢复　git　改动
git status | grep 删除 | awk '{print $3}' | egrep -o ".*/testcase" | \
grep -vw key_1/module/testcase | grep -vw key_2/module/testcase | \
xargs -i git checkout {}

注意事项：
uniq -d 这个选项不能加，加了会达不到目标，就多执行几次　git checkout 吧
grep -vw key1　是因为怕有其它项目，名称为 xxkey1/module/testcase　也被过滤掉
egrep -o ".*/testcase/" 效果不同于 egrep -o .*/testcase/
　　后一种效果只能匹配到两个字符，前一种是正则表达式匹配所有，这个坑了我一段时间

shell 数组使用，坑
lineNum=`sed -n "/${keyWord}/="` ${fileName}
这里， ${keyword} 外面只能用双引号，一旦用了单引号，结果就会错

结果 clineNum　可能不止一条记录，如果是多条，就需要用数组来存储
lineNumArray=(${lineNum})

如果没有找到关键字，则记录为空，所以需要判断
if [ ${#lineNumArray[@]} == 0]; then
    echo key ${keyword} not found from ${fileName}
else
    # 将关键字开始，到文件尾的内容全部删除
    sed -i "${lineNumArray[0]},$"d ${fileName}
fi

\n' the_ip= function Match_and_connect() { echo "script name : $1" echo "line content: $2" echo "script name key : $3" echo "line content key: $4" if [[ "$1" =~ "$3" ]];then if [[ "$2" =~ "$4" ]];then the_ip=`echo $2|tr -d "$4 IP:"` ssh $the_ip -l root break fi fi } # grep -i j_ RADME.txt -A 5 ： 从 README中搜索关键字 "j_"，不区分大小写，然后找到它，连同其后5行，共六行输出 # tr a-z A-Z 将输出中小写字符转换为大写 for line in `grep -i j_ RADME.txt -A 5 | tr a-z A-Z` do echo "----- $line -----" $(Match_and_connect "$script_name" "$line" "MASTER" "MASTER" ); $(Match_and_connect "$script_name" "$line" "SLAVE" "SLAVE" ); $(Match_and_connect "$script_name" "$line" "LINEONE" "LINEONE"); $(Match_and_connect "$script_name" "$line" "LINETWO" "LINETWO"); if [ -n "$the_ip" ];then break fi done IFS=$old_IFS 

C、README.txt中内容的样子

####D、脚本的样子

十七、shell字符串截取

假设有变量 var=http://www.aaa.com/123.htm

1. ‘#’ 号截取，删除左边字符，保留右边字符。

2. “##” 号截取，删除左边字符，保留右边字符。

3. “%”号截取，删除右边字符，保留左边字符

4. “%%” 号截取，删除右边字符，保留左边字符

5. 从左边第几个字符开始，及字符的个数

6. 从左边第几个字符开始，一直到结束。

7. 从右边第几个字符开始，及字符的个数

8. 从右边第几个字符开始，一直到结束。

9、获取全路径中，文件名的方法:basename