2024年12月

1.业务场景

有些时候，我需要知道某个jar包依赖了哪些包，这个时候可以通过maven 依赖插件将依赖的包copy出来。

2.具体做法

我们可以创建一个空的项目，增加 pom.xml 文件,增加我们需要的依赖包。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.redxun</groupId>
        <artifactId>jpaas-cloud</artifactId>
        <version>6.8.5-SNAPSHOT</version>
    </parent>

    <groupId>com.study</groupId>
    <artifactId>ActivitiDep</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-engine</artifactId>
            <version>7.1.0.2.M7</version>
        </dependency>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-image-generator</artifactId>
            <version>7.1.0.2.M7</version>
        </dependency>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-spring-boot-starter</artifactId>
            <version>7.1.0.2.M7</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <!-- 复制依赖 -->
                <executions>
                    <execution>
                        <id>copy-dependencies</id>
                        <phase>package</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                        <configuration>
                            <!-- 依赖包 输出目录 -->
                            <outputDirectory>${project.build.directory}/lib</outputDirectory>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

添加这个后，我们执行 maven 的 package打包命令，maven就会将我们需要的JARcopy到指定的目录下面。

3.输出依赖树

有些时候，我需要输出依赖的结构，那么可以使用下面的命令进行输出

mvn  dependency:tree > dep.txt

输出的内容如下:

[INFO] --- maven-dependency-plugin:3.0.2:tree (default-cli) @ ActivitiDep ---
[INFO] com.study:ActivitiDep:jar:6.8.5-SNAPSHOT
[INFO] +- org.activiti:activiti-engine:jar:7.1.0.2.M7:compile
[INFO] |  +- org.activiti.api:activiti-api-runtime-shared:jar:7.1.0.2.M7:compile
[INFO] |  +- org.activiti.core.common:activiti-project-model:jar:7.1.0.2.M7:compile
[INFO] |  +- org.activiti:activiti-bpmn-converter:jar:7.1.0.2.M7:compile
[INFO] |  +- org.activiti:activiti-bpmn-model:jar:7.1.0.2.M7:compile
[INFO] |  +- org.activiti:activiti-process-validation:jar:7.1.0.2.M7:compile
[INFO] |  +- org.apache.commons:commons-email:jar:1.5:compile
[INFO] |  |  \- com.sun.mail:javax.mail:jar:1.5.6:compile
[INFO] |  |     \- javax.activation:activation:jar:1.1:compile
[INFO] |  +- org.mybatis:mybatis:jar:3.5.1:compile
[INFO] |  +- org.springframework:spring-beans:jar:5.2.15.RELEASE:compile
[INFO] |  +- org.springframework:spring-core:jar:5.2.15.RELEASE:compile
[INFO] |  |  \- org.springframework:spring-jcl:jar:5.2.15.RELEASE:compile
[INFO] |  +- de.odysseus.juel:juel-api:jar:2.2.7:compile
[INFO] |  +- de.odysseus.juel:juel-impl:jar:2.2.7:compile
[INFO] |  +- de.odysseus.juel:juel-spi:jar:2.2.7:compile
[INFO] |  +- com.fasterxml.jackson.core:jackson-core:jar:2.11.4:compile
[INFO] |  +- com.fasterxml.jackson.core:jackson-annotations:jar:2.11.4:compile
[INFO] |  +- com.fasterxml.jackson.core:jackson-databind:jar:2.11.4:compile
[INFO] |  +- joda-time:joda-time:jar:2.10.5:compile

Shell编程

作者: wenmo8
时间: 2024-12-03
分类: 其它
评论

# 自定义vim，以便于更好的编写shell
[root@kylin-xu ~]# vim .vimrc
set ts=4
set ai
autocmd BufNewFile *.sh exec ":call SetTitle()"

func SetTitle()
    if expand("%:e") == 'sh'
        call setline(1,"#!/bin/bash")
        call setline(2,"#")
        call setline(3,"#****************************************************")
        call setline(4,"#Author:            xu")
        call setline(5,"#QQ:                123456")
        call setline(6,"#Date:              ".strftime("%Y-%m-%d"))
        call setline(7,"#FileName:          ".expand("%"))
        call setline(8,"#URL:               https://www.cnblogs.com/xuruizhao")
        call setline(9,"#Description:       test")
        call setline(10,"#Copyright(C):     ".strftime("%Y")." All right")
        call setline(11,"#***************************************************")
        call setline(12,"")
        call setline(13,"")
        call setline(14,"")
    endif
endfunc
autocmd BufNewFile * normal G

一、 shell脚本语言的基本用法

【1】、shell脚本的用途

将简单的命令组合完成复杂的工作，自动化执行命令，提高工作效率
减少手工命令的输入，一定程度上避免人为错误
将软件或应用的安装及配置实现标准化
用于实现日常性的，重复性的，非交互式的运维工作，如：文件打包压缩备份，监控系统运行状态并实现告警等

【2】、shell脚本格式

shell是基于过程式、解释执行的语言。

shell脚本是包含一些命令或声明，并符合一定格式的文本文件。

一个shell脚本文件中主要包含以下内容

各种系统命令的组合
数据存储：变量、数组
表达式：a + b
控制语句：if

格式要求：首行shebang机制
#!/bin/bash 
#!/usr/bin/python
#!/usr/bin/perl 
#!/usr/bin/ruby
#!/usr/bin/lua

【3】、shell脚本创建过程

用编辑器创建新文件，首行必须是 shell 声明（shebang），编辑完成后保存退出
添加可执行权限
运行脚本

#新建文件
[root@kylin-xu ~]# vim test.sh
#!/bin/bash
echo "hello world" 

# 如果没有x权限，在执行时就需要加上解释器
[root@kylin-xu ~]# bash test.sh 
hello world

#加可执行权限，通过绝对路径和相对路径执行
[root@kylin-xu ~]# ./test.sh
-bash: ./test.sh: 权限不够
[root@kylin-xu ~]# chmod +x test.sh 
[root@kylin-xu ~]# ./test.sh
hello 

# 我们也可以将脚本路径加到PATH中，然后就可以直接执行脚本了
[root@kylin-xu ~]# test.sh
-bash: test.sh：未找到命令
[root@kylin-xu ~]# PATH=`pwd`:$PATH
[root@kylin-xu ~]# echo $PATH
/root:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/root/bin
[root@kylin-xu ~]# test.sh
hello world

【4】、第一个shell脚本

[root@kylin-xu scripts]# vim hello.sh
#!/bin/bash
echo hello world
echo "hello world"
echo 'hello world'

[root@kylin-xu scripts]# bash hello.sh 
hello world
hello world
hello world

当前shell执行，和子shell执行

# 父子shell的关系
root@xu-ubuntu:~/scripts# cat 01.sh 
#!/bin/bash

echo hello world
echo 'hello world'
echo "hello world"
sleep 100

# bash 01.sh是在当前shell执行
root@xu-ubuntu:~/scripts# bash 01.sh 
hello world
hello world
hello world
root@xu-ubuntu:~# pstree -p
 ├─sshd(29225)─┬─sshd(83993)───sshd(84113)───bash(84114)───su(84241)───bash(84256)───bash(84456)───sleep(84457)
# ./01.sh 是在子shell执行
root@xu-ubuntu:~/scripts# ./01.sh 
hello world
hello world
hello world

root@xu-ubuntu:~# pstree -p
├─sshd(29225)─┬─sshd(83993)───sshd(84113)───bash(84114)───su(84241)───bash(84256)───01.sh(84468)───sleep(84469)

本地执行远程脚本 - 脚本文件在远程主机，在本机执行并在本机生效，执行结果影响的是本机

test.sh脚本在192.168.121.99主机上
[root@kylin-xu html]# cat /var/www/html/test.sh 
#!/bin/bash

echo 'haha'
touch /root/1.txt

在192.168.121.88上执行并生效
root@xu-ubuntu:~/scripts# curl http://192.168.121.99/test.sh | bash
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100   375  100   375    0     0  72032      0 --:--:-- --:--:-- --:--:-- 93750
haha
root@xu-ubuntu:~/scripts# ll /root/1.txt 
-rw-r--r-- 1 root root 0 Nov 24 19:24 /root/1.txt

脚本在本地，我在远程主机执行本地脚本，脚本的输出结果是在本地，但是脚本的作用对象是远程主机

脚本在本地，在本地执行
root@xu-ubuntu:~/scripts# vim 02.sh
#!/bin/bash

hostname
hostname -I
root@xu-ubuntu:~/scripts# bash 02.sh 
xu-ubuntu
192.168.121.88 

# 连接上远程主机，执行本地shell，shell的结果输出在本地，但是却作用于远程主机
root@xu-ubuntu:~/scripts# ssh 192.168.121.99 /bin/bash < 02.sh 
kylin-xu
192.168.121.99

【5】、shell脚本调试

写一个脚本，获取主机系统信息，包括CPU型号，内存大小，硬盘大小，操作系统版本这四个指标

# version1.0
root@xu-ubuntu:~/scripts# vim sys_ver1.0.sh
#! /bin/bash
lscpu  | grep 'Model name'  | sed -r 's#.*:[ ]+(.*$)#\1#'
free -h | awk 'NR==2{print $2}' 
lsblk | awk '/^sda/{print $(NF-2)}' 
grep 'PRETTY_NAME' /etc/os-release | sed -r 's#.*"(.*)"$#\1#'
root@xu-ubuntu:~/scripts# chmod +x sys_ver1.0.sh 
root@xu-ubuntu:~/scripts# ./sys_ver1.0.sh 
13th Gen Intel(R) Core(TM) i5-13500HX
3.8Gi
50G
Ubuntu 22.04.5 LTS


# version2
root@xu-ubuntu:~/scripts# vim sys_ver2.0.sh
#!/bin/bash

echo -e "CPU info: \c"
lscpu  | grep 'Model name'  | sed -r 's#.*:[ ]+(.*$)#\1#'
echo -e "free total: \c"
free -h | awk 'NR==2{print $2}'
echo -e "hd size: \c"
lsblk | awk '/^sda/{print $(NF-2)}'
echo -e "sys info: \c"
grep 'PRETTY_NAME' /etc/os-release | sed -r 's#.*"(.*)"$#\1#'
root@xu-ubuntu:~/scripts# bash sys_ver2.0.sh 
CPU info: 13th Gen Intel(R) Core(TM) i5-13500HX
free total: 3.8Gi
hd size: 50G
sys info: Ubuntu 22.04.5 LTS


# version3,给输出加上颜色
root@xu-ubuntu:~/scripts# vim sys_ver2.0.sh
#!/bin/bash

echo -e "CPU info: \c"
echo -e "\E[1;32m`lscpu  | grep 'Model name'  | sed -r 's#.*:[ ]+(.*$)#\1#'`\E[0m"

echo -e "free total: \c"
echo -e "\E[1;32m`free -h | awk 'NR==2{print $2}'`\E[0m"

echo -e "hd size: \c"
echo -e "\E[1;32m`lsblk | awk '/^sda/{print $(NF-2)}'`\E[0m"

echo -e "sys info: \c"
echo -e "\E[1;32m`grep 'PRETTY_NAME' /etc/os-release | sed -r 's#.*"(.*)"$#\1#'`\E[0m"
root@xu-ubuntu:~/scripts# bash sys_ver2.0.sh 
CPU info: 13th Gen Intel(R) Core(TM) i5-13500HX
free total: 3.8Gi
hd size: 50G
sys info: Ubuntu 22.04.5 LTS

执行前先做语法检查

此选项只能检测脚本中的语法错误，不能检测命令错误，也不会执行脚本

bash -n

root@xu-ubuntu:~/scripts# vim 03.sh
#!/bin/bash

echo 123
echo 456
echo "ased
root@xu-ubuntu:~/scripts# bash -n 03.sh 
03.sh: line 16: unexpected EOF while looking for matching `"'
03.sh: line 17: syntax error: unexpected end of file

调试并执行，查找命令的错误

逐行输出命令，并输出执行结果

bash -x

root@xu-ubuntu:~/scripts# vim 04.sh
echo '123'
id
hostname
hostname -I
echo 45
root@xu-ubuntu:~/scripts# bash -x 04.sh 
+ echo 123
123
+ id
uid=0(root) gid=0(root) groups=0(root)
+ hostname
xu-ubuntu
+ hostname -I
192.168.121.88 
+ echo 456
456

# 获取两天后的日期
root@xu-ubuntu:~/scripts# date +%F
2024-11-24
root@xu-ubuntu:~/scripts# date +%F --date="+2 day"
2024-11-26

总结：脚本错误常见的有三种

语法错误：会导致后续的命令不继续执行，可以用 bash -n 检查错误，提示的出错行数不一定是准确的
命令错误：默认后续的命令还会继续执行，用 bash -n 无法检查出来，可以使用 bash -x 进行观察
逻辑错误：只能使用 bash -x 进行观察

【6】、变量

1、变量类型

变量类型：

内置变量，如：PS1，PATH，UID，HOSTNAME，$$，BASHPID，PPID，$?，HISTSIZE
用户自定义变量

不同的变量存放的数据不同，决定了以下

数据存储方式
参与的运算
表示的数据范围

变量数据类型：

字符
数值：整型、浮点型，bash 不支持浮点数
布尔
指针
结构体：自定义的复合类型的数据类型
........

2、 Shell中变量命名法则

命名要求

区分大小写
不能使用程序中的保留字和内置变量：如：if, for
只能使用数字、字母及下划线，且不能以数字开头，注意：不支持短横线 “ - ”，和主机名相反

命名习惯

见名知义，用英文单词命名，并体现出实际作用，不要用简写，如：ATM
变量名大写
局部变量小写
函数名小写
大驼峰StudentFirstName，由多个单词组成，且每个单词的首字母是大写，其它小写
小驼峰studentFirstName ，由多个单词组成，第一个单词的首字母小写，后续每个单词的首字母
是大写，其它小写
下划线: student_first_name

3、变量的定义和引用

变量的生效范围等标准划分变量类型

普通变量：生效范围为当前shell进程；对当前shell之外的其它shell进程，包括当前shell的子shell 进程均无效
环境变量：生效范围为当前shell进程及其子进程
本地变量：生效范围为当前shell进程中某代码片断，通常指函数

（1）、变量赋值

name='value'

value 可以是以下多种形式

name='root' #直接字串
name="$USER" #变量引用
name=`COMMAND` #命令引用
name=$(COMMAND) #命令引用

root@xu-ubuntu:~/scripts# name="tom"
root@xu-ubuntu:~/scripts# echo $name
tom
root@xu-ubuntu:~/scripts# name=$USER
root@xu-ubuntu:~/scripts# echo $name
root
root@xu-ubuntu:~/scripts# name=`hostname`
root@xu-ubuntu:~/scripts# echo $name
xu-ubuntu
root@xu-ubuntu:~/scripts# name=$(hostname)
root@xu-ubuntu:~/scripts# echo $name
xu-ubuntu

注意：变量赋值是临时生效，当退出终端后，变量会自动删除，无法持久保存，脚本中的变量会随着脚本结束，也会自动删除

（2）、变量引用

$name
${name}

弱引用和强引用

"$name" 弱引用，其中的变量引用会被替换为变量值
'$name' 强引用，其中的变量引用不会被替换为变量值，而保持原字符串

变量的间接赋值和引用

root@xu-ubuntu:~/scripts# Ti=cto
root@xu-ubuntu:~/scripts# 
root@xu-ubuntu:~/scripts# name=wang
root@xu-ubuntu:~/scripts# Ti=$name
root@xu-ubuntu:~/scripts# echo $Ti
wang
root@xu-ubuntu:~/scripts# name=xu
root@xu-ubuntu:~/scripts# echo $Ti
wang

变量追加值

root@xu-ubuntu:~# TI=cto
root@xu-ubuntu:~# TI+=:xu
root@xu-ubuntu:~# echo $TI
cto:xu

在脚本中使用变量

COLOR=33

echo -e "CPU info: \c"
echo -e "\E[1;${COLOR}m`lscpu  | grep 'Model name'  | sed -r 's#.*:[ ]+(.*$)#\1#'`\E[0m"

echo -e "free total: \c"
echo -e "\E[1;${COLOR}m`free -h | awk 'NR==2{print $2}'`\E[0m"

echo -e "hd size: \c"
echo -e "\E[1;${COLOR}m`lsblk | awk '/^sda/{print $(NF-2)}'`\E[0m"

echo -e "sys info: \c"
echo -e "\E[1;${COLOR}m`grep 'PRETTY_NAME' /etc/os-release | sed -r 's#.*"(.*)"$#\1#'`\E[0m"


root@xu-ubuntu:~/scripts# bash sys_ver2.0.sh 
CPU info: 13th Gen Intel(R) Core(TM) i5-13500HX
free total: 3.8Gi
hd size: 50G
sys info: Ubuntu 22.04.5

（3）、删除变量

root@xu-ubuntu:~/scripts# name=xixi
root@xu-ubuntu:~/scripts# echo $name
xixi
root@xu-ubuntu:~/scripts# unset name
root@xu-ubuntu:~/scripts# echo $name

（4）、显示系统中定义的所有变量

root@xu-ubuntu:~/scripts# set | grep name=
name=xixi

4、环境变量

环境变量：

可以使子进程（包括孙子进程）继承父进程的变量，但是无法让父进程使用子进程的变量
一旦子进程修改从父进程继承的变量，将会新的值传递给孙子进程
一般只在系统配置文件中使用，在脚本中较少使用

变量声明和赋值：

#声明并赋值
export name=VALUE
declare -x name=VALUE
#或者分两步实现
name=VALUE
export name

显示所有环境变量

env
printenv
export
declare -x

查看指定进程的环境变量

cat /proc/$PID/environ

删除变量

unset

bash内建的环境变量

PATH
SHELL
USER
UID
HOME
PWD
SHLVL #shell的嵌套层数，即深度
LANG
MAIL
HOSTNAME
HISTSIZE
_   #下划线,表示前一命令的最后一个参数

root@xu-ubuntu:~# var1=123;export var1
root@xu-ubuntu:~# var2=456
# var1是环境变量，var2是普通变量
root@xu-ubuntu:~# vim scripts/en.sh
echo $var1
echo $var2
echo $PS1
echo $PATH

root@xu-ubuntu:~# ./scripts/en.sh   # 子shell执行
123


/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin

在父shell中定义的环境变量，在子shell中同样也可以引用

5、只读变量

只读变量：只能声明定义，但后续不能修改和删除，即
常量

声明只读变量

readonly name
declare -r name

查看只读变量

readonly [-p]
declare -r

root@xu-ubuntu:~# readonly name
root@xu-ubuntu:~# name="asd"
-bash: name: readonly variable

root@xu-ubuntu:~# readonly name="aaa"
root@xu-ubuntu:~# echo $name
aaa
root@xu-ubuntu:~# name=haha
-bash: name: readonly variable

6、位置变量

位置变量：在bash shell中内置的变量, 在脚本代码中调用通过命令行传递给脚本的参数

$1,$2,...,$9,${10}      #对应第1个、第2个等参数，shift [n]换位置
$0             #shell脚本的文件名
$*             #传递给脚本的所有参数，全部参数合为一个字符串
$@             #传递给脚本的所有参数，每个参数为独立字符串
$#             #传递给脚本的参数的个数
$$             #输出当前的PID

root@xu-ubuntu:~# vim scripts/arg.sh
echo "1st arg is $1"
echo "2st arg is $2"
echo "3st arg is $3"
echo "10st arg is ${10}"
echo "11st arg is ${11}"
echo "The number of arg is $#"
echo "All args are $*"
echo "All args are $@"
echo "The scriptname is `basename $0`"

[root@ubuntu2204 ~]# bash /data/scripts/arg.sh {a..z}
1st arg is a
2st arg is b
3st arg is c
10st arg is j
11st arg is k
The number of arg is 26
All args are a b c d e f g h i j k l m n o p q r s t u v w x y z
All args are a b c d e f g h i j k l m n o p q r s t u v w x y z
The scriptname is arg.sh

$*和$@的区别

for i in "$*";do
        echo $i
done

for j in "$@";do
        echo $j
done
root@xu-ubuntu:~# bash scripts/05.sh 1 2 3
1 2 3
1
2
3

$*：将接收到的参数看为一个整体
$@：将接收到每一个参数看作一个单独的参数

范例: 利用软链接实现同一个脚本不同功能

root@xu-ubuntu:~# ll /usr/sbin/shutdown
lrwxrwxrwx 1 root root 14 Nov 22  2023 /usr/sbin/shutdown -> /bin/systemctl*
root@xu-ubuntu:~# ll /usr/sbin/reboot
lrwxrwxrwx 1 root root 14 Nov 22  2023 /usr/sbin/reboot -> /bin/systemctl*

root@xu-ubuntu:~/scripts# cat test.sh 
echo $0

root@xu-ubuntu:~/scripts# ln -s test.sh a.sh
root@xu-ubuntu:~/scripts# bash a.sh 
a.sh

root@xu-ubuntu:~/scripts# ln -s test.sh b.sh
root@xu-ubuntu:~/scripts# bash b.sh 
b.sh

if [ $0 == "a.sh" ];then
        echo "aaa"
elif [ $0 == "b.sh" ];then
        echo "bbb"
fi
root@xu-ubuntu:~/scripts# bash a.sh 
aaa
root@xu-ubuntu:~/scripts# bash b.sh 
bbb

7、退出状态码变量

进程执行后，将使用变量 $? 保存状态码的相关数字，不同的值反应成功或失败，$?取值范例 0-255

$? 		   #0代表成功,1-255代表失败

root@xu-ubuntu:~/scripts# echo $?
0
root@xu-ubuntu:~/scripts# ping -c1 -w1 baidu.afasfsascom >/dev/null 2>&1
root@xu-ubuntu:~/scripts# echo $?
2

用户可以在脚本中使用以下命令自定义退出状态码

exit [n]

注意：

脚本中一旦遇到exit命令，脚本会立即终止；终止退出状态取决于exit命令后面的数字
如果exit后面无数字，终止退出状态取决于exit命令前面命令执行结果
如果没有exit命令，即未给脚本指定退出状态码，整个脚本的退出状态码取决于脚本中执行的最后一条命令的状态码

8、脚本安全$-

root@xu-ubuntu:~/scripts# echo $-
himBHs

选项	含义
h	开启hash表缓存外部命令路径
i	当前是交互shell
m	开启监控模式，可通过 Job control来控制进程的停止、继续，后台
B	是否支持大括号扩展
H	是否可用 ! 快速展开history命令

root@xu-ubuntu:~/scripts# echo $-
himBHs
root@xu-ubuntu:~/scripts# set +B
root@xu-ubuntu:~/scripts# echo $-
himHs
root@xu-ubuntu:~/scripts# echo {1..4}
{1..4}
root@xu-ubuntu:~/scripts# set -B
root@xu-ubuntu:~/scripts# echo $-
himBHs
root@xu-ubuntu:~/scripts# set +h
root@xu-ubuntu:~/scripts# hash
-bash: hash: hashing disabled

终端中的$- 和 shell脚本中的$- 不同

root@xu-ubuntu:~/scripts# cat 07.sh 
echo $-
root@xu-ubuntu:~/scripts# bash 07.sh 
hB
root@xu-ubuntu:~/scripts# echo $-
himBHs

【7】、格式化输出printf

相当于增强版的 echo, 实现丰富的格式化输出

格式

printf format args..

常用格式替换符

替换符	功能
%s	字符串
%d，%i	十进制整数
%f	浮点类型
%c	ASCII字符，即显示对应参数的第一个字符
%b	相对应的参数中包含转义字符时，可以使用此替换符进行替换，对应的转义字符会被转义
%o	八进制
%u	无符号数
%x	十六进制数值（a-f）
%X	十六进制数值（A-F）
%%	表示%本身

常用转义字符

转义符	功能
\a	警告字符通常为ASCII的BEL字符
\b	退格
\f	换页
\n	换行
\r	回车
\t	水平制表符
\v	垂直制表符
\	表示 \ 本身

root@xu-ubuntu:~/scripts# printf "%s\n"  1 2 3
1
2
3
root@xu-ubuntu:~/scripts# printf "%f\n" 1 2
1.000000
2.000000
# .3f表示保存3位小数
root@xu-ubuntu:~/scripts# printf "%.3f\n" 1.1234 2.12345
1.123
2.123

# 最后的echo表示换行的意思
root@xu-ubuntu:~/scripts# printf "(%s)---" 1 2 3 ;echo
(1)---(2)---(3)---

root@xu-ubuntu:~/scripts# printf "%-10s %-10s %-4s %s \n" 姓名 性别 年龄 体重 小明 男 20 70 小红 女 18 50
# - 表示左对齐，不加- 是右对齐
姓名     性别     年龄 体重 
小明     男        20   70 
小红     女        18   50

# 进制转换
14root@xu-ubuntu:~/scripts# printf "%o" 12;echo 
14

0root@xu-ubuntu:~/scripts# printf "%x" 999 ;echo
3e7
root@xu-ubuntu:~/scripts# printf "%X" 999 ;echo
3E7

【8】、运算符

1、算术运算符

Shell允许在某些情况下对算术表达式进行求值，比如：let和declare 内置命令，(( ))复合命令和算术扩展。求值以固定宽度的整数进行，不检查溢出，尽管除以0 被标记为错误。运算符及其优先级，关联性和值与C语言相同。以下运算符列表分组为等优先级运算符级别。级别按降序排列优先。

注意：bash 只支持整数，不支持小数

+ -                               #addition, subtraction
* / %                             #multiplication, division, remainder, %表示取模，即取余数，示例：9%4=1，5%3=2 
i++ i--                           #variable post-increment and post-decrement
++i --i                           #variable pre-increment and pre-decrement
= *= /= %= += -= <<= >>= &= ^= |=   #assignment
- +                                 #unary minus and plus
! ~                                 #logical and bitwise negation
**                                  #exponentiation 乘方,即指数运算
<< >>                               #left and right bitwise shifts
<= >= < >                           #comparison
== !=                               #equality and inequality
&                                   #bitwise AND
|                                   #bitwise OR
^                                   #bitwise exclusive OR
&&                                  #logical AND
||                                  #logical OR
expr?expr:expr                      #conditional operator
expr1 , expr2                       #comma

乘法符号有些场景中需要转义

实现算术运算

let var=expression
((var=expression))
var=$[expression]
var=$((expression))
var=$(expr arg1 arg2 ...)
declare -i var=number
echo expression|bc

# 如果不进行转义是无法进行运算的
root@xu-ubuntu:~/scripts# i=3
root@xu-ubuntu:~/scripts# j=4
root@xu-ubuntu:~/scripts# echo i+j
i+j

# 进行转义
root@xu-ubuntu:~/scripts# echo $[i+j]
7
root@xu-ubuntu:~/scripts# echo $((i+j))
7
root@xu-ubuntu:~/scripts# let k=i+j
root@xu-ubuntu:~/scripts# echo $k
7

# expr进行算数。在进行乘法运算时要进行转义，而且必须要有空格
root@xu-ubuntu:~/scripts# expr 3 + 4
7
root@xu-ubuntu:~/scripts# expr 3 \* 4
12

范例：生成 0 - 49 之间随机数

$RANDOM 随机数的范围 0-32767
root@xu-ubuntu:~/scripts# echo $[RANDOM%50]
33
root@xu-ubuntu:~/scripts# echo $[RANDOM%50]
5
root@xu-ubuntu:~/scripts# echo $[RANDOM%50]
44

# 随机字体颜色
root@xu-ubuntu:~/scripts# echo -e "\033[1;$[RANDOM%7+31]mhello\033[0m"
hello

增强型赋值：

-=                # i-=j 相当于 i=i-j
*=
/=
%=
++               # i++,++i   相当于 i=i+1
--               # i--,--i   相当于 i=i-1


root@xu-ubuntu:~/scripts# a=10
root@xu-ubuntu:~/scripts# let a+=20
root@xu-ubuntu:~/scripts# echo $a
30
root@xu-ubuntu:~/scripts# echo $[a+=10]
40
root@xu-ubuntu:~/scripts# echo $((a+=10))
50

i++与++i

# i++先赋值再＋1
root@xu-ubuntu:~/scripts# i=1
root@xu-ubuntu:~/scripts# echo j=i++
j=i++
root@xu-ubuntu:~/scripts# let j=i++
root@xu-ubuntu:~/scripts# echo $i
2
root@xu-ubuntu:~/scripts# echo $j
1

# ++i先＋1再赋值
root@xu-ubuntu:~/scripts# i=1
root@xu-ubuntu:~/scripts# let  j=++i
root@xu-ubuntu:~/scripts# echo $j
2
root@xu-ubuntu:~/scripts# echo $i
2

2、逻辑运算

true、false

bool值	二进制表示	含义
true	1	真
false	0	假

与：&和相与结果为0，和1相与结果保留原值,一假则假，全真才真

或：|和1相或结果为1，和0相或结果保留原值,一真则真,全假才假

异或：

异或的两个值，相同为假，不同为真。两个数字X，Y异或得到结果Z，Z再和任意两者之一X异或，将得

出另一个值Y

root@xu-ubuntu:~/scripts# false
root@xu-ubuntu:~/scripts# echo $?
1
root@xu-ubuntu:~/scripts# true
root@xu-ubuntu:~/scripts# echo $?
0

# 变量互换
root@xu-ubuntu:~/scripts# x=10
root@xu-ubuntu:~/scripts# y=20
root@xu-ubuntu:~/scripts# let x=x^y
root@xu-ubuntu:~/scripts# let y=x^y
root@xu-ubuntu:~/scripts# let x=x^y
root@xu-ubuntu:~/scripts# echo $x $y
20 10

短路运算

短路&&

cmd1&&cmd2

当 cmd1 的结果为 false 时，整个表达式就是 false, cmd2 不参与运算，这就是所谓的短路

当 cmd1 的结果为 true 时，cmd2 才参与运算，看cmd2的结果是真假，在整体判断表达式的真假

短路||

cmd1||cmd2

当 cmd1 的结果为 true 时，整个表达式就是 true, cmd2 不参与运算，这就是所谓的短路

当 cmd1 的结果为 false 时，cmd2 参与运算，根据cmd2的结果再去判断整个表达式的真假

[root@kylin-xu ~]# id tom > /dev/null  2>&1 && echo have || echo no
no

【9】、条件测试命令

条件测试：

判断某需求是否满足，需要由测试机制来实现，专用的测试表达式需要由测试命令辅助完成测试过程，

实现评估布尔声明，以便用在条件性环境下进行执行

若真，则状态码变量 $? 返回0

若假，则状态码变量 $? 返回1

条件测试命令

test expr
[ arg... ]            #同 test
[[ expression ]]      #增加版的[],支持[],支持扩展正则表达式和通配符

# 注意：[] 中的表达式，前后要有空格

[[ expression ]] 用法
== #左侧字符串是否和右侧的PATTERN相同
   #注意:此表达式用于[[ ]]中，PATTERN为通配符
   
=~ #左侧字符串是否能够被右侧的正则表达式的PATTERN所匹配
   #注意: 此表达式用于[[ ]]中为扩展的正则表达式

常用选项：文件判断相关

注意：最终结果由用户对文件的实际权限决定，而非文件属性决定
-a FILE     #如果文件存在则为真
-b FILE     #如果文件为块特殊文件则为真
-c FILE     #如果文件为字符特殊文件则为真
-d FILE     #如果文件为目录则为真
-e FILE     #如果文件存在则为真
-f FILE     #如果文件存在且为常规文件则为真
-g FILE     #如果文件的组属性设置打开则为真
-h FILE     #如果文件为符号链接则为真
-L FILE     #如果文件为符号链接则为真
-k FILE     #如果文件的粘滞 (sticky) 位设定则为真
-p FILE     #如果文件为命名管道则为真
-r FILE     #如果当前用户对文件有可读权限为真
-s FILE     #如果文件存在且不为空则为真
-S FILE     #如果文件是套接字则为真
-t FD       #如果文件描述符在一个终端上打开则为真
-u FILE     #如果文件设置了SUID特殊权限则为真
-w FILE     #如果当前用户对文件有可写权限为真
-x FILE     #如果当前用户对文件有可执行权限为真
-O FILE     #如果当前用户是文件属主为真
-G FILE     #如果当前用户对文件属组为真
-N FILE     #如果文件上次被读取之后修改过则为真
FILE1 -nt FILE2 #如果 file1 文件新于 file2 文件 则为真(根据修改日期)
FILE1 -ot FILE2 #如果 file1 文件旧于 file2 文件则为真
FILE1 -ef FILE2 #如果 file1 文件是 file2 文件的硬链接则为真

[root@kylin-xu ~]# [ -a /root/1.txt  ] && echo exist || echo not
not
[root@kylin-xu ~]# touch 1.txt
[root@kylin-xu ~]# [ -a /root/1.txt  ] && echo exist || echo not
exist

常用选项：字符串判断相关

在比较字符串时，建议放在""中

-z STRING     #判断字符串是否为空，为空则为真
-n STRING     #如果字符串不为空则为真
STRING #同上  

[root@kylin-xu ~]# [[ -z "" ]]
[root@kylin-xu ~]# echo $?
0
[root@kylin-xu ~]# [[ -z "asdadasd" ]]
[root@kylin-xu ~]# echo $?
1
[root@kylin-xu ~]# [[ -n "" ]]
[root@kylin-xu ~]# echo $?
1
[root@kylin-xu ~]# [[ -n "asds" ]]
[root@kylin-xu ~]# echo $?
0


#两个字符串变量比较，一定要有空格，如果没有空格，就变成赋值了
STRING1 = STRING2    #如果 string1 和 string2 字符串相同则为真
STRING1 != STRING2   #如果 string1 和 string2 字符串不相同则为真
STRING1 < STRING2    #只比较第一个字符，以字母表顺序来比较，string1在string2 之前则为真，< 要转义
STRING1 > STRING2    #只比较第一个字符，以字母表顺序来比较，string1在string2 之后则为真, > 要转义

[root@kylin-xu ~]# [ "s" == "s" ] &&  echo true
true
[root@kylin-xu ~]# [ "s" == "s" ] &&  echo true || echo false
true
[root@kylin-xu ~]# [ "s" == "ssss" ] &&  echo true || echo false
false
[root@kylin-xu ~]# [ "s" \< "i" ] &&  echo true || echo false
false
[root@kylin-xu ~]# [ "s" \> "i" ] &&  echo true || echo false
true
[root@kylin-xu ~]# [ "s" != "i" ] &&  echo true || echo false
true
[root@kylin-xu ~]# [ "s" != "s" ] &&  echo true || echo false
false


# 使用正则进行匹配
[root@kylin-xu ~]# [[ $str =~ [a-z]+ ]];echo $?
0
[root@kylin-xu ~]# [[ $str =~ [0-9]+ ]];echo $?
1

常用选项：数学相关

#数字相关 格式 arg1 OP arg2
-eq                    #等于
-ne                    #不等于
-lt                    #小于
-le                    #小于等于
-gt                    #大于
-ge                    #大于等于
#算术表达式比较
==                    #相等
!=                    #不相等
<=                    #小于或等于
>=                    #大于或等于
<                     #小于
>                     #大于


[root@kylin-xu ~]# [ 10 -gt 9 ] &&  echo true || echo false
true
[root@kylin-xu ~]# [ 10 -lt 9 ] &&  echo true || echo false
false
[root@kylin-xu ~]# [ 10 -lt 99 ] &&  echo true || echo false
true
[root@kylin-xu ~]# [ 10 -eq 10 ] &&  echo true || echo false
true
[root@kylin-xu ~]# [ 10 -ne 100 ] &&  echo true || echo false
true
[root@kylin-xu ~]# [ 10 -ne 10 ] &&  echo true || echo false
false

常用选项：其它

-o OPTION                  #如果在shell 中开启了某项，则为真
-v VAR                     #如果变量被设置为为真
-R VAR                     #如果变量被设置且被引用则为真
! EXPR                     #表达式结果取反
EXPR1 -a EXPR2             #如果 expr1 和 expr2 都为真则为真 &&
EXPR1 -o EXPR2             #如果 expr1 和 expr2 有一个为真则为真

[root@kylin-xu ~]# x=100
[root@kylin-xu ~]# test -v x
[root@kylin-xu ~]# [ -v x ] && echo exist || echo "not exists"
exist

【10】、关于{} 和 ()

( cmd1;cmd2;... ) 和 { cmd1;cmd2;...; } 都可以将多个命令组合在一起，批量执行
( list ) 会开启子shell,并且list中变量赋值及内部命令执行后,将不再影响后续的环境
{ list; } 不会开启子shell, 在当前shell中运行,会影响当前shell环境，左侧要有空格，右侧要有; 结束

[root@kylin-xu ~]# echo $BASHPID
553624
# 小括号开启子进程
[root@kylin-xu ~]# (echo $BASHPID ; str="aaa";echo $str);echo $str
592898
aaa
abc

# 大括号不会开子进程
[root@kylin-xu ~]# { echo $BASHPID ; str="aaa";echo $str; };echo $str
553624
aaa
aaa

练习

# 1. 编写脚本 argsnum.sh，接受一个文件路径作为参数；如果参数个数小于1，则提示用户“至少应该给 一个参数”，并立即退出；如果参数个数不小于1，则显示第一个参数所指向的文件中的空白行数
#! /bin/bash
if [ "$#" -lt "1" ];then
        echo "至少应该输入一个变量"
        exit
fi

sed '/^$/p' -n "$1"|wc -l

#编写脚本 hostping.sh，接受一个主机的IPv4地址做为参数，测试是否可连通。如果能ping通，则提 示用户“该IP地址可访问”；如果不可ping通，则提示用户“该IP地址不可访问”
if [[ $1 =~ ^(([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-4])$ ]];then 
        ping $1 -c1 -w1 > /dev/null  2>&1 && echo "该ip地址可以访问" || echo "该IP地址不能访问"
fi

#编写脚本 checkdisk.sh，检查磁盘分区空间和inode使用率，如果超过80%，就发广播警告空间将满
for i in `df -ih | sed '2,$p' -n | awk '{print $(NF-1),$1}' | column -t | sort -rn | awk -F "[% ]+" '$1>=80{print $2}'`; 
do 
        echo $i"inode将满"; 
done

for i in `df -h | sed '2,$p' -n | awk '{print $(NF-1),$1}' | column -t | sort -rn | awk -F "[% ]+" '$1>=80{print $2}'`;
do
    echo $i"空间将满";
done

# 编写脚本 per.sh，判断当前用户对指定参数文件，是否不可读并且不可写
if [ ! -r $1 -a ! -x $1 ];then
    echo "不可读，不可写"
else
    echo "可读或可写"
fi

# 编写脚本 excute.sh ，判断参数文件是否为sh后缀的普通文件，如果是，添加所有人可执行权限，否则提示用户非脚本文件
if [ -f $1 ];then
        chmod +x $1
fi

# 编写脚本 nologin.sh和 login.sh，实现禁止和允许普通用户登录系统
nologin.sh
for i in `awk -F: '$3>=500&&$NF=="/bin/bash"{print $1}' /root/passwd`;
do
    usermod -s /sbin/nologin $i
done

login.sh
for i in `awk -F: '$3>=500&&$NF=="/sbin/nologin"{print $1}' /etc/passwd`; 
do 
    usermod -s /bin/bash $i; 
done

【11】、使用read命令来接受输入

使用read来把输入值分配给一个或多个shell变量，read从标准输入中读取值，给每个单词分配一个变量，所有剩余单词都被分配给最后一个变量，如果变量名没有指定，默认标准输入的值赋值给系统内置变量REPLY

[root@kylin-xu ~]# read
aaa
[root@kylin-xu ~]# echo $REPLY
aaa
[root@kylin-xu ~]# read -p "input:" NAME
input:xxx
[root@kylin-xu ~]# echo $NAME
xxx

管道符左右两侧都是子进程

[root@kylin-xu ~]# echo $BASHPID ; { echo $BASHPID; } | { xargs ;echo $BASHPID; } 
654136
663419
663420

二、bash shell的配置文件

bash shell的配置文件很多，可以分成下面类别

【1】、按照生效范围登录

全局配置：针对所有用户皆有效

/etc/profile
/etc/profile.d/*.sh
/etc/bashrc ------------------------ /etc/bash.bashrc #ubuntu

个人配置：只针对特定用户有效

~/.bash_profile
~/.bashrc

【2】、shell登录方式分类

1、交互式登录

直接通过终端输入账号密码登录
使用 su - UserName 切换的用户

配置文件生效和执行顺序：

#放在每个文件最前
/etc/profile
/etc/profile.d/*.sh
/etc/bashrc 
~/ .bash_ profile
~/ .bashrc
/etc/bashrc                 #此文件执行两次
#放在每个文件最后
/etc/profile.d/*.sh
/etc/bashrc
/etc/profile
/etc/bashrc                #此文件执行两次
~/.bashrc
~/.bash_profile

注意：文件之间的调用关系，写在同一个文件的不同位置，将影响文件的执行顺序

2、非交互式登录

su UserName
图形界面下打开的终端
执行脚本
任何其它的bash实例

执行顺序：

/etc/profile.d/*.sh
/etc/bashrc
~/.bashrc

【3】、编辑配置文件生效

修改profile和bashrc文件后需生效两种方法:

重新启动shell进程
source|. 配置文件

注意：source 会在当前shell中执行脚本,所有一般只用于执行置文件,或在脚本中调用另一个脚本的场景

【4】、Bash退出任务

保存在~/.bash_logout文件中（用户）,在退出登录shell时运行

功能：

创建自动备份
清除临时文件

三、流程控制

【1】、条件判断

1、if语法

if COMMANDS; then COMMANDS; [ elif COMMANDS; then COMMANDS; ]... [ else COMMANDS; ] fi

# if单分支
if [ "$1" = "abc" ];then
    echo "abc"
fi

# if多分枝
str=abc
if [ "$1" = "abc" ];then
    echo "abc"
elif [ "$1" = "def" ];then
    echo "def"
else
    echo "haha"
fi

# if 嵌套
str=abc
if [ "$1" = "abc" ];then
        echo "abc"
        if [ "$2" = "def" ];then
                echo "2 is def"
        else
                echo "2 not def"
        fi
elif [ "$1" = "def" ];then
        echo "def"
else 
        echo "haha"
fi

# 判断操作系统类型
. /etc/os-release 

if [ $ID = "ubuntu" ];then
        echo "is ubuntu"
elif [[ $ID =~ rhel|centos|rocky ]];then
        echo "rhel"
else
        echo "other system"
fi

2、case语句

case $1 in
"abc")
        echo "is abc"
        ;;
"def")
        echo "is def"
        ;;
"xyz")
        echo "is xyz"
        ;;
"123")
        echo "is 123"
        ;;
*)
        echo "any"
        ;;
esac

read -p "" INPUT
INPUT=`echo  $INPUT | tr "A-Z" "a-z"`
case $INPUT in
y|yes)
        echo "is yes"
        ;;
n|no)
        echo "is no"
        ;;
*)
        echo "none"
        ;;
esac

# 文件后缀处理
read -p "请输入文件名：" FILE
FILE=`echo $FILE |sed 's#.*\.(.*$)#\1#g' -r`
case $FILE in
txt)
        echo "is txt file"
        ;;
sh)
        echo "is shell file"
        ;;
conf)
        echo "is configure file"
        ;;
*)
        echo "any"
        ;;
esac

【2】、循环控制

将某代码段重复运行多次，通常有进入循环的条件和退出循环的条件

重复运行次数

循环次数事先已知
循环次数事先未知

常见的循环的命令：for, while, until

1、for循环

执行机制：

依次将列表中的元素赋值给“变量名”; 每次赋值后即执行一次循环体; 直到列表中的元素耗尽，循环结束
如果省略 [in WORDS ... ] ，此时使用位置参数变量 in "$@"

for
循环列表生成方式：

直接给出列表
整数列表：如
返回列表的命令：如 $(COMMAND)
使用glob，如：*.sh
变量引用，如：$@，$*，$#

# 计算1+2+3+...+100 的结果
sum=0
for i in {1..100}
do
        let sum=$i+$sum
done
echo $sum

# 批量创建用户
[ $# -eq 0 ] && { echo "你没有输入变量";exit 1; }

for user in $@;
do
    id $user &> /dev/null  && echo "$user已经存在" || { useradd $user;echo "$user is create";id $user; }
done

# 99乘法表
flag=$[RANDOM%7+31]
for i in {1..9}
do
    for j in {1..9}
    do
        if [ $j -le $i ];then
            let k=$i*$j
            echo -ne "\E[1;${flag}m$j×$i=$k\E[0m\t"
        else
            echo
            break
        fi
    done
done
echo

有若干只兔和鸡，兔和鸡加起来一共有100条腿，请写一个简单的shell算出兔和鸡各多少只可能组合(假设所有的鸡和兔子的腿都是健全的，且兔和鸡至少为1只)

# 暴力破解
count=0
sum=0
num=0
for i in {1..100}
do
    for j in {1..100}
    do
        let num++
        let sum=4*$i+2*$j
        if [ $sum == 100 ];then
            echo "$i只兔子，$j只鸡"
            let count++
        fi
    done
done
echo "共有$count种组合"
echo "循环了$num次"

# 第一次优化  加break
count=0
sum=0
num=0
for i in {1..100}
do
    for j in {1..100}
    do
        let num++
        let sum=4*$i+2*$j
        if [ $sum == 100 ];then
            echo "$i只兔子，$j只鸡"
            let count++
            break
        fi
    done
done
echo "共有$count种组合"
echo "循环了$num次"

# 第二次优化
count=0
sum=0
num=0
for i in {1..25}
do
    for j in {1..50}
    do
        let num++
        let sum=4*$i+2*$j
        if [ $sum == 100 ];then
            echo "$i只兔子，$j只鸡"
            let count++
            break
        fi
    done
done
echo "共有$count种组合"
echo "循环了$num次"

# 生成三角形
read -p "请输入三角形行数：" line
let num=$line*2-1
for i  in `seq $line`
do
        let star=$i*2-1
        let space=($num-$star)/2
        if [ $space == 0 ];then
                for j in `seq $num`
                do
                        echo -n "*"
                done
        else
                for k in `seq $space`
                do
                        echo -n " "
                done
                let x=$num-$space*2
                for m in `seq $x`
                do
                        echo -n "*"
                done
        fi
        echo 
done
请输入三角形行数：10
         *
        ***
       *****
      *******
     *********
    ***********
   *************
  ***************
 *****************
*******************

# 进度条
root@xu-ubuntu:~/scripts# for ((i = 0; i <= 100; ++i)); do printf "\e[4D%3d%%" $i;sleep 0.1s; done;echo
100%

2、while循环

while CONDITION; do COMMANDS; done

while CONDITION; do
循环体
done

while CONDITION
do
 循环体
done

说明：

CONDITION：循环控制条件；进入循环之前，先做一次判断；每一次循环之后会再次做判断；条件为

“true”，则执行一次循环；直到条件测试状态为“false”终止循环，因此：CONDTION一般应该有循环控

制变量；而此变量的值会在循环体不断地被修正

进入条件：CONDITION为 true

退出条件：CONDITION为 false

# 死循环
while true; do
  循环体
done

while : ; do
  循环体
done

# 计算1-100
root@xu-ubuntu:~/scripts# i=1
root@xu-ubuntu:~/scripts# while [ $i -le 100 ]; do let sum=$sum+$i;let i++; done
root@xu-ubuntu:~/scripts# echo $sum
5050

国际象棋棋盘

color=41
for i in {1..8}
do
        for j in {1..8}
        do
                echo -ne "\E[0${color}m  \E[0m"
                if [ $color -eq 41 ];then
                        color=43
                else
                        color=41
                fi
        done
        if [ $color -eq 41 ];then
            color=43
        else
            color=41
        fi
        echo
done

while特殊用法，while read

while 循环的特殊用法，遍历文件或文本的每一行

while read line; do
循环体
done < /PATH/FROM/SOMEFILE

while read line
do
        echo $line"---------"
done < /etc/passwd

3、continue和break

continue：结束本次循环，进入下一次循环

break：结束当前循环，跳出当前的循环体

四、函数

【1】、函数定义

函数 function

是由若干条shell命令组成的语句块，实现代码重用和模块化编程

它与shell程序形式上是相似的，不同的是它不是一个单独的进程，不能独立运行，而是shell程序的一部分

函数和shell程序区别

Shell程序在子Shell中运行
函数在当前Shell中运行。因此在当前Shell中，函数可对shell中变量进行修改

#语法一
func_name(){
 ...函数体...
}

#语法二
function func_name {
 ...函数体...
}

#语法三
function func_name(){
 ...函数体...
}

func1(){
    echo "func1"
}

function func2(){
    echo  "func2"
}

function func3 {
    echo "func3"
}

func1
func2
func3

【2】、函数调用

函数的调用方式

可在交互式环境下定义函数
可将函数放在脚本文件中作为它的一部分
可放在只包含函数的单独文件中

调用：函数只有被调用才会执行，通过给定函数名调用函数，函数名出现的地方，会被自动替换为函数代码

函数的生命周期：被调用时创建，返回时终止

# 交互式环境下
root@xu-ubuntu:~/scripts# test(){
> echo "hanshu"
> }
root@xu-ubuntu:~/scripts# test
hanshu

root@xu-ubuntu:~/scripts# function test1(){
> echo hanshu1
> }
root@xu-ubuntu:~/scripts# test1
hanshu1

root@xu-ubuntu:~/scripts# function test2 {
> echo hanshu3
> }
root@xu-ubuntu:~/scripts# test2
hanshu3


# 脚本文件中
function test1(){
        echo hanshu1
}
function test2 {
        echo hanshu2
}
test3(){
        echo hanshu3
}

test1
test2
test3
root@xu-ubuntu:~/scripts# bash fun.sh 
hanshu1
hanshu2
hanshu3

# 单独文件
fun.sh文件
function test1(){
        echo hanshu1
}
function test2 {
        echo hanshu2
}
test3(){
        echo hanshu3
}

fun1.sh文件
. fun.sh
test1
test2
test3

root@xu-ubuntu:~/scripts# bash fun1.sh 
hanshu1
hanshu2
hanshu3

【3】、函数嵌套

# 在使用函数嵌套时一定要保证能够有一个出口，能有一个结束的地方，否则程序会不断地堆栈，报错

function test1(){
    echo hanshu1
}
function test2 {
    echo hanshu2
}
test3(){
    echo hanshu3
    test2
}
test3

root@xu-ubuntu:~/scripts# bash fun.sh
hanshu3
hanshu2

【4】、函数返回值

return

函数默认返回值是函数体中最后一条命令的退出状态码；

也可以使用return 自定义函数的返回值，在函数中使用 return，return 之后的语句将不会被执行

return 语句	返回值
return	由return前面一行的命令执行结果决定
return 0	无错误返回
return 1~255	有错误返回

function re1(){
        echo aaa
        return
        echo bbb
}

function re2 {
        echooo ccc
        return
}

function re3 {
        echo ddd
        return 123
}

re1
echo "re1函数的返回值：$?"
echo "==============================="
re2
echo "re2函数的返回值：$?"
echo "==============================="
re3
echo "re3函数的返回值：$?"
echo "==============================="
root@xu-ubuntu:~/scripts# bash return.sh 
aaa
re1函数的返回值：0
===============================
return.sh: line 21: echooo: command not found
re2函数的返回值：127
===============================
ddd
re3函数的返回值：123
===============================

return和exit的区别

return 只会中断函数执行，但exit 会中断整个脚本的执行

【5】、函数参数

函数可以接受参数：

传递参数给函数：在函数名后面以空白分隔给定参数列表即可，如：testfunc arg1 arg2 ...
在函数体中当中，可使用$1, $2, ...调用这些参数；还可以使用$@, $*, $#等特殊变量

function canshu(){
    echo -e "\E[1;$2m$1\E[0m"
    return
}

yanse=$[RANDOM%7+31]
canshu "nihao" $yanse
echo "canshu的返回值是：$?"

function canshu(){
        for i in $*
        do
                echo $i
        done
}

canshu $*

root@xu-ubuntu:~/scripts# bash hanshucanshu.sh 1 2 3 4 5 6
1
2
3
4
5
6

【6】、函数变量

变量作用域

变量类型	特点
普通变量	只在当前shell进程中有效，函数外定义，可以在函数内修改
环境变量	当前shell和子shell有效
本地变量	作用域在函数内，函数结束会被自动销毁，只能在函数内定义

在函数中定义本地变量

local NAME=VALUE

# 普通变量可以在函数中被修改
root@xu-ubuntu:~/scripts# cat func1.sh 
#!/bin/bash

function test1(){
        echo "============test1 start============"
        echo $var
        var=789
        echo $var
        echo "============test1 end============"
}
root@xu-ubuntu:~/scripts# cat var.sh 
#!/bin/bash

. func1.sh

var=123

function test2(){
        echo "==========test2 start============"
        echo $var
        var=456
        echo $var
        echo "==========test2 end============"
}
function test3(){
        echo "==========test3 start============"
        echo $var
        var=147
        echo $var
        echo "==========test3 end============"
}

echo $var
test1
echo $var
test2
echo $var
test3
echo $var

root@xu-ubuntu:~/scripts# bash var.sh 
123
============test1 start============
123
789
============test1 end============
789
==========test2 start============
789
456
==========test2 end============
456
==========test3 start============
456
147
==========test3 end============
147

# 本地变量只作用在函数内
var=123

function test2(){
        echo "==========test2 start============"
        echo $var
        local var=456
        echo $var
        echo "==========test2 end============"
}
function test3(){
        echo "==========test3 start============"
        echo $var
        local var=147
        echo $var
        echo "==========test3 end============"
}

echo $var
test2
echo $var
test3
echo $var
# 函数中定义的var 只能在函数中被调用，作用域只在函数内
root@xu-ubuntu:~/scripts# bash var.sh 
123
==========test2 start============
123
456
==========test2 end============
123
==========test3 start============
123
147
==========test3 end============
123

【7】、函数递归

函数递归：

函数直接或间接调用自身，注意递归层数，可能会陷入死循环

递归特点:

函数内部自已调用自已
必须有结束函数的出口语句，防止死循环

# 递归实现阶乘
function jiecheng(){
    if [ $1 -eq 1 ];then
        echo 1
    else
        echo $[$1 * $(jiecheng $[$1-1])]
    fi 
}
jiecheng $1

# 斐波那契数列第N项的值
fib(){
 if [ $1 -gt 1 ];then
     echo $[ $(fib $[$1-1]) + $(fib $[$1-2]) ]
 else
     echo $1
 fi
}
fib $1

fork炸弹
fork 炸弹是一种恶意程序，它的内部是一个不断在 fork 进程的无限循环，实质是一个简单的递归程序。
由于程序是递归的，如果没有任何限制，这会导致这个简单的程序迅速耗尽系统里面的所有资源

:(){ :|:& };:
bomb(){ bomb | bomb & };bomb

五、其他脚本相关工具

【1】、trap信号捕捉

trap 命令可以捕捉信号，修改信号原来的功能，实现自定义功能

在脚本或程序的执行过程中，我们可以通过发送信号的方式，打断或终止程序的执行过程，为了避免这种情况，我们可以使用信号捕捉，来自定义信号处理。

#常用选项
-l #显示所有信号
-p #显示所有自定义的信号


trap 'command' signal #自定义指定信号的处理方式
trap '' signal #忽略指定的信号
trap '-' signal #恢复信号默认操作
trap func EXIT #退出时执行func

显示所有的信号

root@xu-ubuntu:~/scripts# trap -l
 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL       5) SIGTRAP
 6) SIGABRT      7) SIGBUS       8) SIGFPE       9) SIGKILL     10) SIGUSR1
11) SIGSEGV     12) SIGUSR2     13) SIGPIPE     14) SIGALRM     15) SIGTERM
16) SIGSTKFLT   17) SIGCHLD     18) SIGCONT     19) SIGSTOP     20) SIGTSTP
。。。

信号的3种表示方法

3) SIGQUIT
3          #信号ID
SIGQUIT    #完整写法，大小写都支持
QUIT       #简短写法，大小写都支持

trap "echo '捕捉到了 ctrl+c信号'" SIGINT
trap "echo '捕捉到了 ctrl+\信号'" quit
trap -p
for i in {1..15};do
 sleep 1
 echo $i
done

trap '' int
trap -p

for i in {16..30};do
 sleep 1
 echo $i
done

trap '-' int
trap -p

for i in {31..45};do
 sleep 1
 echo $i
done

【2】、创建临时文件mktemp

mktemp 命令用于创建并显示临时文件，可避免冲突

#常用选项
-d|--directory          #创建目录
-u|--dry-run            #只输出命令，不执行
-p DIR|--tmpdir[=DIR]   #指明临时文件所存放目录位置
-t                      #将文件保存到$TMPDIR 定义的目录中，如果该变量未定义，则保存到/tmp 目录中

root@xu-ubuntu:~/scripts# mktemp 
/tmp/tmp.mt31TMmcSK

# 如果指定了文件名，则后面一定要有X，至少要3个，X会被替换成随机串
root@xu-ubuntu:~/scripts# mktemp XXXX
vrWA
root@xu-ubuntu:~/scripts# ll vrWA 
-rw------- 1 root root 0 Dec  2 10:30 vrWA
root@xu-ubuntu:~/scripts# mktemp testXXXX
testFo7g
root@xu-ubuntu:~/scripts# ll testFo7g 
-rw------- 1 root root 0 Dec  2 10:30 testFo7g

# 赋值给变量
root@xu-ubuntu:~/scripts# file=`mktemp`
root@xu-ubuntu:~/scripts# echo $?
0
root@xu-ubuntu:~/scripts# echo $file
/tmp/tmp.Bz19OE4SHV
root@xu-ubuntu:~/scripts# echo 123 > $file
root@xu-ubuntu:~/scripts# cat $file
123
root@xu-ubuntu:~/scripts# ll $file
-rw------- 1 root root 4 Dec  2 10:31 /tmp/tmp.Bz19OE4SHV

# 创建目录
root@xu-ubuntu:~/scripts# mktemp -d 
/tmp/tmp.N1GOey7oZo
root@xu-ubuntu:~/scripts# ll /tmp/tmp.N1GOey7oZo -d
drwx------ 2 root root 4096 Dec  2 10:33 /tmp/tmp.N1GOey7oZo/

【3】、安装复制文件install

install 功能相当于cp，chmod，chown，chgrp ，mkdir 等相关工具的集合

#常用选项
-m|--mode=MODE          #指定权限，默认755
-v|--verbose            #显示过程
-o|--owner=OWNER        #指定属主
-g|--group=GROUP        #指定属组
-d|--directory DIR      #指定目录，如果不存在就创建

#如果目录不存在，则创建目录，并将权限设成777，如果目录存在，则修改其权限
root@xu-ubuntu:~/scripts# install -m 777 -d testdir
root@xu-ubuntu:~/scripts# ll testdir/ -d
drwxrwxrwx 2 root root 4096 Dec  2 10:35 testdir/

root@xu-ubuntu:~/scripts# install -m 755 -d testdir
root@xu-ubuntu:~/scripts# ll testdir/ -d
drwxr-xr-x 2 root root 4096 Dec  2 10:35 testdir/



#将文件复制到指定目录，并指定属主属组，权限，可以一步完成
root@xu-ubuntu:~/scripts# install -m 777 -o xu -g xu func1.sh /tmp/ 
root@xu-ubuntu:~/scripts# ll /tmp/func1.sh 
-rwxrwxrwx 1 xu xu 483 Dec  2 10:38 /tmp/func1.sh*

六、数组

【1】、数组定义

变量：存储单个元素的内存空间

数组：存储多个元素的连续的内存空间，相当于多个变量的集合

数组名和索引

索引的编号从0开始，属于数值索引
索引可支持使用自定义的格式，而不仅是数值格式，即为关联索引，bash 4.0版本之后开始支持
bash的数组支持稀疏格式（索引不连续）

【2】、数组声明

#普通数组可以不事先声明,直接使用
declare -a ARRAY_NAME
#关联数组必须先声明,再使用
declare -A ARRAY_NAME

两者不能相互转换

【3】、数组赋值

# 一次只赋值一个元素
root@xu-ubuntu:~/scripts# num[0]=0
root@xu-ubuntu:~/scripts# num[1]=1
root@xu-ubuntu:~/scripts# echo ${num[0]}
0

# 一次性给所有元素赋值
root@xu-ubuntu:~/scripts# title=("ceo" "coo" "cto")
root@xu-ubuntu:~/scripts# echo ${title[1]}
coo
root@xu-ubuntu:~/scripts# echo ${title[2]}
cto

# 间断赋值
root@xu-ubuntu:~/scripts# week=([0]="sun" [4]="thur")
root@xu-ubuntu:~/scripts# echo ${week[0]}
sun
root@xu-ubuntu:~/scripts# echo ${week[1]}

root@xu-ubuntu:~/scripts# echo ${week[4]}
thur

# 使用read接收赋值
root@xu-ubuntu:~/scripts# read -a  test
a b c d 
root@xu-ubuntu:~/scripts# echo ${test[1]}
b

【4】、显示所有的数组

root@xu-ubuntu:~/scripts# declare -a
declare -a BASH_ARGC=([0]="0")
declare -a BASH_ARGV=()
declare -a BASH_COMPLETION_VERSINFO=([0]="2" [1]="11")
declare -a BASH_LINENO=()
declare -a BASH_REMATCH=()
declare -a BASH_SOURCE=()
declare -ar BASH_VERSINFO=([0]="5" [1]="1" [2]="16" [3]="1" [4]="release" [5]="x86_64-pc-linux-gnu")
declare -a DIRSTACK=()
declare -a FUNCNAME
declare -a GROUPS=()
declare -a PIPESTATUS=([0]="0")
declare -a num=([0]="0" [1]="1")
declare -a test=([0]="a" [1]="b" [2]="c" [3]="d")
declare -a title=([0]="ceo" [1]="coo" [2]="cto")
declare -a week=([0]="sun" [4]="thur")

【5】、数组引用

# 引用特定的数组元素
#如果省略[INDEX]表示引用下标为0的元素
${ARRAY_NAME[INDEX]}

root@xu-ubuntu:~/scripts# arr=({01..10})
root@xu-ubuntu:~/scripts# echo ${arr[2]}
03
root@xu-ubuntu:~/scripts# echo ${arr[4]}
05
# 如果不加index，默认是输出第一个值
root@xu-ubuntu:~/scripts# echo ${arr}
01

# 引用数组所有的元素
root@xu-ubuntu:~/scripts# echo ${arr[*]}
01 02 03 04 05 06 07 08 09 10
root@xu-ubuntu:~/scripts# echo ${arr[@]}
01 02 03 04 05 06 07 08 09 10

# 遍历数组
root@xu-ubuntu:~/scripts# arr=({01..05})
root@xu-ubuntu:~/scripts# for i in ${arr[*]};do echo $i ; done
01
02
03
04
05
root@xu-ubuntu:~/scripts# for i in ${arr[@]};do echo $i ; done
01
02
03
04
05

# 取出下标
root@xu-ubuntu:~/scripts# echo ${!arr[*]}
0 1 2 3 4
root@xu-ubuntu:~/scripts# unset arr[2]  # 取消变量
root@xu-ubuntu:~/scripts# echo ${!arr[*]}
0 1 3 4
root@xu-ubuntu:~/scripts# for i in ${!arr[@]};do echo "$i--->${arr[$i]}" ; done
0--->01
1--->02
3--->04
4--->05

# 数组长度
root@xu-ubuntu:~/scripts# echo ${#arr[*]}
4

【6】、删除数组

删除数组中的某元素，会导致稀疏格式

unset ARRAY[INDEX]

删除整个数组

unset ARRAY

【7】、数组数据处理

1、数组切片

root@xu-ubuntu:~/scripts# arr=({a..d})
root@xu-ubuntu:~/scripts# echo ${arr[*]}
a b c d
root@xu-ubuntu:~/scripts# echo ${arr[*]:1:2}
b c

# 从1位置开始取到末尾
root@xu-ubuntu:~/scripts# echo ${arr[*]:1}
b c

2、数组追加元素

root@xu-ubuntu:~/scripts# arr[4]=1234
root@xu-ubuntu:~/scripts# echo ${arr[4]}
1234

root@xu-ubuntu:~/scripts# arr[${#arr[*]}]=haha
root@xu-ubuntu:~/scripts# arr[${#arr[*]}]=haha
root@xu-ubuntu:~/scripts# arr[${#arr[*]}]=haha
root@xu-ubuntu:~/scripts# arr[${#arr[*]}]=haha
root@xu-ubuntu:~/scripts# echo ${arr[*]}
a b c d 1234 haha haha haha haha

【8】、关联数组

关联数组与普通数组区别：

关联数组要先声明，才能使用，普通数组可以不用声明
关联数组可以自定义下标，普通数组必须用数

declare -A ARRAY_NAME 
ARRAY_NAME=([idx_name1]='val1' [idx_name2]='val2‘...)

root@xu-ubuntu:~/scripts# declare -A arr1
root@xu-ubuntu:~/scripts# arr1[name]="xu"
root@xu-ubuntu:~/scripts# arr1[age]=18
root@xu-ubuntu:~/scripts# arr1[gender]=男
root@xu-ubuntu:~/scripts# echo $arr1

root@xu-ubuntu:~/scripts# echo ${arr1[name]}
xu
root@xu-ubuntu:~/scripts# echo ${arr1[gender]}
男
root@xu-ubuntu:~/scripts# declare -A arr2

# 一次性定义完成
root@xu-ubuntu:~/scripts# arr2=([name]="aaa" [age]=18 [gender]="男")
root@xu-ubuntu:~/scripts# echo ${arr2[name]}
aaa

# 取出index
root@xu-ubuntu:~/scripts# echo ${!arr1[*]}
gender age name
root@xu-ubuntu:~/scripts# echo ${!arr2[*]}
gender age name
# 单独取出index是，顺序是不一定的，也就是说如果我们根据index遍历关联数组的结果顺序不是按照我们定义时的去输出
root@xu-ubuntu:~/scripts# for i in ${!arr2[*]} ;do echo "$i---${arr2[$i]}" ;done
gender---男
age---18
name---aaa

【9】、范例

# 生成10个随机数保存于数组中，并找出其最大值和最小值
function SORT(){
    temp=0
    for j in ${!arr[*]}
    do
        let k=$j+1
        for k  in ${!arr[*]}
        do
            if [ ${arr[$j]} -gt ${arr[$k]} ];then
                temp=${arr[$j]}
                arr[$j]=${arr[$k]}
                arr[$k]=$temp
            fi
        done
    done
    echo "max in arr is ${arr[1]}"
    echo "min in arr is ${arr[$j]}"
}

for i in `seq 10`
do
    arr[$i]=$RANDOM
done
echo "arr is ${arr[*]}"
SORT arr

七、字符串处理

【1】、字符串切片

1、基于偏移量取字符串

# #返回字符串变量var的字符的长度,一个汉字算一个字符
root@xu-ubuntu:~/scripts# echo ${#str}
6

root@xu-ubuntu:~/scripts# str=123456
#返回字符串变量var中从第offset个字符后（不包括第offset个字符）的字符开始，到最后的部分，offset的取值在0 到 ${#var}-1 之间(bash4.2后，允许为负值)
root@xu-ubuntu:~/scripts# echo ${str:2}
3456
root@xu-ubuntu:~/scripts# echo ${str:2:2}
34

#取字符串的最右侧几个字符, 注意：冒号后必须有一空白字符
root@xu-ubuntu:~/scripts# echo ${str: -2}
56
root@xu-ubuntu:~/scripts# echo ${str: 2: -2}
34

2、基于模式取子串

#其中word可以是指定的任意字符,自左而右，查找var变量所存储的字符串中，第一次出现的word, 删除字符串开头至第一次出现word字符串（含）之间的所有字符,即懒惰模式,以第一个word为界删左留右
${var#*word}
#从var变量的值中删除以word开头的部分
${var#word}
#同上，贪婪模式，不同的是，删除的是字符串开头至最后一次由word指定的字符之间的所有内容,即贪婪模式,以最后一个word为界删左留右
${var##*word}
${var##word}

root@xu-ubuntu:~/scripts# echo $str
abcd1234abcd1234
root@xu-ubuntu:~/scripts# echo ${str#abc}
d1234abcd1234
root@xu-ubuntu:~/scripts# echo ${str#*abc}
d1234abcd1234
root@xu-ubuntu:~/scripts# echo ${str#*cd}
1234abcd1234

# 贪婪匹配
root@xu-ubuntu:~/scripts# echo ${str##*cd}
1234
root@xu-ubuntu:~/scripts# echo ${str##*abcd}
1234

#其中word可以是指定的任意字符,功能：自右而左，查找var变量所存储的字符串中，第一次出现的word, 删除字符串最后一个字符向左至第一次出现word字符串（含）之间的所有字符,即懒惰模式,以从右向左的第一个word为界删右留左

${var%word*}
${var%word}

#同上，只不过删除字符串最右侧的字符向左至最后一次出现word字符之间的所有字符,即贪婪模式,以从右向左的最后一个word为界删右留左
${var%%word*}
${var%%word}

[root@web01 ~]# str=abcd1234abcd12345
[root@web01 ~]# echo $str
abcd1234abcd12345
[root@web01 ~]# echo ${str%abc*}
abcd1234
[root@web01 ~]# echo ${str%345}
abcd1234abcd12
[root@web01 ~]# echo ${str%%34}
abcd1234abcd12345
[root@web01 ~]# echo ${str%%34*}
abcd12

【2】、查找替换删除

#查找var所表示的字符串中，第一次被pattern所匹配到的字符串，以substr替换之，懒惰模式
${var/pattern/substr}
#查找var所表示的字符串中，所有能被pattern所匹配到的字符串，以substr替换之，贪婪模式
${var//pattern/substr}
#查找var所表示的字符串中，行首被pattern所匹配到的字符串，以substr替换之
${var/#pattern/substr}
#查找var所表示的字符串中，行尾被pattern所匹配到的字符串，以substr替换之
${var/%pattern/substr}

[root@ubuntu2204 ~]# str=abcd1234abcd12345
#从左到右，替换第一个123为XYZ
[root@ubuntu2204 ~]# echo ${str/123/XYZ}
abcdXYZ4abcd12345
#从左到右，替换所有123为XYZ
[root@ubuntu2204 ~]# echo ${str//123/XYZ}
abcdXYZ4abcdXYZ45
#替换行首的abc为XYZ
[root@ubuntu2204 ~]# echo ${str/#abc/XYZ}
XYZd1234abcd12345
#替换行尾的12345为XYZ
[root@ubuntu2204 ~]# echo ${str/%12345/XYZ}
abcd1234abcdXYZ

# 删除就是将查找到的替换为空
#删除var表示的字符串中第一次被pattern匹配到的字符串，懒惰模式
${var/pattern}
#删除var表示的字符串中所有被pattern匹配到的字符串，贪婪模式
${var//pattern}
#删除var表示的字符串中所有以pattern为行首匹配到的字符串
${var/#pattern}
#删除var所表示的字符串中所有以pattern为行尾所匹配到的字符串
${var/%pattern}

[root@ubuntu2204 ~]# str=abcd1234abcd12345
#从左到右删除第一个1234
[root@ubuntu2204 ~]# echo ${str/1234}
abcdabcd12345
#从左到右删除所有1234
[root@ubuntu2204 ~]# echo ${str//1234}
abcdabcd5
#删除行首abcd
[root@ubuntu2204 ~]# echo ${str/#abcd}
1234abcd12345
#删除行尾12345
[root@ubuntu2204 ~]# echo ${str/%12345}
abcd1234abcd

【3】、字符大小写转换

#把var中的所有小写字母转换为大写
${var^^}
#把var中的所有大写字母转换为小写
${var,,}

[root@web01 ~]# str=abcd1234ABCD12345
[root@web01 ~]# echo ${str^^}
ABCD1234ABCD12345
[root@web01 ~]# echo ${str,,}
abcd1234abcd12345

使用Nginx搭建流媒体服务器

作者: wenmo8
时间: 2024-12-03
分类: 其它
评论

什么是流媒体服务器
Nginx如何实现流媒体服务器
为Nginx安装nginx-http-flv-module
配置流媒体服务器
使用OBS推流
使用VLC拉RTMP
使用flv.js拉流
使用jls.js拉m3u8
总结
引用

什么是流媒体服务器

流媒体服务器（Streaming Media Server）是一种用于存储和传输音频、视频、直播等媒体内容的服务器软件。它通过网络将媒体文件实时传输给用户，而不需要用户先下载完整文件。流媒体服务器支持按需播放、实时广播等功能，常见的使用场景包括在线视频、音频点播、直播视频等。

视频流媒体数据传输往往对流媒体服务器编解码能力和协议转换有要求，因为不同的编码格式和不同的协议适用的场景不同。例如，RTMP协议延迟低，但是web浏览器不支持，需要将其转为HLS或者是FLV才能进行播放。

Nginx如何实现流媒体服务器

Nginx作为web服务器的一种，本身关注点在静态资源代理、正反向代理方面，实现作为流媒体服务器使用是依赖“插件”来扩展。例如：nginx-rtmp-module插件和nginx-http-flv-module插件。

为Nginx安装nginx-http-flv-module

概述

nginx中的模块虽然就是类似插件的概念，但是它无法像VsCode那样轻松的安装扩展。针对像 nginx-http-flv-module 这样的 nginx 模块，仅能通过重新编译 nginx 源码的方式完成“插件的安装”。

nginx-http-flv-module 基于 nginx-rtmp-module 二次开发，拥有 nginx-rtmp-module 全部的功能，同时具备HTTP-FLV播放，这个功能就很Nice，有了这个就可以实现在浏览器中观看直播，针对推送端无需额外的配置，一个直播流推送到流媒体服务器，直接可以输出多种流，包括：rtmp、hls、flv，rtmp用于在桌面应用程序中播放，hls和flv用于在浏览器中播放，当然hls也可以在桌面应用程序中播放，在浏览器播放方式中flv的画面延迟明显由于hls。

需要注意的是 nginx-http-flv-module 要求nginx的版本大于等于1.2.6。由于nginx-http-flv-module包含了 nginx-rtmp-module 模块，所以不可将 nginx-http-flv-module 和 nginx-rtmp-module 同时编译，当我们编译完 nginx-http-flv-module 之后，其实就已经拥有了 nginx-rtmp-module 的完整功能。

流程

查看当前nginx 的版本(假设安装位置为：/usr/local/nginx)
下载当前版本nginx的源代码
下载 nginx-http-flv-module 模块源代码
重新编译nginx并追加nginx-http-flv-module
将新编译好的 nginx 可执行文件拷贝到当前nginx安装目录（/usr/local/nginx/sbin）

操作步骤

使用如下命令查看当前已经安装的nginx的版本


[root@bogon sbin]# ./nginx -V nginx version: nginx/1.18.0 built by gcc 4.8.5 20150623 (Red Hat 4.8.5-44) (GCC) built with OpenSSL 1.0.2k-fips 26 Jan 2017 TLS SNI support enabled configure arguments: --prefix=/usr/local/nginx --with-http_dav_module --with-http_stub_status_module --with-http_addition_module --with-http_sub_module --with-http_flv_module --with-http_mp4_module --with-pcre --with-http_ssl_module --with-http_gzip_static_module

V：小v仅打印版本号，大V既打印版本号，也打印扩展信息，这里要使用大V
拿到版本号的目的是待会要下载该版本的源代码
注意保存打印内容中的 arguments 后面的内容，后面编译会用到

下载 nginx 源码和 nginx-http-flv-module 的源码，示例代码如下：


wget http://nginx.org/download/nginx-1.18.0.tar.gz tar -zxvf nginx-1.18.0.tar.gz git clone https://github.com/winshining/nginx-http-flv-module.git

进入nginx源码目录，使用如下命令重新编译nginx：


./configure --prefix=/usr/local/nginx --with-http_dav_module --with-http_stub_status_module --with-http_addition_module --with-http_sub_module --with-http_flv_module --with-http_mp4_module --with-pcre --with-http_ssl_module --with-http_gzip_static_module --add-module=/home/cml/nginx-http-flv-module make

使用configure 配置编译环境
将上面保存的“arguments 后面的内容”作为configure 的第一个参数
第二个参数为 --add-module=/home/cml/nginx-http-flv-module ，即添加一个模块，模块源代码位置是 /home/cml/nginx-http-flv-module
使用make命令执行编译编译

编译成功后，在 objs中会有一个名为nginx的可执行文件，这个就是编译好的nginx了，里面包含已经安装的功能和新增加的nginx-rtmp-module，将这个可执行文件拷贝到当前安装目录（/usr/local/nginx/sbin）中就可以了。

注意拷贝之前需要停止nginx，否则会报当前文件繁忙，无法覆盖的错误。

通过如下命令验证安装是否正常：


nginx -V

若打印的信息中包含nginx-http-flv-module，说明安装好了。

配置流媒体服务器

当安装好了 nginx-http-flv-module 之后，就可以创建流媒体应用了。所谓的创建流媒体应用其实就是编写 nginx 的配置文件，如果需要创建一个名为 live 的流媒体应用，那么可以在 nginx.conf 中做如下配置



#以下内容放可在 nginx.conf 的最后，rtmp 配置块为顶级配置块
rtmp_auto_push on ;

rtmp {
   server {
        listen 1935; #监听的端口
        notify_method get;
        chunk_size 4000;
        application live { #rtmp推流请求路径
            live on;
            # 添加 hls 支持
            hls on;
            hls_path /usr/local/nginx/html/hls;
            hls_fragment 3;
            hls_playlist_length 60;

            # 允许从任何源push 流
            allow publish  all ;
            # 允许从任何地方来播放流
            allow play all;
            # 20s内没有push，就断开连接
            drop_idle_publisher 20s ;
        }
 }
}

listen 1935：指定流媒体服务器的运行端口
live ：为流媒体应用的应用的名称，也即流媒体应用的唯一标识
live on ：添加直播的支持
hls_path：指定生成的m3u8文件的位置

之后就是创建http-flv端点和hls端点了，目的是让直播流可以在http协议上面传输直播画面。
若不创建，将仅可以使用rtmp协议拉流，即rtmp://ip:1935/live/stream_no；若创建了就可以使用hls或者flvjs来拉流播放了。

创建http-flv端点和hls端点同样是编辑nginx.conf来实现，如下示例配置：



 server {
        listen  82;
        server_name  rtmpserver;

        # 创建hls端点
        location /hls {
            add_header 'Access-Control-Allow-Origin' '*' ;
            add_header 'Access-Control-Allow-Credentials' 'true' ;
            types {
                application/vnd.apple.mpegurl m3u8 ;
                video/mp2t ts;
            }
            alias /usr/local/nginx/html/hls;
            expires -1 ;
            add_header 'Cache-Control' 'no-cache';
        }

        # 创建 flv 端点
        location /flv {
                flv_live on ;
                chunked_transfer_encoding on;
                add_header 'Access-Control-Allow-Origin' '*';
                add_header 'Access-Control-Allow-Credentials' 'true';
        }
    }

listen 82 ：指定 hls端点和flv端点的监听端口，此端口可以自定义，针对hls端点和flv端点可以分开设置不同的监听端口
hls端点的标识为 hls，此标识可以自定义，拉流的时候会用到
alias：指定m3u8文件的访问路径，需要和 "创建流媒体应用"中的hls_path配置保持一致
flv端点的标识为flv，此标识可以自定义，拉流的时候会用到

使用OBS推流

OBS 是非常成熟的软件了，安装参考官网：
https://obsproject.com/

假设约定的推拉流地址为 rtmp://192.168.1.115:1935/live/room-1

设置直播流来源为视频采集设备和浏览器，其中视频采集设备就是笔记本的摄像头，浏览器为OBS内置浏览器并打开
https://time.is/zh/
这个网址。最终的直播画面就是两个采集终端的画面叠加在一起，底部是一个网址，网页中有一个时钟，顶部是摄像头。

设置直播服务器和推流码：

服务器：即流媒体应用的地址，即 rtmp://192.168.1.115:1935/live
推流码：即当前推流唯一标识，可以随意指定，保证推拉流地址一致即可，示例为： room-1

点击开始直播，OBS就开始向流媒体服务器推流了。

此时就可以使用拉流客户端拉取直播画面了，同时hls_path 下将生成m3u8文件，文件名称为 room-1.m3u8。

使用VLC拉RTMP

VLC是非常成熟的软件了，安装参考官网。

VLC拉流使用rtmp进行，拉流地址为：


rtmp://192.168.1.115:1935/live/room-1

使用flv.js拉流

基于flv.js编写一个视频播放器，新建一个html文件，示例代码如下：

flvjs_player.html


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>FLV.js Example</title>
    <script src="https://cdn.jsdelivr.net/npm/flv.js@1.5.0/dist/flv.min.js"></script>
</head>
<body>
    <h1>FLV.js Player</h1>
    <video id="videoElement" width="640" height="360" controls></video>
    <button id="playButton">Click to Play Video</button>
    <script>
        // Check if the browser supports FLV.js
        if (flvjs.isSupported()) {
            var videoElement = document.getElementById('videoElement');
            var flvPlayer = flvjs.createPlayer({
                type: 'flv',
                url: 'http://192.168.1.115:82/flv?port=1935&app=live&stream=room-1'  // Replace with your FLV video URL
            });
            flvPlayer.attachMediaElement(videoElement);
            flvPlayer.load();
            // Play video on button click
            document.getElementById('playButton').addEventListener('click', function() {
                flvPlayer.play().catch(function(error) {
                    console.error('Error playing video:', error);
                });
            });
        } else {
            console.error('FLV.js is not supported in this browser.');
        }
    </script>
</body>
</html>

使用jls.js拉m3u8

基于hls.js编写一个视频播放器，新建一个html文件，示例代码如下：

m3u8_play.html


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>HLS.js Example</title>
    <script src="https://cdn.jsdelivr.net/npm/hls.js@latest"></script>
</head>
<body>
    <h1>HLS.js Player</h1>
    <video id="videoElement" width="640" height="360" controls></video>
    <script>
        var video = document.getElementById('videoElement');
       
        // 检查浏览器是否支持 HLS.js
        if (Hls.isSupported()) {
            var hls = new Hls();
            // 加载并播放 .m3u8 文件
            hls.loadSource('http://192.168.1.115:82/hls/room-1.m3u8');  // 替换为你的 .m3u8 URL
            hls.attachMedia(video);
           
            hls.on(Hls.Events.MANIFEST_PARSED, function() {
                video.play();  // 加载后自动播放
            });
            hls.on(Hls.Events.ERROR, function(event, data) {
                if (data.fatal) {
                    switch (data.fatal) {
                        case Hls.ErrorTypes.NETWORK_ERROR:
                            console.error("网络错误");
                            break;
                        case Hls.ErrorTypes.MEDIA_ERROR:
                            console.error("媒体错误");
                            break;
                        case Hls.ErrorTypes.OTHER_ERROR:
                            console.error("其他错误");
                            break;
                        default:
                            console.error("无法播放视频");
                            break;
                    }
                }
            });
        } else if (video.canPlayType('application/vnd.apple.mpegurl')) {
            // 如果浏览器原生支持 HLS（例如 Safari），直接播放
            video.src = 'http://192.168.1.92:82/hls/room-1.m3u8';
            video.play();
        } else {
            console.error('HLS.js 不支持此浏览器');
        }
    </script>
</body>
</html>

总结

本文介绍了流媒体服务器的特性及各种流媒体传输协议的适用场景，并详细阐述了使用 nginx-http-flv-module 扩展Nginx作为流媒体服务器的详细步骤，并提供了在VLC，flv.js，hls.js下的流媒体拉流播放示例。

引用

https://www.cnblogs.com/Naylor/p/18427309

https://www.cnblogs.com/Naylor/p/18070157

https://www.cnblogs.com/Naylor/p/18070047

apisix~路由前缀的正则匹配

作者: wenmo8
时间: 2024-12-03
分类: 其它
评论

参考：
https://apisix.apache.org/zh/docs/apisix/FAQ/

在你提供的 Apache APISIX 路由配置中，
vars
字段用于定义一些变量匹配规则。具体来说，
vars
字段可以用来根据请求的特定变量（如 URI、请求方法等）进行条件匹配。

添加正则路由

curl -i http://127.0.0.1:9180/apisix/admin/routes/1 -H "X-API-KEY: $admin_key" -X PUT -d '
{
    "uri": "/*",
    "vars": [
        ["uri", "~~", "^/[a-z]+$"]
    ],
    "upstream": {
            "type": "roundrobin",
            "nodes": {
                "127.0.0.1:1980": 1
            }
    }
}'

配置解析

"vars": [
    ["uri", "~~", "^/[a-z]+$"]
]

各部分含义：

uri
:
- 这是要匹配的变量名称。在这个例子中，表示我们要检查请求的 URI。
~~
:
- 这是一个匹配操作符，用于表示正则表达式匹配。在 APISIX 中，
  ~~
  表示“使用正则表达式进行匹配”。
"^/[a-z]+$"
:
- 这是一个正则表达式，表示 URI 必须以
  /
  开头，后面跟着一个或多个小写字母（
  [a-z]
  ），并且整个字符串必须以这些小写字母结束。
- 具体来说：
  - ^
    ：表示字符串的开始。
  - /
    ：表示 URI 必须以斜杠开头。
  - [a-z]+
    ：表示后面至少有一个小写字母。
  - $
    ：表示字符串的结束。

示例匹配

匹配的 URI
：
- /abc
- /xyz
- /a
不匹配的 URI
：
- /ABC
  （包含大写字母）
- /123
  （包含数字）
- /abc/def
  （包含多个路径段）

以/search结尾的路由正则

 "uri": "/kc/*",
  "vars": [
    "uri",
    "~~",
    "^.*/userinfo$"
  ]

总结

通过这种方式，
vars
字段允许你对请求的 URI 进行更细粒度的控制和过滤。只有当请求的 URI 符合指定的正则表达式时，路由才会被匹配到。这使得路由配置更加灵活，可以针对特定的请求进行处理。

实践

如果两个路由a和b，其中a是正常的请求，b用来限制某个规则的uri需要添加limit-count这种限流，应该如何实现？

实现思路

路由a和路由b它们的前缀匹配是相同的
路由b通过vars添加路由规则，找出要限制的uri
路由a添加相同的vars，但需要添加
!非
运算符，这样a和b就分别处理不同的uri了，但前缀是相同的

路由配置

 # 路由a
 "uri": "/demo/*",
  "vars": [
    [
      "uri",
      "!",
      "~*",
      "^.*/search$"
    ]
  ],
# 路由b
 "uri": "/demo/*",
  "vars": [
    [
      "uri",
      "~*",
      "^.*/search$"
    ]
  ],

apisix-dashboard中的体现

dotnet core微服务框架Jimu ~ 基础网关

作者: wenmo8
时间: 2024-12-03
分类: 其它
评论

网关提供外部访问内部微服务的统一入口，基于分布式和服务治理等功能特点，外部不能绕过网关调用内部微服务（框架本身提供外部可以直接访问内部微服务的功能，这里不作详细说明），外部通过 http 协议请求网关暴露的接口，网关再用基于 TCP/IP 协议的 RPC 方式调用内部被发现的微服务。

1 创建网关

创建一个基于 .Net Core 6.0 的 Asp.Net Core Web （项目模版选 WebApi）的项目，命名为 ApiGateway

1.1 添加 Jimu.Client 引用

网关相对于微服务而言属于客户端，所以引用 Jimu.Client，因为需要支持 Consul，所以还要因为 Jimu 对 consul 的扩展库 Jimu.Common.Discovery.ConsulIntegration

Install-Package  Jimu.Client

Install-Package  Jimu.Common.Discovery.ConsulIntegration

1.2 然后在 Startup 里添加 Jimu 的启动代码

usingSystem.Linq;usingMicrosoft.AspNetCore.Authentication.JwtBearer;usingMicrosoft.AspNetCore.Builder;usingMicrosoft.AspNetCore.Hosting;usingMicrosoft.Extensions.Configuration;usingMicrosoft.Extensions.DependencyInjection;usingMicrosoft.IdentityModel.Tokens;usingAutofac;usingJimu;usingJimu.Client;usingJimu.Client.ApiGateway;namespaceApiGateway

{public classStartup

    {publicStartup(IConfiguration configuration)

        {

            Configuration=configuration;

        }public IConfiguration Configuration { get; }//This method gets called by the runtime. Use this method to add services to the container.
        public voidConfigureServices(IServiceCollection services)

        {

            services.AddCors();//支持跨域
            services.UseJimu();  //支持 Jimu
}//This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public voidConfigure(IApplicationBuilder app, IHostingEnvironment env)

        {



            app.UseStaticFiles();

            app.UseAuthentication();

            app.UseStatusCodePages();//jimu client, 启动 jimu
            var host = new ServiceHostClientBuilder(newContainerBuilder())

                .UseLog4netLogger(newLogOptions

                {

                    EnableConsoleLog= true,  //启用控制台日志
                    EnableFileLog = true, //启用文件日志
                    FileLogLevel = LogLevel.Info | LogLevel.Error, //文件日志只记录 Info 和 Error
})

                .UseConsulForDiscovery("127.0.0.1", 8500, "JimuService") //配置 consul
                .UseDotNettyForTransfer() //使用 dotnetty 做 RPC 的通信库
                .UseHttpForTransfer() //同时支持使用  http 作为 RPC 的通信库
                .UsePollingAddressSelector() //使用轮询算法实现负载均衡
                .UseServerHealthCheck(1) //服务健康监控，时间间隔为 1 分钟
                .SetRemoteCallerRetryTimes(3) //调用微服务失败重试次数，设为 3次
                .SetDiscoveryAutoUpdateJobInterval(1) //服务发现，时间间隔 1 分钟
                .UseToken(() => { var headers = JimuHttpContext.Current.Request.Headers["Authorization"]; return headers.Any() ? headers[0] : null; }) //获取请求所携带的 token
.Build();

            app.UseJimu(host);//使用 jimu
            host.Run(); //启动 jimu
}

    }

}

最基本的网关完成了，已经支持接收请求。下面要加入一些可视化的服务治理，如微服务器列表，服务器健康状态，服务列表

1.3 服务治理

服务治理还未完善，只简单做了服务器列表和健康状态，以及开放的服务列表。

创建 2 个控制器：

1.3.1 Server 展示服务器列表

usingAutofac;usingJimu;usingJimu.Client;usingJimu.Client.ApiGateway;usingMicrosoft.AspNetCore.Mvc;usingSystem.Collections.Generic;usingSystem.Threading.Tasks;namespaceApiGateway.Controllers

{public classServerController : Controller

    {publicIActionResult Index()

        {returnView();

        }//[HttpGet(Name ="addresses")]//获取服务器列表
        public async Task<List<JimuAddress>>GetAddresses()

        {var serviceDiscovery = JimuClient.Host.Container.Resolve<IClientServiceDiscovery>();var addresses = awaitserviceDiscovery.GetAddressAsync();returnaddresses;

        }

    }

}

注意：控制器和方法上面都不需添加任何属性

1.3.2 Services 展示服务列表

usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.Threading.Tasks;usingAutofac;usingJimu;usingJimu.Client;usingJimu.Client.ApiGateway;usingMicrosoft.AspNetCore.Mvc;namespaceApiGateway.Controllers

{//[Produces("application/json")]
    public classServicesController : Controller

    {publicIActionResult Index()

        {returnView();

        }//[HttpGet(Name ="services")]//获取服务列表
        public async Task<List<JimuServiceDesc>> GetServices(stringserver)

        {var serviceDiscovery = JimuClient.Host.Container.Resolve<IClientServiceDiscovery>();var routes = awaitserviceDiscovery.GetRoutesAsync();if (routes != null && routes.Any() && !string.IsNullOrEmpty(server))

            {return (from route inrouteswhere route.Address.Any(x => x.Code ==server)selectroute.ServiceDescriptor).ToList();

            }return (from route in routes selectroute.ServiceDescriptor).ToList();

        }

    }

}