翼度科技»论坛 云主机 LINUX 查看内容

Linux-shell编程入门基础

9

主题

9

帖子

27

积分

新手上路

Rank: 1

积分
27
目录

前言

本篇文章就是一个过渡学习的,先入门shell脚本,由于作者有编程基础,所以有些解释的比较少。由于现在还在努力学习中,以后等本散修进阶了之后再写进阶的、与网络安全更加贴合的shell编程
Shell编程

指定shebang的意思是指定脚本执行的解释器
  1. #!/bin/bash #指定bash执行,那这就是shell语言脚本了
  2. #!/bin/python #指定python解释器,那么这个就是python语言脚本
  3. #!/bin/perl #指定perl解释器,那这个脚本就是perl语言脚本
复制代码
bash特性

查看历史指令最大存储条数
  1. echo $HISTSIZE
复制代码
存放用户执行的历史指令的文件
  1. echo $HISTFILE
复制代码
快速查看历史指令
  1. !1000 #查看第1000条历史指令是什么
  2. !! #执行上一条指令
复制代码
反引号执行指令
  1. `ls` #反引号中的字符会当成指令执行
复制代码
文件是否能执行得看文件是否具有x执行权限
  1. ll filename #查看文件属性
  2. chmod +x filename #添加执行权限 这样直接+x就是a+x
  3. 有执行权限的文件通常是标志绿色的
复制代码
执行shell脚本方式
  1. source shell.sh
  2. . shell.sh
  3. ./shell.sh
  4. bash shell.sh
  5. sh shell.sh
复制代码
source和.是在当前环境中加载变量,所以你使用这两个命令加载shell脚本后,里面的变量就会加载到你当前的bash中,而不会开启子shell,所以慎用这两个命令。(这两个source和.符号,在后面函数分文件中也会用到)
shell作用域

每个用户家目录下都有一个自己的变量文件,是在系统加载的时候加载
  1. .bash_profile
  2. 该文件作用是先加载.bashrc
  3. 然后再加载你下面定义的变量等等
复制代码

这里提前说明一下如何加载,注意是加载不是执行
  1. source filename
  2. . filename
  3. 以上两个都是加载文件的操作,这两个方法都是可以在该文件没有x执行权限的时候进行加载
  4. 因为如果要按照shell脚本进行加载的话,那么你里面的变量都会变成局部变量,那么脚本执行虽然也加载了,
  5. 但是执行完成后就会被释放,出来后依然还是没有成功加载你的变量
复制代码
linux中执行shell脚本方式
  1. ./shell.sh
  2. bash shell.sh
  3. sh shell.sh
复制代码
bash和sh单独使用的话,就是进入一个子shell中,我们可以通过pstree查看。
可以通过exit退出子shell
安装一个psmisc,主要用pstree功能来理解作用域,没有也无所谓
  1. yum install psmisc -y
复制代码

  • 下面是通过bash开第一个子shell,通过pstree可以看到确实是进入了一个子shell中

  • 下面是通过sh进入的一个子shell,通过pstree可以看到确实是进入了一个子shell中

查看一下两个shell,pstree可以看到是不同bash的。

我们随便定义一个变量,可以看到不同shell之间的变量是互通不了的,原因作用域的问题
作用域大概如下,age一般定义在自己bash中的变量是不能互通的:
每一个盒子都是一个shell盒子,他们之间的变量都是不能互通的
不管是他们的全局变量还是局部变量都是不可以互通
但是除非你定义在了系统变量,比如/etc/profile这种文件中,
这种文件是在系统加载的时候加载的文件,所以每一个用户都会生效。
但是除非你自己盒子里面有和你在系统文件中定义的变量,就会被覆盖掉,以你自身的.bash_profile文件为准

总结:
shell的作用域说白了就是每一个shell登录进来都是不一样作用域,你要全局生效就去修改/etc/profile下的系统加载文件,但是你修改了不会立刻生效,你可以使用source /etc/profile 和 . /etc/profile就能够加载一下该脚本文件,你的变量就会在你当前shell脚本生效,但是其他已经登录进来的用户不会生效,因为他没有加载系统文件,除非他退出重新登录或者source /etc/profile 或者 ./etc/profile才能加载生效。
变量

Linux 系统中环境变量约定好都是大写,不容易和我们自己定义的出现冲突,也就是说我们定义的变量最好是小写的
环境变量

查看变量相关指令
  1. set #输出所有变量,包括全局变量和局部变量
  2. env 只显示全局变量
  3. declare 同set
  4. export 显示还有设置环境变量值,在linux命令中直接使用的话是临时设置的哈
复制代码
常见的环境变量
  1. PATH:shell会到该变量定义的目录中找命令和程序
  2. PS1:基本提示符,对于 root 用户是 #,对于普通用户是 $
  3. HISTSIZE:最大存储的历史记录数
  4. SHELL:该用户使用的Shell,通常是/bin/bash
  5. HOME:当前用户给的默认主目录
  6. LANG:语言相关的环境变量,多语言可以修改此环境变量
  7. USER:用户名
  8. LOGNAME:用户的登录名
  9. HOSTNAME:主机的名称
  10. MAIL:当前用户的邮件存放目录
复制代码
撤销环境变量名

  • unset 变量名,删除变量或者函数
设置只读变量

  • readonly ,只有shell结束才能失效的变量
    1. readonly name='abc'
    2. name=123 #企图修改的时候就会报错下面的信息
    3. -bash: name: 只读变量
    复制代码
set 查看系统中所有的系统变量
通过下图可以看到,我们每一个shell就算定义在了profile文件中,我们也要进行加载才能看到,就算我们直接grep该文件也是查看不到另一个shell中添加到profile中的变量,一定一定要使用source或者.符号进行加载才可以加载。

可以看到我们加载后就能够看到和使用另一个shell添加进去的name变量了。

通过上面案例后,我们可以理解成:
  1. set 就是查看系统中定义的全局变量还有局部变量,不用管他是查看哪个文件。
  2. (PS:env就是只能看全局,比如我们用户自己在shell命令终端中定义的变量只有set能看,env看不到。)
复制代码
其他查看的类型不用了解太深,其实shell脚本用到的大多都是自己定的变量,更多变量以后就会慢慢接触到。(说人话:我懒得查了)
$特殊变量
  1. $0  获取shell脚本的文件名以及脚本路径
  2. $n  获取shell脚本执行的时候传入的参数,比如$1就是获取传进来的第一个参数
  3. $#  获取执行的shell脚本后面的参数总个数,这个是统计参数个数的变量
  4. $*  获取shell脚本传进来的所有参数,直接使用等于"$1" "$2" "$3"
  5. "$*" 这样加上引号是获取所有参数,但是不是列表形式,而是整体"$1 $2 $3"
  6. $@ 和 "$@" 都等于 $* ,他都是列表形式让你循环
复制代码
如下脚本输出,看完就能理解这几个的区别了。
  1. #!/bin/bash
  2. echo '=====$@===line========='
  3. for var in "$*"
  4. do
  5.         echo "$var"
  6. done
  7. echo '=====$@===line========='
  8. for var in $@
  9. do
  10.         echo "$var"
  11. done
  12. echo '==="$@"=====line========='
  13. for var in "$@"
  14. do
  15.         echo "$var"
  16. done
复制代码

$特殊状态变量
  1. $? 上一次命令执行状态返回值,0表示正确,非零表示失败 #这里终于明白了为什么一开始学c语言的时候return 0是正常退出了!!!泪目!!
  2. $$ 当前shell脚本的进程号
  3. $! 上一次后台进程的PID
  4. $_ 上次执行的命令的最后一个参数
复制代码
更详细更多的特殊状态变量解释可以直接查看man手册
  1. man bash
复制代码
$特殊符号(很重要)
  1. ${变量名}    #取出变量的值
  2. $变量名      #取出变量值
  3. $(命令)      #括号中执行命令,然后返回结果
  4. ``          #反引号中执行命令,然后返回结果
  5. ()          #开启子shell执行命令
复制代码
其他内置shell命令

内置的shell有很多,但其实在学习Linux的时候就已经有学过一些了。比如:alias也是内置的shell命令
  1. echo
  2. printf
  3. eval
  4. exec
  5. read
复制代码
echo
  1. -n 不换行输出
  2. -e 解析字符串汇总的特殊符号,
  3.         比如:
  4.         \n 换行
  5.         \r 回车
  6.         \t 制表符(四个空格)
  7.         \b 退格
复制代码
printf
  1. echo需要加上-e才能识别特殊符号,那printf就是可以直接解析特殊符号的。
  2. printf "hello\nworld\n"
复制代码
eval
  1. 执行多个命令
  2. eval ls;cd /tmp;ls
  3. 其实在linux中只使用分号也能实现多个命令执行。
  4. 这里eval可能是为了在shell脚本中好执行??我也不太懂,以后再深入了解。。。
复制代码
exec
  1. 不创建子进程然后执行你给的命令,然后执行结束后就直接退出当前shell,说白了就是exec执行命令后就会自动exit你当前的shell
复制代码

read
read [-参数] [变量1 变量2 ...]
注意:变量1 2 这些是输入的数据,然后按照顺序给到变量,变量名可以随便起,后面要使用该变量的时候按照正常的$符号取变量值即可。
  1. -p #显示提示信息,后面加上你要提示的字符串
  2. -r #不对输入的字符进行转义,读到什么字符串就输出什么字符串
  3. -t #限制用户输入的时间,单位秒
  4. -s #静默模式,不会显示你输入的内容,就像你修改密码的时候也不会显示出来
复制代码

  • -p参数解释
    1. read -p '请输入数据:' name age
    2. echo $name
    3. echo $age
    4. 脚本读到read这行的时候就会要求用户输入数据,然后数据会按照顺序给到变量name和age
    复制代码
  • -t参数解释
    1. read -t 5 -p "请输入你要修改的名字:" name
    2. echo $name
    3. 脚本读到read这行的时候就会要求用户输入数据,然后数据给到name变量
    复制代码
shell语法的子串截取

这里使用name作为变量,下面都使用name
  1. ${name}                                 返回变量值
  2. ${#name}                                返回name的字符长度(这个获取长度命令很快)
  3. ${name:start}                           返回name变量的start下标开始以及后面的字符
  4. ${name:start:length}                返回name变量的start下标开始然后截取length个字符
  5. 下面介绍删除字符的
  6. str_or_pattern意思是可以是字符也可以是正则匹配模式,最短和最长就是因为有正则模糊匹配
  7. ${name#str_or_pattern}                从变量开头开始删除匹配最短str_or_pattern
  8. ${name##str_or_pattern}                从变量开头开始删除匹配最短的str_or_pattern
  9. ${name%str_or_pattern}                从变量结尾开始删除匹配最短的str_or_pattern
  10. ${name%%str_or_pattern}                从变量结尾开始删除匹配最长的str_or_pattern
  11. 下面介绍替换字符的
  12. 下面这种方式有点像我们sed还有vim里面自带的字符替换,所以说Linux语法都是大差不差的哈
  13. ${name/pattern/string}                用string替换第一个匹配的pattern
  14. ${name//pattern/string}                用string替换所有匹配的pattern
复制代码

  • 注意
    1. #上面的删除字符#和%这两个,#开头一定要匹配上,比如name=123abcABC456abcABC
    2. #那么我们要删除的话肯定是1开头的,如果不是1开头就无效,给你返回源字符了
    3. [root@localhost ~]# echo ${name#1*c}
    4. ABC456abcABC
    5. [root@localhost ~]# echo ${name##1*c}
    6. ABC
    7. [root@localhost ~]# echo ${name##2*c} #匹配不正确导致的输出原变量值
    8. 123abcABC456abcABC
    9. #那么同理%也是,只不过是从结尾开始匹配,那么我们给的str_or_pattern结尾要和变量最后一个字符一样才行哈
    10. [root@localhost ~]# echo ${name%b*C}
    11. 123abcABC456a
    12. [root@localhost ~]# echo ${name%%b*C}
    13. 123a
    14. [root@localhost ~]# echo ${name%%C*a} #匹配不正确导致的输出原变量值
    15. 123abcABC456abcABC
    复制代码
统计


  • 最快统计字符方式就是自带的
    1. echo ${#name}
    复制代码
  • wc
    1. -L 统计字符数最多那一行,输出他的字符数量
    2. -l 统计文件行数
    3. -c 统计文件字符数
    复制代码
  • expr length "字符"
    1. 直接输出字符长度,这里可以使用变量,当然你用变量的话记得使用双引号
    2. expr length "${name}"
    复制代码
指令执行时间

计算方式:time 指令
比如我们这里统计上面统计字符长度哪个指令是速度最快的
待检测数据为:
  1. time for i in {1..10000};do str=`seq -s "ok" 10`;echo ${#str} &> /dev/null;done
  2. 修改${#str}部分为其他统计字符指令即可检测不同指令之间的效率
复制代码
知识点:
&>是1&2>的缩写
&1是为了标识1不是一个文件,而是一个标准输出,所以 2>&1意思是将标准错误输入到标准输出1中
command &> /dev/null  等于 command > /dev/null 2>&1

  • ${#str} 这种方式最快
    1. [root@localhost ~]# time for i in {1..10000};do str=`seq -s "ok" 10`;echo ${#str} &> /dev/null;done
    2. real        0m10.319s
    3. user        0m4.307s
    4. sys        0m6.660s
    复制代码
  • wc -L  需要使用到管道符一般都比较慢
    1. [root@localhost ~]# time for i in {1..10000};do str=`seq -s "ok" 10`;echo $str | wc -L &> /dev/null;done
    2. real        0m19.679s
    3. user        0m12.981s
    4. sys        0m13.072s
    复制代码
  • expr length "${str}"
    1. [root@localhost ~]# time for i in {1..10000};do str=`seq -s "ok" 10`;expr length "${str}" &> /dev/null;done
    2. real        0m19.057s
    3. user        0m8.865s
    4. sys        0m11.688s
    复制代码
练习

数据
  1. [root@localhost ~]# touch whoisdhan_{1..10}_nono
  2. [root@localhost ~]#
  3. [root@localhost ~]# ls who*
  4. whoisdhan_10_nono  whoisdhan_4_nono  whoisdhan_8_nono
  5. whoisdhan_1_nono   whoisdhan_5_nono  whoisdhan_9_nono
  6. whoisdhan_2_nono   whoisdhan_6_nono
  7. whoisdhan_3_nono   whoisdhan_7_nono
复制代码
将上面的文件所有带_nono的,都替换为空,比如whoisdhan_10_nono 变成 whoisdhan_10
答案不止一个,下面是我的答案
  1. for var in `ls who*`;do mv $var ${var//_nono/};done
  2. #从这里可以扩展一下思维。我第一时间想到的是find命令进行查找,其实不用,因为我们的文件就在该目录下了,直接ls通配符模糊匹配即可。
复制代码
shell特殊扩展变量

注意:这里我个人认为是适合用在开发脚本的时候,对脚本接受到的参数进行筛选甄别。
  1. ${parameter:-str} #如果parameter为空的时候,就返回str字符串,不为空那就返回parameter
  2. ${parameter:=str} #如果parameter为空的时候,将parameter赋值为str并且返回str值
  3. ${parameter:?str} #如果parameter为空的时候,将str当作错误内容输出,否则输出parameter值
  4. 就像下面这样
  5. [root@localhost ~]# echo ${q:?空变量}
  6. -bash: q: 空变量
  7. ${parameter:+str} #parameter为空的时候啥也不做,如果不为空那就返回str(可以用来判断某些参数是否为空)
  8. 就像下面这样
  9. [root@localhost ~]# echo ${name:+不为空}
  10. 不为空
复制代码
父子shell的理解

下面是我看超哥教程的一份图解:
  1. 为什么要理解父子shell的关系,原因是因为我们shell编程中一个括号就能够开启一个子shell,目的是不让某些操作比如Ping指令将我们当前的shell卡主,这样的话你可以开一个子shell去执行ping这种指令,然后可以让shell脚本继续执行下去。
复制代码

$BASH_SUBSHELL该变量是检测开启了几个子shell
  1. (cd ~;pwd;ls;(cd /tmp;ls;(echo "开启了:$BASH_SUBSHELL 个子shell")))
复制代码

内置和外置命令

识别内置还是外置
  1. type cd
  2. type rename
复制代码
快速查看系统有哪些是内置命令
  1. compgen -b
复制代码
区别

先认识一下两个的意思

  • 内置
    1. 在系统启动时就加载内存,常驻内存,执行效率更高,但是占用资源
    复制代码
  • 外置
    1. 系统需要从硬盘中读取程序文件,再读入内存加载
    复制代码
二者区别:
  1. 内置就是不开启子进程,直接在当前shell中执行,外置就是需要下载的一些系统命令,使用外置命令的时候需要开启一个子进程执行。
复制代码
数值计算

双括号(())运算

  1. ((i=i+1))  #双括号里面进行一系列的运算
  2. $((i=i+1)) #加个$符号就是取你计算出来的结果
  3. ((条件判断)) #为真返回1,为假返回0
复制代码
注意:
  1. 假设你有一个变量名为name=123
  2. 当你使用双括号进行name变量运算的时候是按照你name本来的值进行运算的,同时可以修改name的值。
  3. ((name++))
  4. echo $name
  5. 124
复制代码
计算器简易版
  1. #!/bin/bash
  2. echo $(($1))
复制代码

let
  1. age=5
  2. let age+=5 #let后面就能够直接使用变量进行计算了
  3. 等同于
  4. $((age+=5))  #但是这种是会报错的,因为会把结果10当成命令执行,但是我们赋值是赋值成功了的
复制代码
expr

复习一下,之前我们使用expr进行字符长度计算
  1. 直接输出字符长度,这里可以使用变量,当然你用变量的话记得使用双引号
  2. expr length "${name}"
复制代码
expr --help
  1. 将表达式的值列印到标准输出,分隔符下面的空行可提升算式优先级。
  2. 可用的表达式有:
  3.   ARG1 | ARG2       若ARG1 的值不为0 或者为空,则返回ARG1,否则返回ARG2
  4.   ARG1 & ARG2       若两边的值都不为0 或为空,则返回ARG1,否则返回 0
  5.   ARG1 < ARG2       ARG1 小于ARG2
  6.   ARG1 <= ARG2      ARG1 小于或等于ARG2
  7.   ARG1 = ARG2       ARG1 等于ARG2
  8.   ARG1 != ARG2      ARG1 不等于ARG2
  9.   ARG1 >= ARG2      ARG1 大于或等于ARG2
  10.   ARG1 > ARG2       ARG1 大于ARG2
  11.   ARG1 + ARG2       计算 ARG1 与ARG2 相加之和
  12.   ARG1 - ARG2       计算 ARG1 与ARG2 相减之差
  13.   ARG1 * ARG2       计算 ARG1 与ARG2 相乘之积
  14.   ARG1 / ARG2       计算 ARG1 与ARG2 相除之商
  15.   ARG1 % ARG2       计算 ARG1 与ARG2 相除之余数
  16.   字符串 : 表达式                定位字符串中匹配表达式的模式
  17.   match 字符串 表达式                等于"字符串 :表达式"
  18.   substr 字符串 偏移量 长度        替换字符串的子串,偏移的数值从 1 起计
  19.   index 字符串 字符                在字符串中发现字符的地方建立下标,或者标0
  20.   length 字符串                        字符串的长度
复制代码
在使用expr进行计算的时候,符号与数据之间记得加上空格才能够识别成功过,和变量赋值不一样哈
加减乘除
  1. expr 2 + 3
  2. expr 2 - 3
  3. expr 2 \* 3 #乘法这里要对乘号进行字符转义
  4. expr 2 / 3
复制代码
判断符号
  1. expr 1 \> 2
  2. expr 1 \< 2
复制代码
expr模式匹配
  1. : 冒号,计算字符串的数量
  2. .* 任意字符串重复0或多次
复制代码
看一个语法就理解了(就是有点奇怪,用冒号作为计算字符串标志)
  1. str=str.aaa.bbb
  2. expr $str ":" "st.*b"
  3. 11
  4. 意思是计算出str.aaa.bbb字符一共11个字符数量
  5. "st.*b"这个是正则匹配哈,特殊符号记得加转移\
复制代码
说白了expr就是正则模式匹配上了的,就统计你那个匹配上的字符,但是expr匹配模式是从字符串开始匹配的,所以只能规定后面的截止字符,
比如expr str.abc.abwwwc ":" "a*c"这样是匹配不成功的,因为字符串是s开头,而你给的匹配模式是a开头。
bc

bc计算器
bc是可以直接当作计算机使用的。你直接敲bc命令进入后,直接输入加减乘除这些式子回车都能够给你输出接过来。
  1. [root@localhost ~]# bc
  2. bc 1.06.95
  3. Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006 Free Software Foundation, Inc.
  4. This is free software with ABSOLUTELY NO WARRANTY.
  5. For details type `warranty'.
  6. 1+1
  7. 2
  8. (1+2)*3
  9. 9
  10. 9*9
  11. 81
复制代码
通过管道符计算
  1. echo "4*4" | bc
  2. echo '1+1' | bc
  3. [root@localhost ~]# echo '9*3' | bc
  4. 27
  5. [root@localhost ~]# echo "1+2*3" | bc
  6. 7
复制代码
练习:计算1..100的总和
  1. 方式一:echo {1..100} | tr ' ' '+' | bc
  2. 方式二:seq -s '+' 100 | bc
  3. 方式三:seq -s ' + ' 100 | xargs expr  
  4. 方式三我的理解:首先xargs不加-i参数是因为-i是要配合{}一起使用,然后是一个一个的传进去,但是expr是expr 1 + 2这样的,所以我们就不能用-i,那么我们也不能直接 seq -s ' + ' 100 | expr直接管道符接,因为相当于字符串过去了,即相当于expr "1 + 2 + ..",那我们要配合xargs这种是接到"1 + 2 + .."后,当参数给到exrp而不是整个字符串给他,那么就刚好等于expr 1 + 2 + 3 + ..
复制代码
awk

知道这种格式用法即可了
  1. echo "2 3" | awk '{print($1*$2)}'  #等于2*3=6
复制代码
中括号

num=3
$[num+=2]
$[num-1]
  1. [root@localhost ~]# num=3
  2. [root@localhost ~]# res=$[num+=5]
  3. [root@localhost ~]# echo $res
  4. 8
复制代码
需要注意的是,不要直接就是$[num=3]这样,因为你这样就相当于执行了一个$[num=3]取出来的结果作为命令使用,当然num=3是执行成功了的哈。
shell的条件判断

test判断
  1. -e 测试文件或目录是否已存在,存在则返回真,否则返回假
  2. -f 判断文件是否是普通文件类型
  3. -d 判断是否是目录类型
  4. -n 判断字符串不为空则为真,理解为 no zero
  5. -z 判断字符串为空时候为真,理解为 zero
  6. -r 判断当前用户对该文件是否有权限查看
  7. -u 判断该文件是否具有SUID属性
  8. -g 判断该文件是否具有SGID属性
  9. 比较参数
  10. -eq 相等
  11. -ne 不相等
  12. -gt 大于
  13. -lt 小于
  14. -ge 大于等于
  15. -le 小于等于
  16. -a (and) 比如:test -r hello -a -w hello
  17. #判读用户对该hello文件是否有r读取和w写入权限
  18. -o (or)  比如:test -r hello -o -w hello
  19. #判断用户对该hello文件是否有r读取或者w写入任意一个权限
  20. ! (not) 表示非,例如:test ! -r hello
  21. 表示当用户对该文件不具有r读取权限的时候就返回true,
  22. 注意写的时候! -r之间一定要有空格,否则会报错,不能连在一起写,因为-r是参数,除非你是等于号就可以连在一起!=
复制代码

  • -e
    简单做一个练习:判断hello文件是否存在,存在则打印“文件已存在” 否则打印 “文件成功创建” 并且创建hello文件
    1. test -e "hello" && echo "文件已存在" || (touch hello && echo "文件成功创建")
    复制代码
  • -f
    判断这个文件是否是普通文件类型,如果是就打印yes否则打印no
    1. test -f hello && echo yes || echo no  
    复制代码
  • -d
    判断是否是目录类型
    1. test -d hello && echo yes || echo no
    复制代码
  • -n
    判断字符是否为空,不为空则打印str_yes,否则打印str_no
    1. str=''
    2. test -n "$str" && echo str_yes || echo str_no
    复制代码
  • -r
    判断用户对文件是否有r读取权限
    1. test -r "hello" && echo yes || echo no
    复制代码
  • -w
    判断用户对文件是否有w写权限
  • -x
    判断用户对文件是否有x执行权限
注意:如果你使用root来测试的话只能返回yes,因为root权限是最大的。
中括号[]判断

注意:[]的两边一定要一定要加上空格,否则会出错,这里在if使用中括号的时候是一样的。
文件名和目录名最好使用引号引起来,虽然可以不用引号,但是不敢担保你的文件是否有空格隔开。
格式:[ 条件表达式 ]
参数
  1. -f 测试普通文件是否存在
  2. -d 测试目录是否存在
  3. -r
  4. -w
  5. -x
  6. 以上三个都是判断用户对文件是否有r读取、-w写入、-x执行权限。
  7. 比较参数
  8. -eq 相等
  9. -ne 不相等
  10. -gt 大于
  11. -lt 小于
  12. -ge 大于等于
  13. -le 小于等于
  14. -a (and) 比如:[ -f hello -o -f world ] && echo yes || echo no  
  15. -o (or)  比如:[ -f hello -o -f world ] && echo yes || echo no
  16. ! (not) 表示非,例如:[ ! -f hello ] && echo yes || echo no
  17. 表示当用户对该文件不具有r读取权限的时候就返回true,
  18. 注意写的时候! -r之间一定要有空格,否则会报错,不能连在一起写,因为-r是参数,除非你是等于号就可以连在一起!=
复制代码

  • 判断hello文件是否存在,存在就输出yes 否则就输出 no
    1. [ -f hello ] && echo yes || echo no
    复制代码
  • 判断hello目录是否存在,存在就输出yes 否则就输出no
    1. [ -d hello ] && echo yes || echo no
    复制代码
中括号写判断符号

注意:在中括号中写判断符号的时候,数据与判断符号和数据之间都要用空格隔开,包括中括号也要空格哈,比如下面
(后面会解释为什么使用转移符号=)
  1. [ "${name}" \= "123" ] && echo yes || echo no
  2. 注意:这里使用一个等号还是两个等号都是一样的哈。
  3. 意思是如果该变量name等于123的话就echo yes 否则 no
  4. 同理其他单个的符号也要空格,双个不用
  5. [ 1 \= 1 ]
复制代码

使用数学比较符号的时候记得使用转义符
  1. [ 1 \> 2 ] 这样才对,否则你使用[ 1 > 2 ]是错误的
  2. 下面两语句执行以下就知道结果了
  3. [ 1 \> 2 ] && echo yes || echo no
  4. [ 1 > 2 ] && echo yes || echo no
复制代码
总结:使用数学运算符的话,如果是单个字符的就要使用转移符号\,如果是!=或者==或者>=这种就不用加转义符号。
双中括号[[]]

格式:[[ 条件表达式 ]]
  1. 使用起来和单中括号的区别就是:双中括号不用写转义符,就可以直接识别> < = ,那么双中括号同时还支持正则表达式匹配。
  2. 然后其他单中括号支持的在双中括号里也能用。
  3. 但是我们平时用的比较多的是单中括号。
复制代码
总结括号的知识:

if分支

注意:条件表达式可以是很多种,我们上面学的shell条件判断方式否可以使用
单分支
  1. if <条件表达式>
  2.         then
  3.         codeing...
  4. fi
  5. #简化
  6. if <条件表达式>;then
  7.         codeing
  8. fi
复制代码
嵌套if
  1. if <条件表达式>
  2.         then
  3.         codeing...
  4.         if <条件表达式>
  5.                 then
  6.         fi
  7. fi
复制代码
if-else
  1. if <条件表达式>
  2.         then
  3.         coding...
  4. else
  5.         coding...
  6. fi
复制代码
if-elif
  1. if <条件表达式>
  2.         then
  3.         coding
  4. elif <条件表达式>
  5.         then
  6.         coding
  7. else
  8.         coding...
  9. fi
复制代码
case

注意:case的出现是可以让你少用if else,同时他也是一个菜单化的这么一个命令。
格式
语法
  1. case $choice in
  2. 1)
  3.         shell代码
  4.         ;;
  5. 2)
  6.         shell代码
  7.         ;;       
  8. 3)
  9.         shell代码
  10.         ;;
  11. *) #这个是固定的,相当于我们编程中的default,就是上面的选项都没有被$变量的值的时候就会跳到这里来,在shell中一般是用来写提示信息的。
  12.         shell代码
  13.         ;;
  14. esac
  15. #为什么是esac,很简单,我们学习if的时候是用fi解释,就是if倒过来,那么case的结束也是倒过来esac
复制代码
注意:
  1. 1)
  2. 2)
  3. 3)
  4. 里面的123可以随便,只要你的$变量可以找到这个里面,你可以随便写,可以是:
  5. qqq)
  6. reg)
  7. adgsaf)
  8. *)
  9. 随便写,只要你的$变量能够找到即可。
  10. *)最后一个是固定的
复制代码
for

语法
  1. for 变量名 in 循环列表(一定是列表哈)
  2. do
  3.         shell代码
  4. done
复制代码
注意
  1. 循环列表可以是:
  2. {1..100} shell命令自带的生成1-100的序列,当然其他命令都可以比如seq
  3. "1 2 3 4" 这种也能够当成循环列表,以空格为分隔符号,会依次取出1 2 3 4
  4. 文本文件中你cat出来每一行也能当作列表循环
  5. for i in $(cat /etc/passwd) #这种读取文件出来就是每一行作为一个变量
  6. $()等于``,执行命令,不要忘记了,在这里回顾一下。
复制代码
while

语法
  1. while <条件表达式>
  2. do
  3.         shell代码
  4. done
复制代码
注意
  1. 这个条件表达式和之前学的一样,shell的条件判断表达式能写的while照样可以拿来当条件表达式,不过一般都是用 [] 单中括号的比较多
复制代码
普通数组

定义
  1. 数组名=(值1 值2 值3)
复制代码
取数组值
  1. #根据下标取值
  2. ${数组名[下标]}  #不能用$数组名[下标] ,取不到数组值
  3. #取数组中所有的值
  4. ${数组名[*]}
  5. ${数组名[@]}
  6. #计算数组长度
  7. ${#数组名[@]}
  8. ${#数组名[*]}
  9. #解释:这里很巧妙使用了我们上面说的#取字符长度的写法,这里就变成了取数组长度。比如$*和$@都是取所有参数,然后我们这里就是取数组所有值,那么再结合之前学的统计字符长度${#name}这种,就完美解释和理解了为什么计算数组长度是用${#数组名[@]}这个样子了。
复制代码
函数

说明:函数必须先定义再执行
注意:return 和 exit 是不同的,exit是结束shell环境,而return是结束函数执行。
函数定义

语法格式如下
  1. #第一种
  2. function 函数名(){
  3.         函数体
  4.         return 返回值
  5. }
  6. #第二种
  7. function 函数名{
  8.         函数体
  9.         return 返回值
  10. }
  11. #第三种
  12. 函数名(){
  13.         函数体
  14.         return 返回值
  15. }
复制代码
函数执行
  1. #执行方式
  2. 函数名
  3. 函数名(参数1 [,参数2,...] )
复制代码
函数传参

说明:在shell脚本中,传参方式和你输入的参数一样,我们平常的比如touch ,touch 传参数是 touch 文件名,那么函数传参也是这样。同时,函数获取参数方式和脚本获取参数方式是一样的。(这句话理解不了就看下面的例子)
  1. function 函数名(){
  2.         echo $1 $2 $3
  3.         return 返回值
  4. }
  5. #函数有参数的调用方式如下(和脚本传参一样格式)
  6. 函数名 参数1 参数2 参数3
复制代码
示例脚本:
  1. [root@localhost cxk]# cat args_sh.sh
  2. function f(){
  3.         echo $1 $2 $3
  4.         echo "函数执行完毕。"
  5.         return 0
  6. }
  7. f "var1" "var2" "var3"
  8. exit 0
  9. [root@localhost cxk]# bash args_sh.sh
  10. var1 var2 var3
  11. 函数执行完毕。
复制代码
如何分文件
  1. 如果你要分文件,那么可以使用source 或者 .符号进行当前执行shell的bash中加载进来,所以这就是为什么我们不同shell之间就算定义了系统变量,也要重新加载的原因了吧 。
复制代码
fun.sh文件
  1. . fun.sh
  2. fun1
  3. fun2
  4. exit 0
复制代码
main.sh文件
  1. #!/bin/bash
  2. fun1(){
  3.         echo "fun11111 runing..."
  4. }
  5. fun2(){
  6.         echo "fun22222 runing..."
  7. }
复制代码
执行main.sh文件(可以看到成功分文件执行成功)
  1. [root@localhost cxk]# bash main.sh
  2. fun11111 runing...
  3. fun22222 runing...
  4. [root@localhost cxk]#
复制代码
规范
  1. 学过编程的同学都知道,我们程序主入口的名字一般都是main,
  2. 虽然我们shell中没有固定的main函数,但是我们还是进行一些规范化操作。
  3. 比如:
  4. fun1(){}
  5. fun2(){}
  6. 在定义了一系列函数之后,我们最后要写一个main函数来规范化我们的代码执行逻辑,一方面是方便阅读,二来也是对脚本的封装模块化能够有更深的理解。
复制代码
来源:https://www.cnblogs.com/dhan/p/18294949
免责声明:由于采集信息均来自互联网,如果侵犯了您的权益,请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容,谢谢合作!

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有账号?立即注册

x

举报 回复 使用道具