当前位置: 首页 > news >正文

网站教程制作/百度经验官网入口

网站教程制作,百度经验官网入口,redis wordpress 设置密码,上海 网站公司Linux的循环,bash的循环 在 Linux 系统中,Bash 循环是最常用的循环实现方式(Bash 是 Linux 默认的 Shell),但广义上“Linux 的循环”可能涉及其他 Shell 或编程语言的循环结构。以下是 Bash 循环的详细解析及其在 Linux 环境中的…

Linux的循环,bash的循环

在 Linux 系统中,Bash 循环是最常用的循环实现方式(Bash 是 Linux 默认的 Shell),但广义上“Linux 的循环”可能涉及其他 Shell 或编程语言的循环结构。以下是 Bash 循环的详细解析及其在 Linux 环境中的应用场景,同时对比其他常见循环方式。


一、Bash 循环:核心语法与场景

Bash 是 Linux 的默认 Shell,其循环语法直接用于 Shell 脚本,适合文件操作、批量任务等场景。

1. for 循环
  • 遍历列表/数组

    # 遍历显式列表
    for item in "file1" "file2" "dir/"; doecho "Processing: $item"
    done# 遍历数组
    files=("data.txt" "log.csv")
    for file in "${files[@]}"; docp "$file" "backup_$file"
    done
    
  • 遍历文件(避免解析 ls 的输出):

    for file in *.txt; doecho "Found text file: $file"
    done
    
  • C 语言风格循环

    for ((i=0; i<5; i++)); doecho "Index: $i"
    done
    
2. while 循环
  • 条件驱动

    count=0
    while [ $count -lt 3 ]; doecho "Count: $count"((count++))
    done
    
  • 逐行读取文件

    while IFS= read -r line; doecho "Line: $line"
    done < "input.txt"
    
3. until 循环
  • 条件为假时执行
    status="down"
    until [ "$status" == "up" ]; doecho "Waiting for service..."sleep 1status=$(check_service_status)  # 假设 check_service_status 是检测服务状态的函数
    done
    

二、Bash 循环的高级技巧

1. 处理复杂文件名(含空格、特殊字符)
  • 使用双引号包裹变量
    for file in *; doecho "Processing: '$file'"  # 单引号显示文件名边界mv -- "$file" "new_$file"   # -- 避免文件名以 - 开头被误认为选项
    done
    
2. 并行执行循环任务
  • 利用后台运行
    for i in {1..10}; doprocess_data "$i" &  # & 将任务放入后台
    done
    wait  # 等待所有后台任务完成
    echo "All tasks done!"
    
3. 结合 find 命令处理递归文件
  • 替代 for 遍历子目录
    find /path -type f -name "*.log" -exec sh -c 'for file; doecho "Compressing $file"gzip "$file"done
    ' sh {} +  # 一次性传递多个文件,减少进程启动次数
    

三、Bash 循环 vs 其他 Linux 工具循环

**1. find + xargs
  • 更适合大批量文件处理(避免循环性能瓶颈):
    find . -name "*.tmp" -print0 | xargs -0 rm -f  # 安全删除所有 .tmp 文件
    
**2. awk/sed 内置循环
  • 处理文本流的行级操作
    awk '{ for(i=1; i<=NF; i++) print "Field " i ": " $i }' data.txt  # 遍历每行所有字段
    
**3. Python/Perl 循环(系统预装)
  • 复杂逻辑或数据处理
    # Python 示例(可在 Bash 脚本中嵌入)
    python3 -c '
    for i in range(1, 6):print(f"Number: {i}")
    '
    

四、常见错误与解决方案

1. 循环中的变量作用域
  • 问题:循环内修改的变量会影响全局作用域。
  • 解决:在函数或子 Shell 中运行循环:
    (  # 子 Shell
    for i in {1..3}; docount=$i
    done
    )
    echo "Global count: $count"  # 输出空值,子 Shell 的变量不污染父进程
    
2. 处理空列表
  • 问题:当通配符未匹配到文件时,循环可能执行异常。
  • 解决:检查文件是否存在:
    for file in *.nonexistent; do[ -e "$file" ] || break  # 无文件时退出循环echo "Processing $file"
    done
    
3. 性能优化
  • 避免频繁启动外部命令
    # 低效写法(每次循环调用一次 echo)
    for i in {1..1000}; doecho "$i"
    done# 高效写法(一次性输出)
    echo {1..1000} | tr ' ' '\n'
    

五、总结:如何选择循环方式

场景推荐工具示例
简单文件遍历、快速脚本Bash for 循环for file in *; do ...
逐行处理文本文件while read 循环while IFS= read -r line; do...
复杂条件或计数器C 语言风格 forfor ((i=0; i<10; i++)); do...
大批量文件操作find + xargs`find …
文本数据处理(行列操作)awk/sedawk '{for(...)}'
复杂业务逻辑Python/Perl嵌入脚本或多行字符串执行

最佳实践

  1. 优先使用通配符而非解析 ls 输出。
  2. 始终双引号包裹变量,如 "$var"
  3. 性能敏感时选择 find + xargsawk
  4. 复杂任务考虑 Python/Perl。








在Linux环境中,Bash脚本语言提供了多种循环结构,使得用户能够根据需要重复执行一系列命令。Bash中的循环主要分为for循环、while循环和until循环三种。接下来,我们将逐一介绍这些循环结构及其在Bash脚本中的应用。

  1. for循环
    Bash中的for循环设计用于遍历列表或一系列的值。根据使用场景的不同,for循环可以有不同的写法:

遍历列表:适用于已知的值集合。
bash
for item in value1 value2 value3; do
# 在此处添加要执行的命令
done
遍历数组:在Bash 4.0及以上版本中,你可以使用关联数组。
bash
array=(“value1” “value2” “value3”)
for item in “${array[@]}”; do
# 在此处添加要执行的命令
done
C风格的for循环:适用于需要数值迭代的场景。
bash
for ((i=1; i<=10; i++)); do
# 在此处添加要执行的命令
done
遍历文件或目录:使用通配符匹配文件或目录。
bash
for file in /path/to/directory/*; do
# 在此处添加要执行的命令
done
2. while循环
while循环在条件为真时重复执行一系列命令。这种循环特别适用于执行次数未知,但依赖于特定条件的情况。

bash
while [ condition ]; do
# 在此处添加要执行的命令
done
在循环体内,你可以根据需要修改条件变量,以便在适当的时候退出循环。

  1. until循环
    until循环与while循环类似,但它在条件为假时执行命令。换句话说,until循环会一直执行,直到条件变为真。

bash
until [ condition ]; do
# 在此处添加要执行的命令
done
注意事项
在编写循环时,务必确保循环能够正常退出,否则可能会导致脚本陷入死循环。
使用break语句可以立即退出循环,而continue语句则会跳过当前迭代并进入下一次循环。
在处理文件或目录时,使用引号将变量或通配符括起来,以避免空格或特殊字符导致的问题。
嵌套循环时,确保内层循环的变量不会与外层循环的变量冲突。
通过合理利用这些循环结构,你可以编写出功能强大、灵活多变的Bash脚本,以满足各种自动化和管理任务的需求。








在Linux系统中,循环是一种重要的控制流语句,用于重复执行一组命令多次。在Bash(Bourne Again SHell)中,循环可以帮助自动化任务,提高脚本的效率和可读性。

  1. Linux循环的基本概念
    在Linux中,循环是一种重复执行特定代码块的结构。它通常包括进入循环的条件和退出循环的条件。循环可以基于已知条件进行(如while或until循环),也可以基于已知次数进行(如for循环)。

  2. Bash中for循环的语法
    Bash中的for循环有两种形式:

  • 基于列表的for循环

    for 变量名 in 列表
    do
    命令
    done
    
  • C风格的for循环

    for(( 表达式1; 表达式2; 表达式3 ))
    do
    命令
    done
    
  1. Bash for循环的示例代码
    假设我们有一个包含多个文件名的数组,我们想要打印出每个文件名:
files=("file1.txt" "file2.txt" "file3.txt")
for file in "${files[@]}"
doecho "$file"
done
  1. Bash for循环的执行流程
    在每次循环迭代中,Bash会执行循环体内的命令,直到列表中的所有元素都被处理完毕。在上述示例中,Bash会依次打印出"file1.txt"、“file2.txt"和"file3.txt”。

  2. Bash中其他类型的循环

  • while循环:当给定条件为真时,重复执行循环体中的命令。

    i=1
    while [ $i -le 5 ]
    doecho "$i"let i++
    done
    
  • until循环:当给定条件为假时,重复执行循环体中的命令。

    i=1
    until [ $i -gt 5 ]
    doecho "$i"let i++
    done
    

这些循环结构在Bash脚本中非常有用,可以用于处理文件、目录、数据等,并根据需求进行自动化操作。








在Linux的Bash脚本中,循环是用于重复执行一系列命令直到满足特定条件的一种控制流语句。以下是几种常见的Bash循环结构:

  1. for 循环

    for循环通常用来遍历一个列表(可以是数字、字符串等)。其基本语法如下:

    for var in item1 item2 ... itemN
    do# 执行命令
    done
    

    例如,打印0到4的数字:

    for i in 0 1 2 3 4
    doecho $i
    done
    

    或者使用简写形式:

    for i in {0..4}
    doecho $i
    done
    
  2. while 循环

    while循环会一直执行代码块直到给定的条件不再满足。其基本语法如下:

    while [ condition ]
    do# 执行命令
    done
    

    例如,当计数器小于5时继续循环:

    counter=0
    while [ $counter -lt 5 ]
    doecho $counter((counter++))
    done
    
  3. until 循环

    until循环与while循环类似,但它会在条件为假(false)时执行循环体,直到条件变为真(true)。其基本语法如下:

    until [ condition ]
    do# 执行命令
    done
    

    例如,直到计数器达到5为止:

    counter=0
    until [ $counter -ge 5 ]
    doecho $counter((counter++))
    done
    
  4. select 循环

    select循环用于创建简单的菜单系统,它将生成一个数字列表供用户选择。其基本语法如下:

    select var in item1 item2 ... itemN
    do# 执行命令break # 注意:你可能需要break语句来退出循环
    done
    

    例如,创建一个简单的菜单让用户选择水果:

    echo "Choose a fruit:"
    select fruit in apple banana cherry
    doecho "You selected $fruit"break
    done
    

这些就是Bash脚本中最常用的循环类型。通过灵活运用这些循环,你可以编写出非常强大的脚本来自动化各种任务。








在Linux和Bash中,常见的循环有for循环、while循环和until循环,以下是它们的详细介绍:

Linux中的循环

Linux中的循环通常通过shell脚本语言来实现,常见的shell有Bash、Zsh等。以Bash为例,循环的具体实现如下:

for循环
  • 语法格式
for variable in list
docommands
done
  • 执行过程for循环会将list中的每个元素依次赋值给variable,然后执行dodone之间的commands
  • 示例
for i in 1 2 3 4 5
doecho $i
done
  • 作用:常用于遍历列表、数组或执行固定次数的操作。
while循环
  • 语法格式
while condition
docommands
done
  • 执行过程:只要condition为真,就会一直执行dodone之间的commands
  • 示例
i=1
while [ $i -le 5 ]
doecho $ii=$((i+1))
done
  • 作用:适用于在条件满足的情况下持续执行任务,常用于不确定循环次数的场景。
until循环
  • 语法格式
until condition
docommands
done
  • 执行过程:与while循环相反,until循环会一直执行dodone之间的commands,直到condition为真。
  • 示例
i=1
until [ $i -gt 5 ]
doecho $ii=$((i+1))
done
  • 作用:在需要先执行循环体,再根据条件判断是否继续循环的场景中使用。

Bash中的循环

Bash是Linux系统中最常用的shell,它支持上述所有的循环结构,此外还有一些特殊用法。

for循环的特殊用法
  • 使用通配符:可以使用通配符来遍历文件或目录。例如,for file in *.txt会遍历当前目录下所有以.txt结尾的文件。
  • C语言风格的for循环
for ((i=1; i<=5; i++))
doecho $i
done

这种形式类似于C语言中的for循环,更加紧凑。

while循环的特殊用法
  • 读取文件内容
while read line
doecho $line
done < file.txt

这个循环会逐行读取file.txt文件的内容,并将每一行赋值给line变量,然后打印出来。

Bash中的循环是非常强大和灵活的工具,可以帮助用户自动化各种任务,提高工作效率。在实际使用中,需要根据具体的需求选择合适的循环结构。
















Bash的 for 循环

在 Linux 的 Bash 脚本中,for 循环是一种强大的工具,用于遍历列表、文件、数字范围等,并执行重复操作。以下是 for 循环的详细讲解,涵盖语法、常见用法、高级技巧和注意事项。


一、基础语法

1. 标准 for 循环
for 变量名 in 列表; do# 循环体(操作变量)
done
  • 变量名:自定义的变量,存储列表中的当前元素。
  • 列表:可以是显式列表、数组、通配符表达式、命令输出等。
  • 循环体:对变量执行的操作。
2. C 语言风格 for 循环
for ((初始化; 条件; 步进)); do# 循环体
done
  • 适合需要计数器或复杂循环逻辑的场景。

二、常见用法详解

1. 遍历显式列表

直接列出要遍历的元素:

for fruit in "apple" "banana" "orange"; doecho "Fruit: $fruit"
done

输出

Fruit: apple
Fruit: banana
Fruit: orange
2. 遍历数字范围
  • 大括号展开(推荐):

    for i in {1..5}; doecho "Number: $i"
    done
    

    输出 1 2 3 4 5

  • 指定步长

    for i in {1..10..2}; do  # 步长为 2echo "$i"
    done
    

    输出 1 3 5 7 9

  • 使用 seq 命令(兼容旧版本 Bash):

    for i in $(seq 1 5); doecho "$i"
    done
    
3. 遍历文件或目录
  • 通配符匹配文件

    for file in *.txt; doecho "Processing file: $file"
    done
    
    • 遍历当前目录下所有 .txt 文件。
    • 注意:如果无匹配文件,$file 会保留通配符(如 *.txt),需检查文件是否存在。
  • 递归遍历子目录

    for file in /path/to/dir/*; doif [ -f "$file" ]; thenecho "File: $file"elif [ -d "$file" ]; thenecho "Directory: $file"fi
    done
    
4. 遍历数组
fruits=("Apple" "Banana" "Orange")
for fruit in "${fruits[@]}"; doecho "Fruit: $fruit"
done
  • "${fruits[@]}" 确保正确处理数组中的空格和特殊字符。
5. 遍历命令输出

将命令的输出作为列表:

for user in $(cut -d: -f1 /etc/passwd); doecho "User: $user"
done
  • 注意:如果命令输出包含空格或特殊字符,需用双引号包裹变量(如 "$user")。

三、C 语言风格 for 循环

适用于需要计数器或复杂条件的场景:

for ((i=0; i<5; i++)); doecho "Counter: $i"
done

输出

Counter: 0
Counter: 1
...
Counter: 4
高级示例
  • 嵌套循环:
    for ((i=1; i<=3; i++)); dofor ((j=1; j<=2; j++)); doecho "$i-$j"done
    done
    
    输出 1-1, 1-2, 2-1, 2-2, 3-1, 3-2

四、循环控制

1. break:提前退出循环
for i in {1..10}; doif [ $i -eq 5 ]; thenbreakfiecho "$i"
done

输出 1 2 3 4

2. continue:跳过当前迭代
for i in {1..5}; doif [ $i -eq 3 ]; thencontinuefiecho "$i"
done

输出 1 2 4 5


五、高级技巧

1. 处理带空格的文件名

使用双引号包裹变量,避免路径中的空格导致错误:

for file in *.log; doecho "Processing: '$file'"  # 单引号显示文件名边界
done
2. 并行执行任务

结合 &wait 实现简单并行:

for i in {1..5}; dosleep 1 &  # 后台运行
done
wait  # 等待所有后台任务完成
echo "All tasks done!"
3. 修改数组元素

在循环中直接修改数组:

fruits=("apple" "banana" "orange")
for ((i=0; i<${#fruits[@]}; i++)); dofruits[$i]="${fruits[$i]^}"  # 首字母大写
done
echo "${fruits[@]}"  # 输出 Apple Banana Orange

六、常见错误与注意事项

1. 未引用的变量
  • 错误示例
    for file in $(ls *.txt); dorm $file  # 若文件名含空格,会导致误删
    done
    
  • 正确做法
    for file in *.txt; dorm -- "$file"  # 使用通配符 + 双引号
    done
    
2. 遍历空列表

如果列表为空(如无匹配文件),循环可能不会执行:

for file in *.nonexistent; doecho "Found: $file"  # 不会执行
done
3. 性能问题
  • 遍历大量文件时,避免在循环中频繁调用外部命令(如 ls)。
  • 替代方案:使用 find + -execxargs

七、总结

  • 适用场景:遍历文件、数组、数字范围、命令输出等。
  • 最佳实践
    1. 始终用双引号包裹变量(如 "$var")。
    2. 优先使用通配符(*.txt)而非 ls 遍历文件。
    3. 处理复杂逻辑时,优先选择 C 语言风格循环。
    4. 测试脚本时,先使用 echodry-run 模式验证逻辑。

通过掌握这些技巧,你可以高效编写健壮的 Bash 脚本!








在Bash脚本中,for 循环是一种常用的控制流结构,用于遍历一系列的值(如数字、字符串等),并对每个值执行一组命令。以下是 for 循环的基本用法和一些示例。

基本语法

1. 列表形式的 for 循环

这是最常见的形式,其中 var 是循环变量,item1 item2 ... itemN 是要迭代的列表。

for var in item1 item2 ... itemN
do# 执行的命令
done

示例:

打印从0到4的数字:

for i in 0 1 2 3 4
doecho $i
done

或者使用简写形式来生成序列:

for i in {0..4}
doecho $i
done
2. 使用C语言风格的 for 循环

Bash还支持类似C语言的 for 循环语法。

for (( init; condition; increment ))
do# 执行的命令
done

示例:

同样地,打印从0到4的数字:

for (( i=0; i<=4; i++ ))
doecho $i
done

应用实例

  • 遍历目录下的文件:

    for file in /path/to/directory/*
    doif [ -f "$file" ]; thenecho "$file is a file."fi
    done
    
  • 遍历数组元素:

    如果你有一个数组,可以使用 for 循环遍历数组中的每一个元素。

    array=(apple banana cherry)
    for element in "${array[@]}"
    doecho $element
    done
    

通过这些例子可以看出,for 循环是Bash脚本编写中非常强大且灵活的一个工具,适用于多种不同的场景,无论是简单的任务还是更复杂的操作。








Bash中的for循环是一个强大的结构,用于重复执行一组命令。在Bash中,for循环有两种主要语法形式:

  1. 列表遍历形式
for 变量名 in 列表; do命令
done

在这种形式中,变量名用于存储列表中的每个值,并在每次循环时获取列表中的下一个值。列表可以是任何列表,例如一个包含多个字符串的数组,或是一个由空格分隔的字符串列表。

例如,遍历一个包含多个文件名的数组:

files=("file1.txt" "file2.txt" "file3.txt")
for file in "${files[@]}"; doecho "$file"
done
  1. C风格的形式
for (( 初始化; 条件; 更新 )); do命令
done

这种形式适用于需要更精细控制的情况,允许你指定一个初始化表达式,一个条件表达式和一个更新表达式。

例如,生成10个随机数:

for (( i=1; i<=10; i++ )); doecho $RANDOM
done

在Bash中,for循环常用于遍历文件和目录。例如,你可以使用for循环来遍历一个目录中的所有文件:

for file in /path/to/directory/*; doif [ -f "$file" ]; thenecho "文件:$file"elif [ -d "$file" ]; thenecho "目录:$file"fi
done

此外,Bash的for循环还支持一些高级用法,如使用seq命令生成序列,或使用find命令查找文件等。

Bash中的for循环在脚本编写中非常重要,它可以用于自动化重复的任务,如批量处理文件、批量创建用户等。通过合理地使用for循环,可以大大提高脚本的效率和可读性。








当然,Bash 中的 for 循环是一种非常强大的控制结构,它允许你遍历一系列的值并执行一系列的命令。Bash for 循环有几种不同的用法,包括遍历列表、遍历命令的输出、遍历文件以及使用 C 风格的循环语法。以下是对 Bash for 循环的详细讲解:

1. 遍历列表

这是 Bash for 循环最常见的用法之一。你可以遍历一个由空格分隔的字符串列表(或数组),并对列表中的每个元素执行一系列命令。

for item in list1 list2 list3; doecho "Item: $item"
done

在这个例子中,for 循环会依次将 list1list2list3 赋值给变量 item,并在每次迭代中执行 echo 命令。

如果你有一个数组,你也可以这样遍历它:

my_array=("apple" "banana" "cherry")
for item in "${my_array[@]}"; doecho "Fruit: $item"
done

2. 遍历命令的输出

你可以使用命令替换($(...) 或反引号 `...`)来将命令的输出作为 for 循环的输入。

for file in $(ls); doecho "File: $file"
done

注意:这种方法在处理包含空格或特殊字符的文件名时可能会遇到问题。更健壮的方法是使用 find 命令与 -print0 选项和 while 循环的 read -d '' 命令结合,或者使用 Bash 4+ 的 mapfilereadarray 命令与 -d '' 选项来读取命令输出,并正确地处理文件名。

3. 遍历文件

Bash 提供了一个简单的模式匹配机制,可以用来遍历目录中的文件。

for file in *.txt; doecho "Processing $file"
done

这个循环会遍历当前目录中所有以 .txt 结尾的文件。

4. C 风格的循环

Bash 也支持类似于 C 语言的 for 循环语法,这允许你使用一个初始化表达式、一个条件表达式和一个更新表达式来控制循环。

for ((i=1; i<=10; i++)); doecho "Number: $i"
done

在这个例子中,循环变量 i 从 1 开始,每次迭代增加 1,直到它的值大于 10 为止。

5. 遍历关联数组(Bash 4+)

在 Bash 4 及更高版本中,你可以使用关联数组(也称为哈希表或字典),其中键和值都是字符串。你可以遍历关联数组的键或值。

declare -A my_assoc_array
my_assoc_array[key1]="value1"
my_assoc_array[key2]="value2"# 遍历键
for key in "${!my_assoc_array[@]}"; doecho "Key: $key, Value: ${my_assoc_array[$key]}"
done# 或者只遍历值(但这需要知道键)
for key in "${!my_assoc_array[@]}"; doecho "Value: ${my_assoc_array[$key]}"
done

6. 嵌套循环

你可以在一个 for 循环内部嵌套另一个 for 循环,以处理多维数据结构或执行更复杂的逻辑。

for i in {1..3}; dofor j in {a..c}; doecho "i=$i, j=$j"done
done

7. breakcontinue 语句

你可以在 for 循环中使用 break 语句来立即退出循环,或使用 continue 语句来跳过当前迭代并继续下一次迭代。

for i in {1..5}; doif [ $i -eq 3 ]; thencontinue  # 跳过 i=3 的迭代fiif [ $i -eq 5 ]; thenbreak  # 退出循环fiecho "i=$i"
done

在这个例子中,当 i 等于 3 时,continue 语句会导致循环跳过当前迭代并继续下一次迭代。当 i 等于 5 时,break 语句会立即退出循环。

总结

Bash 的 for 循环是一种非常灵活和强大的控制结构,适用于各种场景。通过理解不同的循环用法和选项,你可以编写出更强大、更高效的 Bash 脚本。




















































Bash数组

在 Bash 脚本中,数组是一种非常有用的数据结构,可以用来存储一系列的值。Bash 支持一维数组,并且可以通过索引来访问这些值。以下是一些关于 Bash 数组的基本操作和示例:

声明和初始化数组

  1. 声明数组(不初始化)

    declare -a my_array
    
  2. 直接初始化数组

    my_array=(value1 value2 value3)
    
  3. 通过索引初始化数组

    my_array[0]=value1
    my_array[1]=value2
    my_array[2]=value3
    

访问数组元素

  1. 通过索引访问

    echo ${my_array[0]}  # 输出 value1
    echo ${my_array[1]}  # 输出 value2
    
  2. 访问所有元素

    echo ${my_array[@]}  # 输出 value1 value2 value3
    echo ${my_array[*]}  # 输出 value1 value2 value3
    

获取数组长度

  1. 获取数组元素的个数
    length=${#my_array[@]}
    echo $length  # 输出 3
    

遍历数组

  1. 使用 for 循环遍历数组

    for element in "${my_array[@]}"; doecho $element
    done
    
  2. 使用索引遍历数组

    for i in "${!my_array[@]}"; doecho "Index $i: ${my_array[$i]}"
    done
    

修改数组元素

  1. 通过索引修改
    my_array[1]=new_value2
    echo ${my_array[1]}  # 输出 new_value2
    

删除数组元素

  1. 通过 unset 删除特定元素

    unset my_array[1]
    echo ${my_array[@]}  # 输出 value1 (empty) value3
    
  2. 删除整个数组

    unset my_array
    

示例脚本

以下是一个完整的 Bash 脚本示例,展示了上述操作:

#!/bin/bash# 初始化数组
my_array=(apple banana cherry)# 访问数组元素
echo "First element: ${my_array[0]}"
echo "Second element: ${my_array[1]}"# 访问所有元素
echo "All elements: ${my_array[@]}"# 获取数组长度
length=${#my_array[@]}
echo "Array length: $length"# 遍历数组
echo "Traversing array:"
for element in "${my_array[@]}"; doecho $element
done# 使用索引遍历数组
echo "Traversing array with indices:"
for i in "${!my_array[@]}"; doecho "Index $i: ${my_array[$i]}"
done# 修改数组元素
my_array[1]=blueberry
echo "Modified second element: ${my_array[1]}"# 删除数组元素
unset my_array[1]
echo "Array after deletion: ${my_array[@]}"# 删除整个数组
unset my_array
echo "Array after deletion of all elements: ${my_array[@]}"  # 输出空行

这个脚本展示了如何声明、初始化、访问、修改和删除 Bash 数组中的元素,以及如何遍历数组和获取数组的长度。希望这些示例对你有所帮助!








Bash数组是一种数据结构,用于存储一系列元素,这些元素可以是数值、字符等类型。Bash数组支持一维数组,也支持关联数组(类似于字典,通过键值对存储数据)[1]。

如何在Bash中声明数组

在Bash中,声明数组有几种方式:

  1. 直接为所有数组元素赋值

    array=(1 2 3 4 5)  # 定义一个包含5个元素的数组[@1@]
    
  2. 通过索引为数组元素赋值

    array[0]=1
    array[1]=2
    array[2]=3  # 可以不按顺序赋值[@1@]
    
  3. 声明关联数组(需要先使用declare -A命令):

    declare -A myArray
    myArray=(["Unicom"]=10010 ["TELECOM"]=10000 ["Mobile"]=10086)  # 定义一个关联数组[@3@]
    
访问和修改Bash数组中的元素
  • 访问数组元素:使用${array[index]}格式,其中index是数组的索引。如果不指定索引,默认访问第一个元素(但需要注意,直接使用$array并不会显示整个数组,而是显示第一个元素的值,要显示整个数组应使用${array[@]}${array[*]})[@1@][@4@]。

    echo ${array[1]}  # 访问索引为1的元素[@1@]
    
  • 修改数组元素:直接对指定索引的元素重新赋值即可。

    array[1]=20  # 将索引为1的元素修改为20[@1@]
    
Bash数组的基本操作
  • 遍历数组:可以使用for循环遍历数组的元素或索引。

    for i in "${array[@]}"  # 或者 "${array[*]}"
    doecho $i
    done  # 遍历数组中的每个元素[@1@]
    
  • 计算数组长度:使用${#array[@]}${#array[*]}来计算数组的长度(即元素个数)[@1@][@4@]。

    echo ${#array[@]}  # 输出数组的长度[@1@]
    
  • 数组切片:可以获取数组中的某一段元素。

    echo ${array[@]:1:2}  # 获取从索引1开始,长度为2的子数组[@1@]
    
  • 数组替换:可以临时或永久替换数组中的元素。

    echo ${array[*]/2/20}  # 临时将元素2替换为20[@1@]
    array=(${array[*]/2/20})  # 永久替换[@1@]
    
  • 删除数组或数组元素:使用unset命令可以删除整个数组或数组中的某个元素。

    unset array  # 删除整个数组[@1@]
    unset array[1]  # 删除索引为1的元素[@1@]
    
Bash数组使用的示例场景
  • 存储和处理一系列相关的数据:例如,存储一组用户的ID和姓名,然后遍历这些数据进行处理。

  • 配置管理:将配置项存储在数组中,方便读取和修改。

  • 数据处理:在处理数据时,可以将数据分割成多个部分存储在数组中,然后逐一处理。

Bash数组是一种强大的数据结构,通过合理使用数组,可以简化脚本的编写,提高代码的可读性和可维护性。








在 Bash 脚本中,数组(Array) 是一种存储多个值的数据结构,支持索引和键值对形式。以下是 Bash 数组的 完整用法指南,涵盖基本操作、高级技巧和常见问题。


1. 数组的基本操作

1.1 声明数组
  • 普通数组(数字索引):

    # 隐式声明
    fruits=("Apple" "Banana" "Orange")# 显式声明
    declare -a colors=("Red" "Green" "Blue")
    
  • 关联数组(键值对,Bash 4.0+):

    declare -A user_info=(["name"]="Alice"["age"]=30["city"]="Paris"
    )
    

1.2 访问数组元素
  • 索引从 0 开始

    echo ${fruits[0]}   # 输出:Apple
    echo ${fruits[1]}   # 输出:Banana
    
  • 获取所有元素

    echo ${fruits[@]}   # 输出所有元素:Apple Banana Orange
    
  • 获取所有键(关联数组)

    echo ${!user_info[@]}  # 输出:name age city
    

1.3 修改和添加元素
  • 修改元素

    fruits[1]="Mango"   # 将索引 1 的元素改为 Mango
    
  • 添加元素到末尾

    fruits+=("Grape")   # 数组变为:Apple Mango Orange Grape
    

1.4 获取数组长度
  • 元素个数

    echo ${#fruits[@]}  # 输出:4
    
  • 单个元素的长度

    echo ${#fruits[0]}  # 输出:5(Apple 的字符数)
    

2. 数组的高级用法

2.1 遍历数组
  • 普通数组遍历

    for fruit in "${fruits[@]}"; doecho "Fruit: $fruit"
    done
    
  • 关联数组遍历

    for key in "${!user_info[@]}"; doecho "$key: ${user_info[$key]}"
    done
    

2.2 数组切片
  • 提取子数组
    # 语法:${数组名[@]:起始索引:长度}
    echo ${fruits[@]:1:2}  # 输出:Mango Orange
    

2.3 合并数组
  • 合并两个数组
    vegetables=("Carrot" "Broccoli")
    combined=("${fruits[@]}" "${vegetables[@]}")
    echo ${combined[@]}  # 输出:Apple Mango Orange Grape Carrot Broccoli
    

2.4 删除元素或数组
  • 删除单个元素

    unset fruits[2]      # 删除索引 2 的元素(Orange)
    
  • 删除整个数组

    unset fruits
    

3. 处理特殊场景

3.1 包含空格或特殊字符的元素
  • 用引号包裹元素
    files=("Document 1.txt" "Report 2023.pdf")
    for file in "${files[@]}"; doecho "File: $file"  # 正确处理文件名中的空格
    done
    

3.2 从命令输出创建数组
  • 按行分割
    # 将 `ls` 的输出存入数组(每个元素为一行)
    mapfile -t files < <(ls *.txt)
    echo "${files[@]}"
    

3.3 判断元素是否存在
  • 检查索引是否存在
    if [[ -v fruits[2] ]]; thenecho "索引 2 存在"
    fi
    

4. 关联数组(Bash 4.0+)

4.1 声明与初始化
declare -A capitals=(["France"]="Paris"["Japan"]="Tokyo"["Brazil"]="Brasília"
)
4.2 访问键值对
echo ${capitals["France"]}  # 输出:Paris
4.3 遍历关联数组
for country in "${!capitals[@]}"; doecho "$country 的首都是 ${capitals[$country]}"
done

5. 常见错误与解决

5.1 未加引号导致元素分割
  • 错误示例
    files=(*.txt)  # 如果文件名含空格,会被分割成多个元素
    
  • 正确做法
    # 使用循环安全处理
    files=()
    while IFS= read -r -d $'\0' file; dofiles+=("$file")
    done < <(find . -name "*.txt" -print0)
    

5.2 索引越界
  • Bash 不强制检查索引范围
    echo ${fruits[10]}  # 若索引 10 不存在,输出空
    

6. 实用示例

6.1 批量重命名文件
files=(*.jpg)
counter=1
for file in "${files[@]}"; domv "$file" "image_$counter.jpg"((counter++))
done
6.2 统计词频
text="apple banana apple orange banana apple"
words=($text)  # 将文本拆分为数组
declare -A count
for word in "${words[@]}"; do((count[$word]++))
done
for word in "${!count[@]}"; doecho "$word: ${count[$word]} 次"
done

7. 总结

操作语法示例
声明普通数组arr=("a" "b" "c")
声明关联数组declare -A arr=(["key"]="value")
遍历数组元素for item in "${arr[@]}"; do ...
获取数组长度echo ${#arr[@]}
数组切片echo ${arr[@]:1:2}
合并数组combined=("${a[@]}" "${b[@]}")

最佳实践

  1. 始终用双引号包裹数组变量(如 "${arr[@]}")。
  2. 优先使用 mapfilewhile read 处理命令输出。
  3. 关联数组需 Bash 4.0+,检查版本兼容性:bash --version








在Bash中,数组是一个非常有用的功能,它允许你存储一系列的值,并且可以通过索引来访问这些值。以下是一些关于Bash数组的基本操作和用法:

定义数组

  1. 直接定义并初始化数组:

    array=(value0 value1 value2 ... valueN)
    
  2. 逐个赋值给数组元素:

    array[0]=value0
    array[1]=value1
    # ...
    

访问数组元素

  • 访问特定的数组元素(使用索引):

    echo ${array[index]}
    
  • 获取整个数组的所有元素:

    echo ${array[@]}
    

    或者

    echo ${array[*]}
    

数组长度

  • 获取数组的长度(即数组中有多少个元素):
    echo ${#array[@]}
    
    或者
    echo ${#array[*]}
    

遍历数组

遍历数组中的所有元素,可以使用for循环:

for element in "${array[@]}"
doecho $element
done

或者使用索引的方式进行遍历:

for ((i=0; i<${#array[@]}; i++))
doecho ${array[$i]}
done

添加和删除数组元素

  • 在数组末尾添加元素:

    array+=("newValue")
    
  • 删除数组中的某个元素:

    unset array[index]
    
  • 清空数组:

    unset array
    

通过这些基本的操作,你可以有效地管理和操作Bash脚本中的数组数据结构。无论是简单的任务还是复杂的脚本编写,数组都是非常有用的工具。








在Bash中,数组是一种非常有用的数据结构,它可以用来存储多个元素。以下是Bash数组的详细介绍:

数组的定义

  • 定义方式
    • 直接赋值:可以使用括号来定义数组,并在括号内指定数组的元素,元素之间用空格分隔。例如:array=(element1 element2 element3)
    • 逐个赋值:也可以逐个为数组元素赋值,通过指定索引来确定元素的位置。例如:array[0]=element1array[1]=element2array[2]=element3
  • 动态定义:数组的大小可以根据需要动态调整,不需要事先指定固定的大小。

数组的访问

  • 访问单个元素:通过索引来访问数组中的单个元素,索引从0开始。例如,要访问数组array的第一个元素,可以使用${array[0]}
  • 访问所有元素:可以使用*@来访问数组中的所有元素。例如,${array[*]}${array[@]}会返回数组中的所有元素,元素之间用空格分隔。

数组的操作

  • 获取数组长度:使用#符号可以获取数组的长度,即元素的个数。例如,${#array[@]}${#array[*]}会返回数组array的长度。
  • 数组切片:可以使用切片操作来获取数组的一部分元素。语法为${array[@]:start:count},其中start是起始索引,count是要获取的元素个数。例如,${array[@]:1:2}会从索引1开始获取2个元素。
  • 数组拼接:可以将两个数组合并成一个新的数组。例如,array1=(element1 element2)array2=(element3 element4),则array3=("${array1[@]}" "${array2[@]}")会将array1array2的元素合并到array3中。
  • 数组删除:可以使用unset命令来删除数组中的元素或整个数组。例如,unset array[2]会删除数组array的第三个元素,unset array会删除整个数组。

数组的遍历

  • 使用for循环
array=(element1 element2 element3)
for element in "${array[@]}"
doecho $element
done
  • 使用索引遍历
array=(element1 element2 element3)
for ((i=0; i<${#array[@]}; i++))
doecho "${array[i]}"
done

关联数组

  • 定义和使用:Bash还支持关联数组,它使用字符串作为索引,而不是数字。需要先使用declare -A声明关联数组,然后可以使用字符串索引来赋值和访问元素。例如:
declare -A assoc_array
assoc_array["key1"]="value1"
assoc_array["key2"]="value2"
echo "${assoc_array["key1"]}"
  • 遍历关联数组
declare -A assoc_array
assoc_array["key1"]="value1"
assoc_array["key2"]="value2"
for key in "${!assoc_array[@]}"
doecho "Key: $key, Value: ${assoc_array[$key]}"
done








在Bash中,数组是一种可以存储多个值的数据结构。Bash支持一维数组,数组的元素可以是字符串或数字。以下是一些关于Bash数组的基本操作:

定义数组

你可以使用括号()来定义一个数组,并用空格分隔数组中的元素。

# 定义一个包含字符串的数组
fruits=("苹果" "香蕉" "橙子")# 定义一个包含数字的数组
numbers=(1 2 3 4 5)

访问数组元素

你可以使用下标来访问数组中的元素,下标从0开始。

echo ${fruits[0]} # 输出 "苹果"
echo ${numbers[2]} # 输出 3

获取数组长度

使用${#array[@]}${#array[*]}可以获取数组的长度。

echo ${#fruits[@]} # 输出 3
echo ${#numbers[@]} # 输出 5

遍历数组

你可以使用for循环来遍历数组中的所有元素。

# 遍历字符串数组
for fruit in "${fruits[@]}"
doecho "水果: $fruit"
done# 遍历数字数组
for number in "${numbers[@]}"
doecho "数字: $number"
done

添加和删除元素

Bash数组没有直接的添加和删除元素的方法,但你可以通过重新赋值来实现。

# 添加元素到数组末尾
fruits+=("葡萄")# 删除数组中的某个元素
unset fruits[1] # 删除第二个元素 "香蕉"

截取数组

你可以截取数组的一部分来创建一个新的数组。

# 截取数组的前两个元素
first_two=("${fruits[@]:0:2}")
echo "${first_two[@]}" # 输出 "苹果 橙子"

综合示例

以下是一个综合示例,展示了如何定义数组、访问元素、遍历数组以及添加和删除元素。

# 定义数组
colors=("红色" "绿色" "蓝色")# 访问元素
echo "第一个颜色是: ${colors[0]}" # 输出 "红色"# 遍历数组
echo "所有颜色:"
for color in "${colors[@]}"
doecho "$color"
done# 添加元素
colors+=("黄色")
echo "添加新颜色后:"
for color in "${colors[@]}"
doecho "$color"
done# 删除元素
unset colors[1] # 删除 "绿色"
echo "删除第二个颜色后:"
for color in "${colors[@]}"
doecho "$color"
done

以上就是Bash中数组的基本用法和一些示例。通过这些基本操作,你可以有效地管理和操作数组中的数据。

相关文章:

Linux的循环,bash的循环

Linux的循环,bash的循环 在 Linux 系统中&#xff0c;Bash 循环是最常用的循环实现方式&#xff08;Bash 是 Linux 默认的 Shell&#xff09;&#xff0c;但广义上“Linux 的循环”可能涉及其他 Shell 或编程语言的循环结构。以下是 Bash 循环的详细解析及其在 Linux 环境中的…...

【DeepSeek开发】Python实现股票数据可视化

代码&#xff1a; Github&#xff1a;Python实现股票数据可视化代码https://github.com/magolan2000/Data-visualization/tree/master 软件环境&#xff1a;PyCharm 2022.3.1 数据来源&#xff1a;akshare 最近DeepSeek可谓是热度不断&#xff0c;因此想评判一下DeepSeek的编程…...

华为小米vivo向上,苹果荣耀OPPO向下

日前&#xff0c;Counterpoint发布的手机销量月度报告显示&#xff0c;中国智能手机销量在2024年第四季度同比下降3.2%&#xff0c;成为2024年唯一出现同比下滑的季度。而对于各大智能手机品牌来说&#xff0c;他们的市场份额和格局也在悄然发生变化。 华为逆势向上 在2024年第…...

毕业设计:基于深度学习的高压线周边障碍物自动识别与监测系统

目录 前言 课题背景和意义 实现技术思路 一、算法理论基础 1.1 卷积神经网络 1.2 目标检测算法 1.3 注意力机制 二、 数据集 2.1 数据采集 2.2 数据标注 三、实验及结果分析 3.1 实验环境搭建 3.2 模型训练 3.2 结果分析 最后 前言 &#x1f4c5;大四是整个大学…...

el-table表格点击单元格实现编辑

使用 el-table 和 el-table-column 创建表格。在单元格的默认插槽中&#xff0c;使用 div 显示文本内容&#xff0c;单击时触发编辑功能。使用 el-input 组件在单元格中显示编辑框。data() 方法中定义了 tableData&#xff0c;tabClickIndex: null,tabClickLabel: ,用于判断是否…...

数据结构:时间复杂度

文章目录 为什么需要时间复杂度分析&#xff1f;一、大O表示法&#xff1a;复杂度的语言1.1 什么是大O&#xff1f;1.2 常见复杂度速查表 二、实战分析&#xff1a;解剖C语言代码2.1 循环结构的三重境界单层循环&#xff1a;线性时间双重循环&#xff1a;平方时间动态边界循环&…...

SPI(Serial Peripheral Interface)串行外围设备接口

SPI概述&#xff1a; SPI协议最初由Motorola公司&#xff08;现为NXP Semiconductors的一部分&#xff09;在20世纪80年代中期开发。最初是为了在其68000系列微控制器中实现高速、高效的串行通信。该协议旨在简化微控制器与外围设备之间的数据传输。 1980年代&#xff1a;SPI协…...

Java 8 Stream API

通过 Stream.of 方法直接传入多个元素构成一个流 String[] arr {“a”, “b”, “c”}; Stream.of(arr).forEach(System.out::println); Stream.of(“a”, “b”, “c”).forEach(System.out::println); Stream.of(1, 2, “a”).map(item -> item.getClass().getName()…...

亚博microros小车-原生ubuntu支持系列:21 颜色追踪

背景知识 这个测试例子用到了很多opencv的函数&#xff0c;举个例子。 #cv2.findContours函数来找到二值图像中的轮廓。#参数&#xff1a;#参数1&#xff1a;输 入的二值图像。通常是经过阈值处理后的图像&#xff0c;例如在颜色过滤之后生成的掩码。#参数2(cv2.RETR_EXTERNA…...

GESP6级语法知识(六):(动态规划算法(六)多重背包)

多重背包&#xff08;二维数组&#xff09; #include <iostream> using namespace std; #define N 1005 int Asd[N][N]; //Asd[i][j]表示前 i 个物品&#xff0c;背包容量是 j 的情况下的最大价值。 int Value[N], Vol[N], S[N];int main() {int n, Volume;cin &g…...

MySQL 事务实现原理( 详解 )

MySQL 主要是通过: 锁、Redo Log、Undo Log、MVCC来实现事务 事务的隔离性利用锁机制实现 原子性、一致性和持久性由事务的 redo 日志和undo 日志来保证。 Redo Log(重做日志)&#xff1a;记录事务对数据库的所有修改&#xff0c;在崩溃时恢复未提交的更改&#xff0c;保证事务…...

AI协助探索AI新构型自动化创新的技术实现

一、AI自进化架构的核心范式 1. 元代码生成与模块化重构 - 代码级自编程&#xff1a;基于神经架构搜索的强化学习框架&#xff0c;AI可通过生成元代码模板&#xff08;框架的抽象层定义&#xff09;自动组合功能模块。例如&#xff0c;使用注意力机制作为原子单元&#xff…...

九. Redis 持久化-RDB(详细讲解说明,一个配置一个说明分析,步步讲解到位)

九. Redis 持久化-RDB(详细讲解说明&#xff0c;一个配置一个说明分析&#xff0c;步步讲解到位) 文章目录 九. Redis 持久化-RDB(详细讲解说明&#xff0c;一个配置一个说明分析&#xff0c;步步讲解到位)1. RDB 概述2. RDB 持久化执行流程3. RDB 的详细配置4. RDB 备份&恢…...

mac连接linux服务器

1、mac连接linux服务器 # ssh -p 22 root192.168.1.152、mac指定密码连接linux服务器 (1) 先安装sshpass,下载后解压执行 ./configure && make && makeinstall https://sourceforge.net/projects/sshpass/ (2) 连接linux # sshpass -p \/\\\[\!\\wen12\$ s…...

oracle: 表分区>>范围分区,列表分区,散列分区/哈希分区,间隔分区,参考分区,组合分区,子分区/复合分区/组合分区

分区表 是将一个逻辑上的大表按照特定的规则划分为多个物理上的子表&#xff0c;这些子表称为分区。 分区可以基于不同的维度&#xff0c;如时间、数值范围、字符串值等&#xff0c;将数据分散存储在不同的分区 中&#xff0c;以提高数据管理的效率和查询性能&#xff0c;同时…...

使用Pygame制作“走迷宫”游戏

1. 前言 迷宫游戏是最经典的 2D 游戏类型之一&#xff1a;在一个由墙壁和通道构成的地图里&#xff0c;玩家需要绕过障碍、寻找通路&#xff0c;最终抵达出口。它不但简单易实现&#xff0c;又兼具可玩性&#xff0c;还能在此基础上添加怪物、道具、机关等元素。本篇文章将展示…...

AJAX案例——图片上传个人信息操作

黑马程序员视频地址&#xff1a; AJAX-Day02-11.图片上传https://www.bilibili.com/video/BV1MN411y7pw?vd_source0a2d366696f87e241adc64419bf12cab&spm_id_from333.788.videopod.episodes&p26 图片上传 <!-- 文件选择元素 --><input type"file"…...

Day35-【13003】短文,什么是双端队列?栈和队列的互相模拟,以及解决队列模拟栈时出栈时间开销大的方法

文章目录 第三节进一步讨论栈和队列双端队列栈和队列的相互模拟使用栈来模拟队列类型定义入队出队判空&#xff0c;判满 使用队列来模拟栈类型定义初始化清空操作判空&#xff0c;判满栈长度输出入栈出栈避免出栈时间开销大的方法 第三节进一步讨论栈和队列 双端队列 假设你芷…...

力扣 55. 跳跃游戏

&#x1f517; https://leetcode.cn/problems/jump-game 题目 给一个数组 nums&#xff0c;最开始在 index 0&#xff0c;每次可以跳跃的区间是 0-nums[i]判断是否可以跳到数组末尾 思路 题解是用贪心&#xff0c;实际上模拟也可以过遍历可以到达的下标&#xff0c;判断其可…...

深入剖析 HTML5 新特性:语义化标签和表单控件完全指南

系列文章目录 01-从零开始学 HTML&#xff1a;构建网页的基本框架与技巧 02-HTML常见文本标签解析&#xff1a;从基础到进阶的全面指南 03-HTML从入门到精通&#xff1a;链接与图像标签全解析 04-HTML 列表标签全解析&#xff1a;无序与有序列表的深度应用 05-HTML表格标签全面…...

本地快速部署DeepSeek-R1模型——2025新年贺岁

一晃年初六了&#xff0c;春节长假余额马上归零了。今天下午在我的电脑上成功部署了DeepSeek-R1模型&#xff0c;抽个时间和大家简单分享一下过程&#xff1a; 概述 DeepSeek模型 是一家由中国知名量化私募巨头幻方量化创立的人工智能公司&#xff0c;致力于开发高效、高性能…...

MVC 文件夹:架构之美与实际应用

MVC 文件夹:架构之美与实际应用 引言 MVC(Model-View-Controller)是一种设计模式,它将应用程序分为三个核心组件:模型(Model)、视图(View)和控制器(Controller)。这种架构模式不仅提高了代码的可维护性和可扩展性,而且使得开发流程更加清晰。本文将深入探讨MVC文…...

Redis --- 秒杀优化方案(阻塞队列+基于Stream流的消息队列)

下面是我们的秒杀流程&#xff1a; 对于正常的秒杀处理&#xff0c;我们需要多次查询数据库&#xff0c;会给数据库造成相当大的压力&#xff0c;这个时候我们需要加入缓存&#xff0c;进而缓解数据库压力。 在上面的图示中&#xff0c;我们可以将一条流水线的任务拆成两条流水…...

如何确认设备文件 /dev/fb0 对应的帧缓冲设备是开发板上的LCD屏?如何查看LCD屏的属性信息?

要判断 /dev/fb0 是否对应的是 LCD 屏幕&#xff0c;可以通过以下几种方法&#xff1a; 方法 1&#xff1a;使用 fbset 命令查看帧缓冲设备的属性信息 Linux 的 帧缓冲设备&#xff08;Framebuffer&#xff09; 通常在 /dev/fbX 下&#xff0c;/dev/fb0 一般是主屏幕&#xff…...

C++多线程编程——基于策略模式、单例模式和简单工厂模式的可扩展智能析构线程

1. thread对象的析构问题 在 C 多线程标准库中&#xff0c;创建 thread 对象后&#xff0c;必须在对象析构前决定是 detach 还是 join。若在 thread 对象销毁时仍未做出决策&#xff0c;程序将会终止。 然而&#xff0c;在创建 thread 对象后、调用 join 前的代码中&#xff…...

AI与SEO关键词的完美结合如何提升网站流量与排名策略

内容概要 在当今数字营销环境中&#xff0c;内容的成功不仅依赖于高质量的创作&#xff0c;还包括高效的关键词策略。AI与SEO关键词的结合&#xff0c;正是这一趋势的重要体现。 AI技术在SEO中的重要性 在数字营销领域&#xff0c;AI技术的引入为SEO策略带来了前所未有的变革。…...

保姆级教程Docker部署Kafka官方镜像

目录 一、安装Docker及可视化工具 二、单节点部署 1、创建挂载目录 2、运行Kafka容器 3、Compose运行Kafka容器 4、查看Kafka运行状态 三、集群部署 在Kafka2.8版本之前&#xff0c;Kafka是强依赖于Zookeeper中间件的&#xff0c;这本身就很不合理&#xff0c;中间件依赖…...

解析PHP文件路径相关常量

PHP文件路径相关常量包括以下几个常量&#xff1a; __FILE__&#xff1a;表示当前文件的绝对路径&#xff0c;包括文件名。 __DIR__&#xff1a;表示当前文件所在的目录的绝对路径&#xff0c;不包括文件名。 dirname(__FILE__)&#xff1a;等同于__DIR__&#xff0c;表示当前…...

WPS计算机二级•幻灯片的配色、美化与动画

听说这是目录哦 配色基础颜色语言❤️使用配色方案&#x1fa77;更改PPT的颜色&#x1f9e1;PPT动画添加的原则&#x1f49b;PPT绘图工具&#x1f49a;自定义设置动画&#x1f499;使用动画刷复制动画效果&#x1fa75;制作文字打字机效果&#x1f49c;能量站&#x1f61a; 配色…...

C#,shell32 + 调用控制面板项(.Cpl)实现“新建快捷方式对话框”(全网首发)

Made By 于子轩&#xff0c;2025.2.2 不管是使用System.IO命名空间下的File类来创建快捷方式文件&#xff0c;或是使用Windows Script Host对象创建快捷方式&#xff0c;亦或是使用Shell32对象创建快捷方式&#xff0c;都对用户很不友好&#xff0c;今天小编为大家带来一种全新…...