Skip to content
SRE运维进阶之路SRE运维进阶之路
github icon
    • 第一部分 初见shell

      • 第一章 为什么使用shell编程
        • 第二章 和Sha-Bang(#!)一起出发

          • 2.1 调用一个脚本
            • 2.2 牛刀小试
          • 第二部分 shell基础

            • 第三章 特殊字符
              • 第四章 变量与参数

                • 4.1 变量替换
                  • 4.2 变量赋值
                    • 4.3 Bash变量是弱类型的
                      • /code/shell/part2/04_4_special_variable_types
                      • 第五章 引用

                        • 5.1 引用变量
                          • 5.2 转义
                          • 第六章 退出与退出状态
                            • 第七章 测试

                              • 7.1 测试结构
                                • 7.2 文件测试操作
                                  • -e
                                    • -a
                                      • -f
                                        • -s
                                          • -d
                                            • -b
                                              • -c
                                                • -p
                                                  • -h
                                                    • -L
                                                      • -S
                                                        • -t
                                                          • -r
                                                            • -w
                                                              • -x
                                                                • -g
                                                                  • -u
                                                                    • -k
                                                                      • -O
                                                                        • -G
                                                                          • -N
                                                                            • f1 -nt f2
                                                                              • f1 -ot f2
                                                                                • f1 -ef f2
                                                                                  • !
                                                                                  • 7.3 其他比较操作
                                                                                    • 7.4 嵌套 if/then 条件测试
                                                                                      • 7.5 牛刀小试
                                                                                      • 第八章 运算符相关话题

                                                                                        • 8.1 运算符
                                                                                          • 8.2 数字常量
                                                                                            • 8.3 双圆括号结构
                                                                                              • 8.4 运算符优先级
                                                                                            • 第三部分 shell进阶

                                                                                              • 第九章 换个角度看变量

                                                                                                • 9.1 内部变量
                                                                                                  • 9.2 变量类型标注:declare 与 typeset
                                                                                                    • 9.2.1 declare 的另类用法
                                                                                                      • 9.3 $RANDOM:生成随机数
                                                                                                      • 第十章 变量处理

                                                                                                        • 10.1 字符串处理
                                                                                                          • 10.1.1 使用 awk 处理字符串
                                                                                                            • 10.1.2 参考资料
                                                                                                              • 10.2 参数替换
                                                                                                              • 第十一章 循环与分支

                                                                                                                • 11.1 循环
                                                                                                                  • 11.2 嵌套循环
                                                                                                                    • 11.3 循环控制
                                                                                                                      • 11.4 测试与分支
                                                                                                                      • 第十二章 命令替换
                                                                                                                        • 第十三章 算术扩展
                                                                                                                        • 第四部分 命令
                                                                                                                          • 第五部分 高级话题

                                                                                                                            • 18 正则表达式

                                                                                                                              • 18.1 正则表达式简介
                                                                                                                                • 18.2文件名替换
                                                                                                                                  • 18.3 正则表达式对照表
                                                                                                                                  • 19 嵌入文档
                                                                                                                                    • 20 I/O 重定向

                                                                                                                                      • 20.1 使用 exec
                                                                                                                                        • 20.2 重定向代码块
                                                                                                                                          • 20.3 应用程序
                                                                                                                                          • 第二十一章 子shell
                                                                                                                                            • 第二十二章. 限制模式的Shell
                                                                                                                                              • 第二十三章. 进程替换
                                                                                                                                                • 24 函数

                                                                                                                                                  • 24.1 复杂函数和函数复杂性
                                                                                                                                                    • 24.2 局部变量
                                                                                                                                                      • 24.3 不使用局部变量的递归
                                                                                                                                                      • 25. 别名
                                                                                                                                                        • 26. 列表结构
                                                                                                                                                          • 27 数组
                                                                                                                                                            • 30 网络编程
                                                                                                                                                              • 33 选项
                                                                                                                                                                • 第34章 陷阱
                                                                                                                                                                  • 第36章 杂项
                                                                                                                                                                    • echo命令
                                                                                                                                                                    • 第六部分 Google Shell 风格指南
                                                                                                                                                                    • 前端学习笔记

                                                                                                                                                                      7.2 文件测试操作

                                                                                                                                                                      author iconLinuxStorycalendar icon2021年5月11日category icon
                                                                                                                                                                      • Linux
                                                                                                                                                                      tag icon
                                                                                                                                                                      • Bash
                                                                                                                                                                      timer icon大约 5 分钟

                                                                                                                                                                      此页内容
                                                                                                                                                                      • -e
                                                                                                                                                                      • -a
                                                                                                                                                                      • -f
                                                                                                                                                                      • -s
                                                                                                                                                                      • -d
                                                                                                                                                                      • -b
                                                                                                                                                                      • -c
                                                                                                                                                                      • -p
                                                                                                                                                                      • -h
                                                                                                                                                                      • -L
                                                                                                                                                                      • -S
                                                                                                                                                                      • -t
                                                                                                                                                                      • -r
                                                                                                                                                                      • -w
                                                                                                                                                                      • -x
                                                                                                                                                                      • -g
                                                                                                                                                                      • -u
                                                                                                                                                                      • -k
                                                                                                                                                                      • -O
                                                                                                                                                                      • -G
                                                                                                                                                                      • -N
                                                                                                                                                                      • f1 -nt f2
                                                                                                                                                                      • f1 -ot f2
                                                                                                                                                                      • f1 -ef f2
                                                                                                                                                                      • !

                                                                                                                                                                      # 7.2 文件测试操作

                                                                                                                                                                      下列每一个运算符在满足其下条件时,返回的结果为真。

                                                                                                                                                                      # -e

                                                                                                                                                                      检测文件是否存在

                                                                                                                                                                      # -a

                                                                                                                                                                      检测文件是否存在

                                                                                                                                                                      等价于 -e。不推荐使用,已被弃用[1]。

                                                                                                                                                                      # -f

                                                                                                                                                                      文件是常规文件(regular file),而非目录或 设备文件open in new window

                                                                                                                                                                      # -s

                                                                                                                                                                      文件大小不为0

                                                                                                                                                                      # -d

                                                                                                                                                                      文件是一个目录

                                                                                                                                                                      # -b

                                                                                                                                                                      文件是一个 块设备open in new window

                                                                                                                                                                      # -c

                                                                                                                                                                      文件是一个 字符设备open in new window

                                                                                                                                                                      device0="/dev/sda2"    # /   (根目录)
                                                                                                                                                                      if [ -b "$device0" ]
                                                                                                                                                                      then
                                                                                                                                                                        echo "$device0 is a block device."
                                                                                                                                                                      fi
                                                                                                                                                                      
                                                                                                                                                                      # /dev/sda2 是一个块设备。
                                                                                                                                                                      
                                                                                                                                                                      
                                                                                                                                                                      
                                                                                                                                                                      device1="/dev/ttyS1"   # PCMCIA 调制解调卡
                                                                                                                                                                      if [ -c "$device1" ]
                                                                                                                                                                      then
                                                                                                                                                                        echo "$device1 is a character device."
                                                                                                                                                                      fi
                                                                                                                                                                      
                                                                                                                                                                      # /dev/ttyS1 是一个字符设备。
                                                                                                                                                                      
                                                                                                                                                                      1
                                                                                                                                                                      2
                                                                                                                                                                      3
                                                                                                                                                                      4
                                                                                                                                                                      5
                                                                                                                                                                      6
                                                                                                                                                                      7
                                                                                                                                                                      8
                                                                                                                                                                      9
                                                                                                                                                                      10
                                                                                                                                                                      11
                                                                                                                                                                      12
                                                                                                                                                                      13
                                                                                                                                                                      14
                                                                                                                                                                      15
                                                                                                                                                                      16
                                                                                                                                                                      17

                                                                                                                                                                      # -p

                                                                                                                                                                      文件是一个 管道设备open in new window

                                                                                                                                                                      function show_input_type()
                                                                                                                                                                      {
                                                                                                                                                                         [ -p /dev/fd/0 ] && echo PIPE || echo STDIN
                                                                                                                                                                      }
                                                                                                                                                                      
                                                                                                                                                                      show_input_type "Input"                           # STDIN
                                                                                                                                                                      echo "Input" | show_input_type                    # PIPE
                                                                                                                                                                      
                                                                                                                                                                      # 这个例子由 Carl Anderson 提供。
                                                                                                                                                                      
                                                                                                                                                                      1
                                                                                                                                                                      2
                                                                                                                                                                      3
                                                                                                                                                                      4
                                                                                                                                                                      5
                                                                                                                                                                      6
                                                                                                                                                                      7
                                                                                                                                                                      8
                                                                                                                                                                      9

                                                                                                                                                                      # -h

                                                                                                                                                                      文件是一个 符号链接open in new window

                                                                                                                                                                      # -L

                                                                                                                                                                      文件是一个符号链接

                                                                                                                                                                      # -S

                                                                                                                                                                      文件是一个 套接字open in new window

                                                                                                                                                                      # -t

                                                                                                                                                                      文件(文件描述符open in new window)与终端设备关联

                                                                                                                                                                      该选项通常被用于 测试open in new window 脚本中的 stdin [ -t 0 ] 或 stdout [ -t 1 ] 是否为终端设备。

                                                                                                                                                                      # -r

                                                                                                                                                                      该文件对执行测试的用户可读

                                                                                                                                                                      # -w

                                                                                                                                                                      该文件对执行测试的用户可写

                                                                                                                                                                      # -x

                                                                                                                                                                      该文件可被执行测试的用户所执行

                                                                                                                                                                      # -g

                                                                                                                                                                      文件或目录设置了 set-group-id sgid 标志

                                                                                                                                                                      如果一个目录设置了 sgid 标志,那么在该目录中所有的新建文件的权限组都归属于该目录的权限组,而非文件创建者的权限组。该标志对共享文件夹很有用。

                                                                                                                                                                      # -u

                                                                                                                                                                      文件设置了 set-user-id suid 标志。

                                                                                                                                                                      一个属于 root 的可执行文件设置了 suid 标志后,即使是一个普通用户执行也拥有 root 权限[2]。对需要访问硬件设备的可执行文件(例如 pppd 和 cdrecord)很有用。如果没有 suid 标志,这些可执行文件就不能被非 root 用户所调用了。

                                                                                                                                                                      -rwsr-xr-t    1 root       178236 Oct  2  2000 /usr/sbin/pppd
                                                                                                                                                                      
                                                                                                                                                                      1

                                                                                                                                                                      设置了 suid 标志后,在权限中会显示 s。

                                                                                                                                                                      # -k

                                                                                                                                                                      设置了粘滞位(sticky bit)。

                                                                                                                                                                      标志粘滞位是一种特殊的文件权限。如果文件设置了粘滞位,那么该文件将会被存储在高速缓存中以便快速访问[3]。如果目录设置了该标记,那么它将会对目录的写权限进行限制,目录中只有文件的拥有者可以修改或删除文件。设置标记后你可以在权限中看到 t。

                                                                                                                                                                      drwxrwxrwt    7 root         1024 May 19 21:26 tmp/
                                                                                                                                                                      
                                                                                                                                                                      1

                                                                                                                                                                      如果一个用户不是设置了粘滞位目录的拥有者,但对该目录有写权限,那么他仅仅可以删除目录中他所拥有的文件。这可以防止用户不经意间删除或修改其他人的文件,例如 /tmp 文件夹。(当然目录的所有者可以删除或修改该目录下的所有文件)

                                                                                                                                                                      # -O

                                                                                                                                                                      执行用户是文件的拥有者

                                                                                                                                                                      # -G

                                                                                                                                                                      文件的组与执行用户的组相同

                                                                                                                                                                      # -N

                                                                                                                                                                      文件在在上次访问后被修改过了

                                                                                                                                                                      # f1 -nt f2

                                                                                                                                                                      文件 f1 比文件 f2 新

                                                                                                                                                                      # f1 -ot f2

                                                                                                                                                                      文件 f1 比文件 f2 旧

                                                                                                                                                                      # f1 -ef f2

                                                                                                                                                                      文件 f1 和文件 f2 硬链接到同一个文件

                                                                                                                                                                      # !

                                                                                                                                                                      取反——对测试结果取反(如果条件缺失则返回真)。

                                                                                                                                                                      样例 7-4. 检测链接是否损坏

                                                                                                                                                                      #!/bin/bash
                                                                                                                                                                      # broken-link.sh
                                                                                                                                                                      # Lee bigelow <ligelowbee@yahoo.com> 编写。
                                                                                                                                                                      # ABS Guide 经许可可以使用。
                                                                                                                                                                      
                                                                                                                                                                      #  该脚本用来发现输出损坏的链接。输出的结果是被引用的,
                                                                                                                                                                      #+ 所以可以直接导到 xargs 中进行处理 :)
                                                                                                                                                                      #  例如:sh broken-link.sh /somedir /someotherdir|xargs rm
                                                                                                                                                                      #
                                                                                                                                                                      #  更加优雅的方式:
                                                                                                                                                                      #
                                                                                                                                                                      #  find "somedir" -type 1 -print0|\
                                                                                                                                                                      #  xargs -r0 file|\
                                                                                                                                                                      #  grep "broken symbolic"|
                                                                                                                                                                      #  sed -e 's/^\|: *broken symbolic.*$/"/g'
                                                                                                                                                                      #
                                                                                                                                                                      #  但是这种方法不是纯 Bash 写法。
                                                                                                                                                                      #  警告:小心 /proc 文件下的文件和任意循环链接!
                                                                                                                                                                      ############################################
                                                                                                                                                                      
                                                                                                                                                                      
                                                                                                                                                                      #  如果不给脚本传任何参数,那么 directories-to-search 设置为当前目录
                                                                                                                                                                      #+ 否则设置为传进的参数
                                                                                                                                                                      #####################
                                                                                                                                                                      
                                                                                                                                                                      [ $# -eq 0 ] && directory=`pwd` || directory=$@
                                                                                                                                                                      
                                                                                                                                                                      
                                                                                                                                                                      #  函数 linkchk 是用来检测传入的文件夹中是否包含损坏的链接文件,
                                                                                                                                                                      #+ 并引用输出他们。
                                                                                                                                                                      #  如果文件夹中包含子文件夹,那么将子文件夹继续传给 linkchk 函数进行检测。
                                                                                                                                                                      #################
                                                                                                                                                                      
                                                                                                                                                                      linkchk () {
                                                                                                                                                                          for element in $1/*; do
                                                                                                                                                                            [ -h "$element" -a ! -e "$element" ] && echo \"$element\"
                                                                                                                                                                            [ -d "$element" ] && linkchk $element
                                                                                                                                                                          # -h 用来检测是否是链接,-d 用来检测是否是文件夹。
                                                                                                                                                                          done
                                                                                                                                                                      }
                                                                                                                                                                      
                                                                                                                                                                      #  检测传递给 linkchk() 函数的参数是否是一个存在的文件夹,
                                                                                                                                                                      #+ 如果不是则报错。
                                                                                                                                                                      ################
                                                                                                                                                                      for directory in $direcotrys; do
                                                                                                                                                                          if [ -d $directory ]
                                                                                                                                                                              then linkchk $directory
                                                                                                                                                                              else
                                                                                                                                                                                  echo "$directory is not a directory"
                                                                                                                                                                                  echo "Usage $0 dir1 dir2 ..."
                                                                                                                                                                          fi
                                                                                                                                                                      done
                                                                                                                                                                      
                                                                                                                                                                      exit $?
                                                                                                                                                                      
                                                                                                                                                                      1
                                                                                                                                                                      2
                                                                                                                                                                      3
                                                                                                                                                                      4
                                                                                                                                                                      5
                                                                                                                                                                      6
                                                                                                                                                                      7
                                                                                                                                                                      8
                                                                                                                                                                      9
                                                                                                                                                                      10
                                                                                                                                                                      11
                                                                                                                                                                      12
                                                                                                                                                                      13
                                                                                                                                                                      14
                                                                                                                                                                      15
                                                                                                                                                                      16
                                                                                                                                                                      17
                                                                                                                                                                      18
                                                                                                                                                                      19
                                                                                                                                                                      20
                                                                                                                                                                      21
                                                                                                                                                                      22
                                                                                                                                                                      23
                                                                                                                                                                      24
                                                                                                                                                                      25
                                                                                                                                                                      26
                                                                                                                                                                      27
                                                                                                                                                                      28
                                                                                                                                                                      29
                                                                                                                                                                      30
                                                                                                                                                                      31
                                                                                                                                                                      32
                                                                                                                                                                      33
                                                                                                                                                                      34
                                                                                                                                                                      35
                                                                                                                                                                      36
                                                                                                                                                                      37
                                                                                                                                                                      38
                                                                                                                                                                      39
                                                                                                                                                                      40
                                                                                                                                                                      41
                                                                                                                                                                      42
                                                                                                                                                                      43
                                                                                                                                                                      44
                                                                                                                                                                      45
                                                                                                                                                                      46
                                                                                                                                                                      47
                                                                                                                                                                      48
                                                                                                                                                                      49
                                                                                                                                                                      50
                                                                                                                                                                      51
                                                                                                                                                                      52
                                                                                                                                                                      53
                                                                                                                                                                      54

                                                                                                                                                                      样例 31-1open in new window,样例 11-8open in new window,样例 11-3open in new window,样例 31-3open in new window和样例 A-1open in new window 也包含了测试运算符的使用。


                                                                                                                                                                      1. 摘自1913年版本的韦氏词典

                                                                                                                                                                        Deprecate
                                                                                                                                                                        ...

                                                                                                                                                                        To pray against, as an evil;
                                                                                                                                                                        to seek to avert by prayer;
                                                                                                                                                                        to desire the removal of;
                                                                                                                                                                        to seek deliverance from;
                                                                                                                                                                        to express deep regret for;
                                                                                                                                                                        to disapprove of strongly.
                                                                                                                                                                        ↩︎

                                                                                                                                                                      2. 注意使用 suid 的可执行文件可能会带来安全问题。suid 标记对 shell 脚本没有影响。 ↩︎

                                                                                                                                                                      3. 在 Linux 系统中,文件已经不使用粘滞位了, 粘滞位只作用于目录。 ↩︎

                                                                                                                                                                      edit icon编辑此页open in new window
                                                                                                                                                                      上次编辑于: 2022/4/27 15:33:00
                                                                                                                                                                      贡献者: clay-wangzhi
                                                                                                                                                                      上一页
                                                                                                                                                                      7.1 测试结构
                                                                                                                                                                      下一页
                                                                                                                                                                      7.3 其他比较操作
                                                                                                                                                                      备案号:冀ICP备2021007336号
                                                                                                                                                                      Copyright © 2023 LinuxStory