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 文件测试操作
                                  • 7.3 其他比较操作
                                    • 7.4 嵌套 if/then 条件测试
                                      • 7.5 牛刀小试
                                      • 第八章 运算符相关话题

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

                                              • 第九章 换个角度看变量

                                                • 9.1 内部变量
                                                  • 9.2 变量类型标注:declare 与 typeset
                                                    • declare/typeset 命令选项
                                                      • -r 只读(readonly)
                                                        • -i 整型(integer)
                                                          • -a 数组(array)
                                                            • -f 函数(function)
                                                              • -x 导出(export)
                                                                • -x var=$value
                                                                • 注记
                                                                • 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 风格指南
                                                                                                                                • 前端学习笔记

                                                                                                                                  9.2 变量类型标注:declare 与 typeset

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

                                                                                                                                  此页内容
                                                                                                                                  • declare/typeset 命令选项
                                                                                                                                    • -r 只读(readonly)
                                                                                                                                    • -i 整型(integer)
                                                                                                                                    • -a 数组(array)
                                                                                                                                    • -f 函数(function)
                                                                                                                                    • -x 导出(export)
                                                                                                                                    • -x var=$value
                                                                                                                                  • 注记

                                                                                                                                  # 9.2 变量类型标注:declare 与 typeset

                                                                                                                                  内建命令 declare 和 typeset 是完全相同的命令,其被用于修改变量的属性。相比起一部分编程语言来说,这种修改属于非常弱的类型标注方式[1]。declare 命令只有在 Bash version 2 及更高版本才能使用,而 typeset 命令可以在 ksh 脚本中运行。

                                                                                                                                  # declare/typeset 命令选项

                                                                                                                                  # -r 只读(readonly)

                                                                                                                                  (declare -r var1 与 readonly var1 的作用相同)

                                                                                                                                  该选项约等于 C 语言中的类型限定符 const。任何尝试修改只读变量的行为都会导致脚本出错。

                                                                                                                                  declare -r var1=1
                                                                                                                                  echo "var1 = $var1"   # var1 = 1
                                                                                                                                  
                                                                                                                                  (( var1++ ))          # x.sh: line 4: var1: readonly variable
                                                                                                                                  
                                                                                                                                  1
                                                                                                                                  2
                                                                                                                                  3
                                                                                                                                  4

                                                                                                                                  # -i 整型(integer)

                                                                                                                                  declare -i number
                                                                                                                                  # 脚本会将之后所有出现的 "number" 变量的类型都视作整型。
                                                                                                                                  
                                                                                                                                  number=3
                                                                                                                                  echo "Number = $number"     # Number = 3
                                                                                                                                  
                                                                                                                                  number=three
                                                                                                                                  echo "Number = $number"     # Number = 0
                                                                                                                                  # 脚本试图将字符串 "three" 视为整型。
                                                                                                                                  
                                                                                                                                  1
                                                                                                                                  2
                                                                                                                                  3
                                                                                                                                  4
                                                                                                                                  5
                                                                                                                                  6
                                                                                                                                  7
                                                                                                                                  8
                                                                                                                                  9

                                                                                                                                  被视为整型的变量无需命令 expr 或是 let 即可进行数学运算。

                                                                                                                                  n=6/3
                                                                                                                                  echo "n = $n"       # n = 6/3
                                                                                                                                  
                                                                                                                                  declare -i n
                                                                                                                                  n=6/3
                                                                                                                                  echo "n = $n"       # n = 2
                                                                                                                                  
                                                                                                                                  1
                                                                                                                                  2
                                                                                                                                  3
                                                                                                                                  4
                                                                                                                                  5
                                                                                                                                  6

                                                                                                                                  # -a 数组(array)

                                                                                                                                  declare -a indices
                                                                                                                                  
                                                                                                                                  1

                                                                                                                                  变量 indices 会被视作 数组。

                                                                                                                                  # -f 函数(function)

                                                                                                                                  declare -f
                                                                                                                                  
                                                                                                                                  1

                                                                                                                                  如果没有在 declare -f 后带上任何参数,该语句将会列出在脚本中已经定义的所有函数。

                                                                                                                                  declare -f function_name
                                                                                                                                  
                                                                                                                                  1

                                                                                                                                  而 declare -f function_name 则仅仅列出名为 function_name 的函数。

                                                                                                                                  # -x 导出(export)

                                                                                                                                  declare -x var3
                                                                                                                                  
                                                                                                                                  1

                                                                                                                                  该语句声明了变量 var3 可以导出到该变量所属脚本之外的 shell 环境中。

                                                                                                                                  # -x var=$value

                                                                                                                                  declare -x var3=373
                                                                                                                                  
                                                                                                                                  1

                                                                                                                                  declare 命令允许在设置变量属性的同时给变量赋值。

                                                                                                                                  # 样例9-10. 使用 declare 命令标注变量类型

                                                                                                                                  #!/bin/bash
                                                                                                                                  
                                                                                                                                  func1 ()
                                                                                                                                  {
                                                                                                                                    echo This is a function.
                                                                                                                                  }
                                                                                                                                  
                                                                                                                                  declare -f        # 显示上面的所有函数。
                                                                                                                                  
                                                                                                                                  echo
                                                                                                                                  
                                                                                                                                  declare -i var1   # var1 是一个整型变量。
                                                                                                                                  var1=2367
                                                                                                                                  echo "var1 declared as $var1"
                                                                                                                                  var1=var1+1       # 整型变量的运算可以省略 let 命令。
                                                                                                                                  echo "var1 incremented by 1 is $var1."
                                                                                                                                  # 尝试修改整型变量。
                                                                                                                                  echo "Attempting to change var1 to floating point value, 2367.1."
                                                                                                                                  var1=2367.1       # 报错,并且 var1 的值并没有被修改。
                                                                                                                                  echo "var1 is still $var1"
                                                                                                                                  
                                                                                                                                  echo
                                                                                                                                  
                                                                                                                                  declare -r var2=13.36         # 'declare' 允许在设置变量属性时,
                                                                                                                                                                #+ 同时给变量赋值。
                                                                                                                                  echo "var2 declared as $var2" # 尝试修改只读变量。
                                                                                                                                  var2=13.37                    # 报错,然后脚本异常结束。
                                                                                                                                  
                                                                                                                                  echo "var2 is still $var2"    # 这行语句将不会被执行。
                                                                                                                                  
                                                                                                                                  exit 0                        # 脚本也不会从这里结束。
                                                                                                                                  
                                                                                                                                  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

                                                                                                                                  {% hint style="warning" %}

                                                                                                                                  使用内建命令 declare 还可以限制变量的 作用域。

                                                                                                                                  foo ()
                                                                                                                                  {
                                                                                                                                  FOO="bar"
                                                                                                                                  }
                                                                                                                                  
                                                                                                                                  bar ()
                                                                                                                                  {
                                                                                                                                  foo
                                                                                                                                  echo $FOO
                                                                                                                                  }
                                                                                                                                  
                                                                                                                                  bar   # 输出 bar。
                                                                                                                                  
                                                                                                                                  1
                                                                                                                                  2
                                                                                                                                  3
                                                                                                                                  4
                                                                                                                                  5
                                                                                                                                  6
                                                                                                                                  7
                                                                                                                                  8
                                                                                                                                  9
                                                                                                                                  10
                                                                                                                                  11
                                                                                                                                  12

                                                                                                                                  但是...

                                                                                                                                  foo(){
                                                                                                                                  declare FOO="bar"
                                                                                                                                  }
                                                                                                                                  
                                                                                                                                  bar ()
                                                                                                                                  {
                                                                                                                                  foo
                                                                                                                                  echo $FOO
                                                                                                                                  }
                                                                                                                                  
                                                                                                                                  bar  # 什么都不会输出。
                                                                                                                                  
                                                                                                                                  
                                                                                                                                  # 感谢 Michael Iatrou 指出这点。
                                                                                                                                  
                                                                                                                                  1
                                                                                                                                  2
                                                                                                                                  3
                                                                                                                                  4
                                                                                                                                  5
                                                                                                                                  6
                                                                                                                                  7
                                                                                                                                  8
                                                                                                                                  9
                                                                                                                                  10
                                                                                                                                  11
                                                                                                                                  12
                                                                                                                                  13
                                                                                                                                  14

                                                                                                                                  {% endhint %}

                                                                                                                                  # 注记

                                                                                                                                  {% hint style="info" %} 在本书中,变量类型标注(typing)是指指定变量类型并限制其属性。例如一个变量被 declared 或是 typed 命令声明为整型,则该变量不再适用于各种 字符串操作。

                                                                                                                                  declare -i intvar
                                                                                                                                  
                                                                                                                                  intvar=23
                                                                                                                                  echo "$intvar"   # 23
                                                                                                                                  intvar=stringval
                                                                                                                                  echo "$intvar"   # 0
                                                                                                                                  
                                                                                                                                  1
                                                                                                                                  2
                                                                                                                                  3
                                                                                                                                  4
                                                                                                                                  5
                                                                                                                                  6

                                                                                                                                  {% endhint %}


                                                                                                                                  1. Footnotes placeholder ↩︎

                                                                                                                                  edit icon编辑此页open in new window
                                                                                                                                  上次编辑于: 2022/4/27 15:33:00
                                                                                                                                  贡献者: clay-wangzhi
                                                                                                                                  上一页
                                                                                                                                  9.1 内部变量
                                                                                                                                  下一页
                                                                                                                                  9.2.1 declare 的另类用法
                                                                                                                                  备案号:冀ICP备2021007336号
                                                                                                                                  Copyright © 2022 LinuxStory