shell语法保姆级教程

Shell脚本

建立一个sh脚本

1. touch 1.sh (新建脚本文件)
   
2. vi 1.sh（编写文件内容）
   
3. 按 i 可以写入内容，按esc :wq退出并保存

复制代码

解释
1、创建脚本文件
2、脚本文件中第一行为指定脚本编译器：# !/bin/bash
最终调用的都是dash

执行shell脚本下令：1、./1.sh

难道我们必须要修改权限才能执行sh脚本吗?让我们看一下接下来的两种方式。

1. 2、bash+文件名相对路径\绝对路径
   
2. 
   
3. 3、.sh+文件名相对路径\绝对路径

复制代码

当然我们的source也可以执行4、source+文件名相对路径\绝对路径

shell脚本变量

在Kali Linux体系中，体系变量（也称为环境变量）是在整个用户会话或整个操作体系中可用的变量。这些变量可以存储诸如路径、设置信息、用户设置等数据，并且可以在体系中的多个程序和脚本之间共享。以下是一些常见的Kali Linux体系变量及其作用域：
全局体系变量（作用于整个操作体系）

• PATH
  
  
  
  • 作用：包含可执行文件的目次列表，当用户在终端输入下令时，体系会在这些目次中查找相应的可执行文件。
    
  • 示例：/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
    
  
  
• HOME
  
  
  
  • 作用：指向当前用户主目次的路径。
    
  • 示例：/home/user
    
  
  
• USER
  
  
  
  • 作用：当前登录用户的用户名。
    
  • 示例：kali
    
  
  
• SHELL
  
  
  
  • 作用：当前用户登录的shell范例。
    
  • 示例：/bin/bash
    
  
  
• LANG
  
  
  
  • 作用：界说体系的语言和字符集。
    
  • 示例：en_US.UTF-8
    
  
  
• PWD
  
  
  
  • 作用：当前工作目次的绝对路径。
    
  • 示例：/home/user/projects
    
  
  

用户级别的环境变量

用户可以在自己的主目次下的.bashrc或.profile文件中设置特定的环境变量，这些变量仅对该用户会话有用。
设置用户级别的环境变量

• 打开终端。
  
• 编辑 .bashrc 文件：
  1. nano ~/.bashrc

  复制代码
• 添加新的环境变量：
  1. export MY_VARIABLE="my_value"

  复制代码
• 使更改生效：
  1. source ~/.bashrc

  复制代码

利用 env 或 printenv 下令查看环境变量

• **env**：体现当前所有的环境变量。
  
• **printenv**：可以查看特定环境变量的值，比方：
  1. printenv PATH

  复制代码

注意事项

• 修改体系级别的环境变量通常需要管理员权限。
  
• 对于暂时设置环境变量，可以在当前终端会话中利用 export 下令，但该设置不会在新的终端窗口或会话中保留。
  

在Kali Linux体系中，设置持续化变量（永久环境变量）意味着要设置环境变量，使其在体系重启后仍然有用。这通常涉及到修改用户级别的设置文件（如.bashrc或.profile）或体系级别的设置文件（如/etc/profile）。以下是设置Kali Linux中持续化变量的步骤：
设置用户级别的永久环境变量

• 打开终端。
  
• 编辑用户级别的设置文件。对于Bash shell用户，通常是.bashrc文件；对于Zsh shell用户，则是.zshrc文件。
  1. nano ~/.bashrc

  复制代码
• 添加新的环境变量，并利用export下令。比方：
  1. export MY_VARIABLE="my_value"

  复制代码
• 保存文件并退出编辑器。
  
• 使更改生效，执行以下下令：
  1. source ~/.bashrc

  复制代码

设置体系级别的永久环境变量

对于体系级别的环境变量，需要编辑/etc/profile文件。请利用root权限执行以下操作：

• 打开终端。
  
• 利用文本编辑器打开/etc/profile文件。比方，利用nano编辑器：
  1. sudo nano /etc/profile

  复制代码
• 在文件末尾添加新的环境变量，并利用export下令。比方：
  1. export SYSTEM_VARIABLE="system_value"

  复制代码
• 保存文件并退出编辑器。
  
• 使更改生效，执行以下下令：
  1. source /etc/profile

  复制代码

暂时环境变量

通过在变量前加上export，将变量变为暂时环境变量。
在Kali Linux体系中，暂时环境变量是指仅在当前终端会话中有用的变量。一旦关闭终端或会话结束，这些变量就会丢失。设置暂时环境变量非常简单，只需在终端中利用export下令即可。
设置暂时环境变量

• 打开终端。
  
• 利用export下令设置暂时环境变量。比方：
  1. export TEMP_VARIABLE="temp_value"

  复制代码

查看暂时环境变量

• 利用env下令查看当前所有的环境变量，包罗暂时设置的变量：
  1. env | grep TEMP_VARIABLE

  复制代码
• 或者利用printenv下令查看特定暂时环境变量的值：
  1. printenv TEMP_VARIABLE

  复制代码

注意事项

• 暂时环境变量仅在当前终端会话中有用，关闭终端或会话结束后，这些变量将不再存在。
  
• 如果需要在多个终端会话中共享变量，发起设置持续化环境变量（永久环境变量）。
  

自界说变量(普通变量作用域：当前解释器）

在Kali Linux体系中，自界说变量（普通变量）通常指的是在脚本或下令行中界说的局部变量，其作用域仅限于当前解释器会话或脚本执行期间。这些变量不会影响到其他终端会话或全局环境变量。
设置自界说变量

• 在脚本中设置自界说变量
  打开一个文本编辑器，创建一个新的脚本文件，比方my_script.sh，并在其中界说变量：
  1. #!/bin/bash
     
  2. MY_CUSTOM_VAR="Hello, Kali!"
     
  3. echo $MY_CUSTOM_VAR

  复制代码
  保存文件并赋予执行权限：
  1. chmod +x my_script.sh

  复制代码
  运行脚本：
  1. ./my_script.sh

  复制代码
  输出将是：
  1. Hello, Kali!

  复制代码
• 在下令行中设置自界说变量
  在终端中直接界说变量并利用：
  1. MY_CUSTOM_VAR="Hello, Kali!"
     
  2. echo $MY_CUSTOM_VAR

  复制代码
  输出将是：
  1. Hello, Kali!

  复制代码

注意事项

• 自界说变量的作用域仅限于当前解释器会话或脚本执行期间。
  
• 变量名通常以字母或下划线开头，背面可以跟字母、数字或下划线。
  
• 变量值可以是字符串、数字或其他范例的数据。
  

通过以上步骤，您可以在Kali Linux体系中轻松地创建和利用自界说变量，这些变量仅在当前解释器会话中有用。

1. eg:
   
2. 定义一个name变量：name=”leyinsec”
   
3. 利用echo打印输出echo $name

复制代码

注：空格需要用引号，引起来（空格代表结束）
变量作用域

在Kali Linux体系中，变量的作用域决定了变量在何处以及如何被访问。以下是几种常见的变量作用域：
1. 局部变量（Local Variables）

• 作用域：仅在界说它们的函数或代码块内有用。
  
• 示例：
  1. function my_function() {
     
  2.     local MY_VAR="This is local"
     
  3.     echo $MY_VAR
     
  4. }
     
  5. my_function
     
  6. echo $MY_VAR  # 这将不会输出任何内容，因为MY_VAR在函数外部不可见

  复制代码

2. 全局变量（Global Variables）

• 作用域：在整个脚本或程序中有用，包罗所有函数和代码块。
  
• 示例：
  1. MY_VAR="This is global"
     
  2. function my_function() {
     
  3.     echo $MY_VAR
     
  4. }
     
  5. my_function
     
  6. echo $MY_VAR  # 这将输出 "This is global"

  复制代码

3. 环境变量（Environment Variables）

• 作用域：在整个用户会话或整个操作体系中有用。
  
• 设置：
  1. export MY_ENV_VAR="This is an environment variable"

  复制代码
• 查看：
  1. printenv MY_ENV_VAR

  复制代码

4. 用户级别的环境变量

• 作用域：仅对当前用户有用。
  
• 设置：
  1. echo "export MY_USER_VAR='This is a user-specific environment variable'" >> ~/.bashrc
  2. source ~/.bashrc

  复制代码

5. 体系级别的环境变量

• 作用域：对所有用户有用。
  
• 设置：
  1. sudo sh -c 'echo "export MY_SYSTEM_VAR='This is a system-wide environment variable'" >> /etc/profile'
  2. source /etc/profile

  复制代码

6. 暂时变量（Temporary Variables）

• 作用域：仅在当前终端会话中有用。
  
• 设置：
  1. export TEMP_VAR="This is temporary"

  复制代码
• 关闭终端后，TEMP_VAR将不再存在。
  

总结

• 局部变量：仅在界说它们的函数或代码块内有用。
  
• 全局变量：在整个脚本或程序中有用。
  
• 环境变量：在整个用户会话或整个操作体系中有用。
  
• 用户级别的环境变量：仅对当前用户有用。
  
• 体系级别的环境变量：对所有用户有用。
  
• 暂时变量：仅在当前终端会话中有用。
  

特别变量

在Kali Linux体系中，特别变量重要指的是那些具有特别寄义和用途的变量。这些变量由Bash shell提供，用于在脚本和下令行中存储和传递信息。以下是一些常见的特别变量及其作用：
特别变量列表

• **$0**：当前脚本的文件名。
  
• **$n**：传递给脚本或函数的参数。n是一个数字，表示第几个参数。
  
• **$#**：传递给脚本或函数的参数个数。
  
• **$@**：传递给脚本或函数的所有参数。
  
• **$***：传递给脚本或函数的所有参数。被双引号包含时，与$@稍有不同。
  
• **$?**：上个下令的退出状态，或函数的返回值。
  
• **$$**：当前Shell进程ID。
  

特别变量的利用示例

假设我们有一个脚本test.sh，内容如下：

1. #!/bin/bash
   
2. echo "File Name: $0"
   
3. echo "First Parameter: $1"
   
4. echo "Second Parameter: $2"
   
5. echo "Quoted Values: $@"
   
6. echo "Quoted Values: $*"
   
7. echo "Total Number of Parameters: $#"

复制代码

运行该脚本并传入两个参数：

1. ./test.sh Zara Ali

复制代码

输出将是：

1. File Name: ./test.sh
   
2. First Parameter: Zara
   
3. Second Parameter: Ali
   
4. Quoted Values: Zara Ali
   
5. Quoted Values: Zara Ali
   
6. Total Number of Parameters: 2

复制代码

shell脚本——字符串（2）

字符串的常见操作

在Shell脚本中，对字符串进行操作是常见的任务。以下是一些常见的字符串操作：
1. 字符串拼接

你可以直接将两个字符串放在一起，或者利用+运算符（在某些Shell中）来拼接字符串。

1. str1="Hello"
   
2. str2="World"
   
3. combined="${str1}${str2}"
   
4. echo $combined  # 输出: HelloWorld

复制代码

2. 获取字符串长度

利用${#string}来获取字符串的长度。

1. str="Hello, World!"
   
2. length=${#str}
   
3. echo $length  # 输出: 13

复制代码

3. 子字符串提取

利用${string:start:length}来提取子字符串。

1. str="Hello, World!"
   
2. substr=${str:7:5}
   
3. echo $substr  # 输出: World

复制代码

4. 字符串查找

利用expr index或grep来查找子字符串的位置。

1. str="Hello, World!"
   
2. pos=$(expr index "$str" "World")
   
3. echo $pos  # 输出: 8

复制代码

5. 字符串更换

利用${string/old/new}来进行简单的更换，或者利用sed进行更复杂的更换。

1. str="Hello, World!"
   
2. new_str=${str/World/Universe}
   
3. echo $new_str  # 输出: Hello, Universe!

复制代码

6. 字符串分割

利用IFS（内部字段分隔符）来分割字符串。

1. str="apple,banana,cherry"
   
2. IFS=',' read -ra ADDR <<< "$str"
   
3. for i in "${ADDR[@]}"; do
   
4.     echo "$i"
   
5. done
   
6. # 输出:
   
7. # apple
   
8. # banana
   
9. # cherry

复制代码

将上述脚本保存为myscript.sh，并赋予执行权限：

1. str1="Hello"
   
2. str2="Hello"
   
3. if [ "$str1" == "$str2" ]; then
   
4.     echo "Strings are equal"
   
5. else
   
6.     echo "Strings are not equal"
   
7. fi

复制代码

运行脚本并提供不同的参数组合：

1. str="Hello, World!"
   
2. upper=$(echo "$str" | tr '[:lower:]' '[:upper:]')
   
3. echo $upper  # 输出: HELLO, WORLD!

复制代码

输出结果：

1. str="Hello, World!"
   
2. trimmed=${str%,*}
   
3. echo $trimmed  # 输出: Hello,

复制代码

在这个示例中，我们利用了getopts下令来解析传递给脚本的参数。getopts支持短选项（如-a、-b等），并根据提供的参数执行相应的操作。你可以根据需要在case语句中添加更多选项。
如果你想支持长选项（如--option1、--option2等），可以利用getopt下令或利用更高级的参数解析库，如Python的argparse模块或Ruby的optparse库。
循环利用参数

在Shell脚本中，可以利用for循环来遍历并处理传递给脚本的参数

1. str="Hello, World!"
   
2. reversed=$(echo "$str" | rev)
   
3. echo $reversed  # 输出: !dlroW ,olleH

复制代码

将上述脚本保存为myscript.sh，并赋予执行权限：

1. str1="Hello"
   
2. str2="Hello"
   
3. if [ "$str1" == "$str2" ]; then
   
4.     echo "Strings are equal"
   
5. else
   
6.     echo "Strings are not equal"
   
7. fi

复制代码

运行脚本并提供不同的参数组合：

1. str="Hello, World!"
   
2. upper=$(echo "$str" | tr '[:lower:]' '[:upper:]')
   
3. echo $upper  # 输出: HELLO, WORLD!./myscript.sh -a -b
4. ./myscript.sh -a -c
5. ./myscript.sh -b -c

复制代码

输出结果：

1. #!/bin/bash
   
2. 
   
3. string="Hello, World!"
   
4. length=${#string}
   
5. 
   
6. echo "The length of the string is: $length"

复制代码

在这个示例中，我们界说了一个名为process_args的函数来处理参数组合。我们利用了getopts下令来解析传递给脚本的参数，并根据不同的参数组合执行不同的操作。我们还支持了嵌套参数组合，比方选项A和B、选项A和C、选项B和C以及选项A、B和C。
参数传递的映射

在Shell脚本中，可以利用关联数组（associative arrays）来实现参数传递的映射

1. The length of the string is: 13

复制代码

5. 利用 expect 工具

expect 是一个用于自动化交互式应用程序的工具，通常用于自动化SSH登录等操作。
首先，确保你已经安装了 expect 工具：

1. #!/bin/bash
   
2. 
   
3. text="Hello, Kali Linux!"
   
4. substring="Kali"
   
5. 
   
6. case $text in
   
7.     *"$substring"*)
   
8.         echo "'$substring' found in the text"
   
9.         ;;
   
10.     *)
    
11.         echo "'$substring' not found in the text"
    
12.         ;;
    
13. esac

复制代码

然后，你可以利用 expect 自动化交互过程：

1. #!/bin/bash
   
2. 
   
3. text="Hello, Kali Linux!"
   
4. substring="Kali"
   
5. 
   
6. if [[ $text == *"$substring"* ]]; then
   
7.     echo "'$substring' found in the text"
   
8. else
   
9.     echo "'$substring' not found in the text"
   
10. fi

复制代码

这些方法可以资助你在Shell脚本中实现与用户的交互。选择哪种方法取决于你的具体需求和环境。
检测用户输入

在Shell脚本中检测用户输入可以通过条件语句和比较运算符来实现。以下是一些常见的方法：
1. 利用 if 语句和比较运算符

你可以利用 if 语句和比较运算符（如 -eq, -ne, -lt, -le, -gt, -ge）来检测用户输入的数值。

1. #!/bin/bash
   
2. 
   
3. text="Hello, Kali Linux!"
   
4. substring="Kali"
   
5. 
   
6. if echo "$text" | grep -q "$substring"; then
   
7.     echo "'$substring' found in the text"
   
8. else
   
9.     echo "'$substring' not found in the text"
   
10. fi

复制代码

2. 利用 case 语句

case 语句可以用于检测用户输入的字符串。

1. #!/bin/bash
   
2. 
   
3. string1="Hello"
   
4. string2="World"
   
5. result="$string1, $string2!"
   
6. 
   
7. echo "$result"

复制代码

3. 利用正则表达式

你可以利用正则表达式来检测用户输入的格式。

1. #!/bin/bash
   
2. 
   
3. date_str=$(date)
   
4. greeting="Today is $date_str"
   
5. 
   
6. echo "$greeting"

复制代码

4. 利用 grep 下令

你还可以利用 grep 下令来检测用户输入是否匹配某个模式。

1. #!/bin/bash
   
2. 
   
3. string1="Hello"
   
4. string2="World"
   
5. result=$(echo -n "$string1, " && echo "$string2!")
   
6. 
   
7. echo "$result"

复制代码

5. 利用 getopts 下令

getopts 是一个用于解析下令行选项的Shell内置下令。

1. #!/bin/bash
   
2. 
   
3. string1="Hello"
   
4. string2="World"
   
5. result=$(printf "%s, %s!" "$string1" "$string2")
   
6. 
   
7. echo "$result"

复制代码

这些方法可以资助你在Shell脚本中检测用户输入，并根据输入执行相应的操作。选择哪种方法取决于你的具体需求和环境。
编写交互式shell脚本

编写一个交互式Shell脚本通常涉及接收用户输入并根据输入执行相应的操作。以下是一个简单的示例，展示了如何编写一个交互式Shell脚本：
示例：简单的交互式Shell脚本

1. #!/bin/bash
   
2. 
   
3. string="Hello, World!"
   
4. length=${#string}
   
5. 
   
6. for ((i=0; i<$length; i++)); do
   
7.     char="${string:$i:1}"
   
8.     ascii=$(printf "%d" "'$char")
   
9.     echo "Character: $char, ASCII Value: $ascii"
   
10. done

复制代码

解释

• Shebang (#!/bin/bash):
  
  
  
  • 这行告诉体系利用/bin/bash解释器来执行这个脚本。
    
  
  
• 提示用户输入名字:
  
  
  
  • echo "请输入你的名字：" 输出提示信息。
    
  
  
• 读取用户输入:
  
  
  
  • read name 读取用户输入的名字并存储在变量name中。
    
  
  
• 输出问候语:
  
  
  
  • echo "你好，$name！" 利用变量name输出问候语。
    
  
  
• 提示用户输入年事:
  
  
  
  • echo "请输入你的年事：" 输出提示信息。
    
  
  
• 读取用户输入:
  
  
  
  • read age 读取用户输入的年事并存储在变量age中。
    
  
  
• 输出年事信息:
  
  
  
  • echo "你的年事是：$age岁" 利用变量age输出年事信息。
    
  
  
• 提示用户选择操作:
  
  
  
  • echo "请选择一个操作：" 和后续的echo下令输出操作选项。
    
  
  
• 读取用户选择:
  
  
  
  • read choice 读取用户选择的操作并存储在变量choice中。
    
  
  
• 根据用户选择执行相应的操作:
  
  
  
  • case $choice in ... esac 结构根据用户的选择执行相应的操作。
    
  
  

运行脚本

• 将上述脚本保存到一个文件中，比方interactive_script.sh。
  
• 赋予脚本执行权限：
  1. Character: H, ASCII Value: 72
     
  2. Character: e, ASCII Value: 101
     
  3. Character: l, ASCII Value: 108
     
  4. Character: l, ASCII Value: 108
     
  5. Character: o, ASCII Value: 111
     
  6. Character: ,, ASCII Value: 44
     
  7. Character:  , ASCII Value: 32
     
  8. Character: W, ASCII Value: 87
     
  9. Character: o, ASCII Value: 111
     
  10. Character: r, ASCII Value: 114
      
  11. Character: l, ASCII Value: 108
      
  12. Character: d, ASCII Value: 100
      
  13. Character: !, ASCII Value: 33

  复制代码
• 运行脚本：
  1. #!/bin/bash
     
  2. 
     
  3. string1="Hello"
     
  4. string2="World"
     
  5. 
     
  6. if [[ $string1 == $string2 ]]; then
     
  7.     echo "Strings are equal"
     
  8. else
     
  9.     echo "Strings are not equal"
     
  10. fi

  复制代码

这样，你就可以看到一个简单的交互式Shell脚本，它会提示用户输入名字和年事，并根据用户的选择体现当前日期或时间。echo "Number is greater than 5"elseecho "Number is less than or equal to 5"fi​if [ "str" != "world" ]; thenecho "String is not world"elseecho "String is world"fi

1. #!/bin/sh
   
2. 
   
3. string1="Hello"
   
4. string2="World"
   
5. 
   
6. if test "$string1" = "$string2"; then
   
7.     echo "Strings are equal"
   
8. else
   
9.     echo "Strings are not equal"
   
10. fi

复制代码

​
利用case语句进行多条件判断

​case语句也可以用于多条件判断：​

1. #!/bin/bash
   
2. 
   
3. string1="Hello"
   
4. string2="World"
   
5. 
   
6. tmpfile1=$(mktemp)
   
7. tmpfile2=$(mktemp)
   
8. 
   
9. echo "$string1" > "$tmpfile1"
   
10. echo "$string2" > "$tmpfile2"
    
11. 
    
12. if cmp -s "$tmpfile1" "$tmpfile2"; then
    
13.     echo "Strings are equal"
    
14. else
    
15.     echo "Strings are not equal"
    
16. fi
    
17. 
    
18. rm "$tmpfile1"
    
19. rm "$tmpfile2"

复制代码

​通过这些方法，你可以在Shell脚本中实现复杂的条件判断逻辑。​
for循环

在Shell脚本中，for循环用于遍历一组值（通常是一个序列或数组），并针对每个值执行一段代码。for循环的根本语法如下：

1. #!/bin/bash
   
2. 
   
3. plaintext="Hello, World!"
   
4. key="mysecretkey12345"  # 密钥长度必须是16, 24, 或32字节
   
5. iv=$(openssl rand -base64 16)  # 初始化向量，16字节
   
6. 
   
7. # 加密
   
8. ciphertext=$(openssl enc -aes-256-cbc -salt -in <(echo "$plaintext") -out <(echo "$iv") -pass pass:"$key")
   
9. 
   
10. echo "Ciphertext: $ciphertext"
    
11. echo "IV: $iv"

复制代码

其中：

• variable 是一个变量，用于存储当前遍历到的值。
  
• value_list 是一个值列表，可以包含数字、字符串、数组元素等。值列表中的每个值都会被依次赋给 variable，然后执行循环体中的代码。
  
• do 和 done 是循环体的起始和结束标志，它们之间的代码是每次循环都会执行的。
  

以下是一个简单的示例，演示了如何利用for循环打印数字1到5：

1. #!/bin/bash
   
2. 
   
3. plaintext="Hello, World!"
   
4. recipient="your-email@example.com"  # 替换为接收者的GPG公钥ID或电子邮件
   
5. 
   
6. # 加密
   
7. ciphertext=$(echo "$plaintext" | gpg --encrypt --recipient "$recipient" --armor)
   
8. 
   
9. echo "Ciphertext: $ciphertext"

复制代码

在这个示例中，变量 i 依次被赋值为1、2、3、4、5，然后执行 echo $i 下令打印当前值。
别的，还可以利用 seq 下令生成数字序列，并在for循环中利用：

1. #!/bin/bash
   
2. 
   
3. plaintext="Hello, World!"
   
4. 
   
5. # 编码
   
6. encoded=$(echo "$plaintext" | base64)
   
7. 
   
8. echo "Encoded: $encoded"

复制代码

这个示例与前面的示例结果相同，都是打印数字1到5。
总结

for循环在Shell脚本中重要用于遍历序列并对序列中的每个元素执行相同的操作。通过合理利用for循环，你可以编写出简便且易于维护的脚本。
for循环与遍历数组的区别

在Shell脚本中，for循环和遍历数组都可以用于处理一系列的元素，但它们的利用方式和适用场景有所不同。
for循环

for循环重要用于遍历一个明确的序列，这个序列可以是数字、字符串、文件名等。for循环的根本语法如下：

1. #!/bin/bash
   
2. 
   
3. plaintext="Hello, World!"
   
4. key="mysecretkey12345"  # 密钥长度必须是16, 24, 或32字节
   
5. iv=$(openssl rand -base64 16)  # 初始化向量，16字节
   
6. 
   
7. # 加密
   
8. ciphertext=$(openssl enc -aes-256-cbc -salt -in <(echo "$plaintext") -out <(echo "$iv") -pass pass:"$key")
   
9. 
   
10. echo "Ciphertext: $ciphertext"
    
11. echo "IV: $iv"

复制代码

其中，value_list 是一个由空格分隔的值列表，variable 会在每次循环中被赋予列表中的下一个值。
比方，以下脚本利用for循环遍历一个数字序列并打印出来：

1. #!/bin/bash
   
2. 
   
3. # 输出参数信息
   
4. echo "Script name: $0"
   
5. echo "First argument: $1"
   
6. echo "Second argument: $2"
   
7. echo "All arguments: $@"
   
8. echo "Number of arguments: $#"

复制代码

遍历数组

遍历数组是Shell脚本中的一种特别用法，用于处理数组中的每个元素。遍历数组的根本语法如下：

1. chmod +x myscript.sh

复制代码

其中，array 是一个数组变量，${array[@]} 表示数组中的所有元素。在每次循环中，element 会被赋予数组中的下一个元素值。
比方，以下脚本界说了一个数组并遍历打印出每个元素：

1. ./myscript.sh arg1 arg2 "arg 3"

复制代码

区别

• 数据范例：for循环重要用于遍历序列（如数字、字符串、文件名等），而遍历数组专门用于处理数组中的元素。
  
• 语法：for循环的语法相对简单，只需指定一个值列表即可；而遍历数组需要利用${array[@]}来表示数组中的所有元素。
  
• 灵活性：for循环更加灵活，可以处理各种范例的序列；而遍历数组只能用于处理数组。
  

总的来说，for循环和遍历数组都是Shell脚本中常用的循环结构，选择利用哪种方式取决于具体的需求和场景。
在Shell脚本中，for循环可以用于遍历数组并对数组中的每个元素执行相同的操作。以下是几种常见的数组遍历方法：
1. 利用for循环遍历数组元素

1. Script name: ./myscript.sh
   
2. First argument: arg1
   
3. Second argument: arg2
   
4. All arguments: arg1 arg2 arg 3
   
5. Number of arguments: 3

复制代码

在这个例子中，${array[@]}表示数组中的所有元素。for循环将依次处理数组中的每个元素。
2. 利用for循环和数组索引遍历数组元素

1. #!/bin/bash
   
2. 
   
3. # 输出参数信息
   
4. echo "Script name: $0"
   
5. echo "First argument: $1"
   
6. echo "Second argument: $2"
   
7. echo "Third argument: $3"
   
8. echo "All arguments: $@"
   
9. echo "Number of arguments: $#"

复制代码

利用>>将下令的标准输出追加到文件。如果文件不存在，它将被创建。比方：

1. chmod +x myscript.sh

复制代码

将标准错误重定向到文件：
利用2>将下令的标准错误重定向到文件。比方：

1. ./myscript.sh arg1 arg2 arg3

复制代码

利用2>>将下令的标准错误追加到文件。比方：

1. Script name: ./myscript.sh
   
2. First argument: arg1
   
3. Second argument: arg2
   
4. Third argument: arg3
   
5. All arguments: arg1 arg2 arg3
   
6. Number of arguments: 3

复制代码

将标准输出和标准错误重定向到同一个文件：
利用&>将下令的标准输出和标准错误重定向到同一个文件。比方：

1. ./myscript.sh arg1 "arg 2 with spaces" arg3

复制代码

或者，你可以分别重定向标准输出和标准错误，然后利用>>将它们追加到同一个文件：

1. Script name: ./myscript.sh
   
2. First argument: arg1
   
3. Second argument: arg 2 with spaces
   
4. Third argument: arg3
   
5. All arguments: arg1 arg 2 with spaces arg3
   
6. Number of arguments: 3

复制代码

将标准输出和/或标准错误重定向到其他下令：
利用管道（|）将一个下令的标准输出重定向到另一个下令的标准输入。比方：

1. #!/bin/bash
   
2. 
   
3. # 创建一个数组来存储参数
   
4. params=("$@")
   
5. 
   
6. # 获取参数个数
   
7. num_params=${#params[@]}
   
8. 
   
9. # 输出参数信息
   
10. echo "Script name: $0"
    
11. echo "Number of arguments: $num_params"
    
12. echo "All arguments:"
    
13. 
    
14. # 遍历数组并输出每个参数
    
15. for (( i=0; i<$num_params; i++ )); do
    
16.   echo "Argument $(($i+1)): ${params[$i]}"
    
17. done

复制代码

利用2>&1将标准错误重定向到标准输出，然后将其传递给另一个下令。比方：

1. chmod +x myscript.sh

复制代码

这些是Shell脚本中常用的重定向方法。通过利用这些方法，你可以灵活地控制下令的输出和错误处理。
重定向指定字段

在Shell脚本中，你可以利用awk、sed或其他文本处理工具来指定输出字段

• 利用awk指定输出字段：
  awk是一个功能强大的文本处理工具，可以用于在文本文件或下令输出中提取和操作字段。以下是一些利用awk指定输出字段的示例：
  
  
  
  • 提取第1个字段（默认以空格分隔）：
    1. ./myscript.sh arg1 arg2 "arg 3 with spaces"

    复制代码
  • 提取第2个字段，并利用逗号作为字段分隔符：
    1. Script name: ./myscript.sh
       
    2. Number of arguments: 3
       
    3. All arguments:
       
    4. Argument 1: arg1
       
    5. Argument 2: arg2
       
    6. Argument 3: arg 3 with spaces

    复制代码
  • 提取所有字段，并在每个字段之间添加制表符：
    1. #!/bin/bash
       
    2. 
       
    3. # 检查参数个数
       
    4. if [ "$#" -lt 1 ]; then
       
    5.     echo "Usage: $0 [option1] [option2] [option3]"
       
    6.     exit 1
       
    7. fi
       
    8. 
       
    9. # 根据参数执行不同操作
       
    10. while getopts ":a:b:c" opt; do
        
    11.   case $opt in
        
    12.     a)
        
    13.       echo "Option A selected"
        
    14.       # 在此处执行选项A的操作
        
    15.       ;;
        
    16.     b)
        
    17.       echo "Option B selected"
        
    18.       # 在此处执行选项B的操作
        
    19.       ;;
        
    20.     c)
        
    21.       echo "Option C selected"
        
    22.       # 在此处执行选项C的操作
        
    23.       ;;
        
    24.     \?)
        
    25.       echo "Invalid option: -$OPTARG" >&2
        
    26.       exit 1
        
    27.       ;;
        
    28.     :)
        
    29.       echo "Option -$OPTARG requires an argument." >&2
        
    30.       exit 1
        
    31.       ;;
        
    32.   esac
        
    33. done
        
    34. 
        
    35. # 如果没有提供任何参数，显示帮助信息
        
    36. if [ "$OPTIND" -eq 1 ]; then
        
    37.     echo "No options provided. Use -a, -b, or -c."
        
    38. fi

    复制代码
  
  
• 利用cut指定输出字段：
  cut下令用于从文件或下令输出中提取文本列。以下是一些利用cut指定输出字段的示例：
  
  
  
  • 提取第1个字段（默认以制表符分隔）：
    1. chmod +x myscript.sh

    复制代码
  • 提取第2个字段，并利用逗号作为字段分隔符：
    1. ./myscript.sh -a
       
    2. ./myscript.sh -b -c
       
    3. ./myscript.sh -a -b -c

    复制代码
  • 提取前3个字符：
    1. Option A selected
       
    2. Option B selected
       
    3. Option C selected
       
    4. Option A selected
       
    5. Option B selected
       
    6. Option C selected

    复制代码
  
  

这些示例仅涉及awk和cut下令的根本用法。你可以根据需要调解这些下令以满足你的需求。通过利用这些工具，你可以灵活地指定输出字段并将其重定向到文件或其他下令。
应用方向

在Shell脚本中，重定向是一种将下令的输出（标准输出和/或标准错误）发送到文件、设备或其他下令的操作

• 日志记录：将脚本的输出和错误信息重定向到日志文件，以便于跟踪和调试。比方：
  1. #!/bin/bash
     
  2. 
     
  3. # 获取参数个数
     
  4. num_params=$#
     
  5. 
     
  6. # 输出参数信息
     
  7. echo "Script name: $0"
     
  8. echo "Number of arguments: $num_params"
     
  9. 
     
  10. # 使用for循环遍历并处理每个参数
      
  11. for (( i=1; i<=$num_params; i++ )); do
      
  12.   echo "Processing argument $i: ${!i}"
      
  13. done

  复制代码
  或者，将标准输出和标准错误重定向到同一个日志文件：
  1. chmod +x myscript.sh

  复制代码
• 数据存储：将下令的输出保存到文件中，以便于后续处理或分析。比方，将ls下令的输出保存到一个文本文件中：
  1. ./myscript.sh arg1 arg2 "arg 3 with spaces"

  复制代码
• 数据处理：将一个下令的输出作为另一个下令的输入，进行数据处理。比方，利用grep过滤ls下令的输出：
  1. #!/bin/bash
     
  2. 
     
  3. # 创建一个数组来存储参数
     
  4. params=("$@")
     
  5. 
     
  6. # 获取参数个数
     
  7. num_params=${#params[@]}
     
  8. 
     
  9. # 输出参数信息
     
  10. echo "Script name: $0"
      
  11. echo "Number of arguments: $num_params"
      
  12. echo "All arguments:"
      
  13. 
      
  14. # 遍历数组并输出每个参数
      
  15. for (( i=0; i<$num_params; i++ )); do
      
  16.   echo "Argument $(($i+1)): ${params[$i]}"
      
  17. done

  复制代码
• 输出克制：将下令的输出重定向到/dev/null，以克制不需要的输出。比方，运行一个产生大量输出的下令，但不希望看到输出：
  1. #!/bin/bash
     
  2. 
     
  3. # 定义一个函数来处理参数组合
     
  4. process_args() {
     
  5.     local option_a=false
     
  6.     local option_b=false
     
  7.     local option_c=false
     
  8. 
     
  9.     while getopts ":a:b:c" opt; do
     
  10.         case $opt in
      
  11.             a)
      
  12.                 option_a=true
      
  13.                 ;;
      
  14.             b)
      
  15.                 option_b=true
      
  16.                 ;;
      
  17.             c)
      
  18.                 option_c=true
      
  19.                 ;;
      
  20.             \?)
      
  21.                 echo "Invalid option: -$OPTARG" >&2
      
  22.                 exit 1
      
  23.                 ;;
      
  24.             :)
      
  25.                 echo "Option -$OPTARG requires an argument." >&2
      
  26.                 exit 1
      
  27.                 ;;
      
  28.         esac
      
  29.     done
      
  30. 
      
  31.     # 根据参数组合执行不同操作
      
  32.     if $option_a; then
      
  33.         echo "Option A selected"
      
  34.         # 在此处执行选项A的操作
      
  35.     fi
      
  36. 
      
  37.     if $option_b; then
      
  38.         echo "Option B selected"
      
  39.         # 在此处执行选项B的操作
      
  40.     fi
      
  41. 
      
  42.     if $option_c; then
      
  43.         echo "Option C selected"
      
  44.         # 在此处执行选项C的操作
      
  45.     fi
      
  46. 
      
  47.     # 嵌套参数组合
      
  48.     if $option_a && $option_b; then
      
  49.         echo "Option A and B selected"
      
  50.         # 在此处执行选项A和B的组合操作
      
  51.     fi
      
  52. 
      
  53.     if $option_a && $option_c; then
      
  54.         echo "Option A and C selected"
      
  55.         # 在此处执行选项A和C的组合操作
      
  56.     fi
      
  57. 
      
  58.     if $option_b && $option_c; then
      
  59.         echo "Option B and C selected"
      
  60.         # 在此处执行选项B和C的组合操作
      
  61.     fi
      
  62. 
      
  63.     if $option_a && $option_b && $option_c; then
      
  64.         echo "Option A, B, and C selected"
      
  65.         # 在此处执行选项A、B和C的组合操作
      
  66.     fi
      
  67. }
      
  68. 
      
  69. # 调用函数处理参数
      
  70. process_args "$@"

  复制代码
• 输入重定向：将文件的内容作为下令的输入。比方，利用cat下令体现文件内容：
  1. chmod +x myscript.sh

  复制代码
• 并行执行：将多个下令的输出重定向到不同的文件，以便于并行执行和监控。比方：
  1. ./myscript.sh -a
     
  2. ./myscript.sh -b -c
     
  3. ./myscript.sh -a -b -c
     
  4. ./myscript.sh -a -b
     
  5. ./myscript.sh -a -c
     
  6. ./myscript.sh -b -c

  复制代码

这些只是Shell脚本中重定向的一些应用场景。现实上，重定向是一种非常强大的技术，可以资助你更有用地控制和管理下令的输出和错误处理。
案例讲解

重定向输出时实现文件名动态生成

在Shell脚本中，你可以利用变量和下令更换来动态生成文件名，然后将输出重定向到这些文件

• 利用变量：
  在脚本中界说一个变量，该变量包含文件名的一部门或全部。然后，在重定向输出时利用该变量。
  1. Option A selected
     
  2. Option B selected
     
  3. Option C selected
     
  4. Option A and B selected
     
  5. Option C selected
     
  6. Option A and C selected
     
  7. Option B and C selected
     
  8. Option A, B, and C selected
     
  9. Option A and B selected
     
  10. Option A and C selected

  复制代码
  在这个示例中，我们利用date下令生成一个包含当前日期的字符串，并将其存储在变量date_str中。然后，我们将输出重定向到一个包含该日期的文件名。
  
• 利用下令更换：
  你可以利用下令更换（$(command)或`command`）在重定向输出时动态生成文件名。
  1. #!/bin/bash
     
  2. 
     
  3. # 声明一个关联数组
     
  4. declare -A param_map
     
  5. 
     
  6. # 定义映射关系
     
  7. param_map=(
     
  8.   ["arg1"]="value1"
     
  9.   ["arg2"]="value2"
     
  10.   ["arg3"]="value3"
      
  11. )
      
  12. 
      
  13. # 获取参数个数
      
  14. num_params=$#
      
  15. 
      
  16. # 使用for循环遍历并处理每个参数
      
  17. for (( i=1; i<=$num_params; i++ )); do
      
  18.   arg_name=${!i}
      
  19.   echo "Processing argument $arg_name: ${param_map[$arg_name]}"
      
  20. done

  复制代码
  在这个示例中，我们利用$(date +%Y-%m-%d)下令更换在重定向输出时动态生成文件名。
  

这些方法可以资助你在Shell脚本中实现文件名的动态生成，并将输出重定向到这些文件。通过利用变量和下令更换，你可以根据需要灵活地生成文件名。
重定向输出时实现文件长期化

在Shell脚本中，将输出重定向到文件可以实现文件的长期化

• 将标准输出重定向到文件：
  利用>将下令的标准输出重定向到文件。如果文件已存在，它将被覆盖。比方：
  1. chmod +x myscript.sh

  复制代码
  利用>>将下令的标准输出追加到文件。如果文件不存在，它将被创建。比方：
  1. chmod +x myscript.sh

  复制代码
• 将标准错误重定向到文件：
  利用2>将下令的标准错误重定向到文件。比方：
  1. ./myscript.sh arg1 arg2 arg3

  复制代码
  利用2>>将下令的标准错误追加到文件。比方：
  1. Script name: ./myscript.sh
     
  2. First argument: arg1
     
  3. Second argument: arg2
     
  4. Third argument: arg3
     
  5. All arguments: arg1 arg2 arg3
     
  6. Number of arguments: 3

  复制代码
• 将标准输出和标准错误重定向到同一个文件：
  利用&>将下令的标准输出和标准错误重定向到同一个文件。比方：
  1. ./myscript.sh arg1 "arg 2 with spaces" arg3

  复制代码
  或者，你可以分别重定向标准输出和标准错误，然后利用>>将它们追加到同一个文件：
  1. Script name: ./myscript.sh
     
  2. First argument: arg1
     
  3. Second argument: arg 2 with spaces
     
  4. Third argument: arg3
     
  5. All arguments: arg1 arg 2 with spaces arg3
     
  6. Number of arguments: 3

  复制代码

通过利用这些重定向方法，你可以确保下令的输出被长期化到文件中，即使在脚本执行完成后，这些输出仍然可以访问。这对于记录日志、保存设置信息、收集统计信息等场景非常有用。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。