在动心前，还是得好好考虑下NAT这个大问题。



## 前言

NAT VPS，即无独占IP的虚拟服务器。这好比群租房，租户们共用同一个收件地址，至于包裹究竟要放在哪个房间里，外人无从知晓。它便宜的价格总会使人有购买的冲动，不过在购买前，还是得再三了解下NAT这个坑哈（群租房也是同理😦）。

通常这些VPS的硬件资源有限，处理器性能平庸、内存小（128MB~384MB）；由于NAT的特性，所有虚拟机共用同一个外网IP；意味着如果邻居干了些奇怪的事情导致IP被封，那么自己小鸡的网络也会跟着一起遭殃；虚拟化方案通常为OpenVZ或者直接使用LXC（坑越挖越深），更适合特别轻量化的服务……


## 剁手

剁手的是Gullo家的NAT主机，2美刀一年。

配置为：1核心、128MB内存、2GiB硬盘、125GiB流量。


<div align="center"> <img src="https://nixieka.top/static/img/c256d6eff9830f7edbb2c5ae96cb6daf.Snipaste_2023-03-12_19-37-11.webp" width = 40% /> </div>

控制台非常的熟悉，非常的正常（

<div align="center"> <img src="https://nixieka.top/static/img/42283babd2cd4f13c9893c4419621ef6.Snipaste_2023-03-12_21-44-24.webp" width = 80% /> </div>


## 测试

<div align="center"> <img src="https://nixieka.top/static/img/1d7afe45686e53eda74219ff6c25a62f.Snipaste_2023-03-12_21-30-13.webp" width = 60% /> </div>


好家伙，居然是Haswell时期的消费级硬件做底层（不过2刀/年，能缩就缩也正常），轻度服务问题不大。


## 折腾

开启TUN/TAP转发功能，能提高NAT机的网络传输效率。


<div align="center"> <img src="https://nixieka.top/static/img/35828dd014f2f5f5a58badd4dc51d5ce.Snipaste_2023-03-12_21-44-40.webp" width = 40% /> </div>


虽然映射的IPv4地址被拦截，但IPv6能直接访问，此时可通过域名+Cloudflare间接实现IPv4网络的访问。

安装了Nginx，内存占用极低。（注：跑了一些奇怪的服务，换成CentOS了）

<div align="center"> <img src="https://nixieka.top/static/img/ccf2ac0f330628a108cc7662a02179e7.NATVPS_Nginx.webp" width = 65% /> </div>


## 总结

当玩具机使用还算是能用的，但老规矩——明确需求后再剁手~

折腾2刀的NAT VPS

Shell 是一个用 C 语言编写的程序，它是用户使用 Linux 的桥梁……




## 数组的概念

在编程中，数组是一种用于存储多个数据元素的数据结构

- 数组可以容纳相同类型的元素
- 并通过一个唯一的标识符（通常是一个变量名）引用这些元素

与大多数编程语言类似，Shell也支持数组

- 不过在Shell中 **仅支持一维数组**，且**初始化时不需要定义数组大小**



## 数组的类型

### 普通数组

- 索引：通常是从0开始的整数，表示数组中的位置
  - 例如，第一个元素的索引是0，第二个元素的索引是1，依此类推
- 元素：存储在数组中的实际值，每个索引对应一个元素值
  - 例如，`my_array[0]` 表示数组中的第一个元素。
- 普通数组使用可不声明（`declare -a [数组名]`）

```bash
my_array=("apple" "banana" "cherry")
# 索引:    0        1        2
# 元素: "apple" "banana" "cherry"
```

###  关联数组

- 索引：在关联数组中，索引是字符串，而不是整数
  - 每个索引表示一个键，它与一个特定的元素值相关联。
  - 与普通数组最大的区别，其由**特定格式的键值对组成**
- 元素：元素是与索引关联的值
  - 关联数组中的每个索引都映射到一个元素值。

- 使用前必须声明（`declare -A [数组名]`）

```bash
declare -A fruit_colors
fruit_colors["apple"]="red"
fruit_colors["banana"]="yellow"
fruit_colors["cherry"]="red"
# 索引:   "apple"    "banana"    "cherry"
# 元素:    "red"     "yellow"    "red"
```



## 数组的定义

### 直接定义

格式为 `array_name=(value1 value2 ... valueN)` 

```bash
array=(a b c)
```

### 通过索引定义

格式为 `array_name=( [1]=value1 [2]=value2 ... [N]=valueN )`

```bash
array=([1]=a [2]=b [3]=c)
```


## 数组的使用

要获取数组中的值，可使用`${数组名[索引]}`

|                 **操作符**                 |                      **解释**                      |
| :----------------------------------------: | :------------------------------------------------: |
| `echo ${!array[*]}` 或 `echo ${!array[@]}` |                 获取数组的所有索引                 |
| `echo ${array[*]} ` 或 `echo ${array[@]}`  |                  获取数组所有元素                  |
|             `echo ${array[0]}`             |                获取数组的第一个元素                |
|            `echo ${array[@]:1}`            | 表示从索引 1 开始，获取包括索引 1 及之后的所有元素 |
|           `echo ${array[@]:1:2}`           |        从第二个元素开始，获取连续的两个元素        |
|            `echo ${#array[@]}`             |         获取数组中的元素个数（数组的长度）         |
|            `echo ${#array[n]}`             |           获取数组`第n个`元素的字符个数            |


## 数组的遍历

数组的遍历，可以使用`for`、`while`循环体实现

### 通过索引遍历

- 使用 `for` 循环以索引 `i` 来迭代数组 `array`
- 这种方式适合于需要根据**元素的索引**来处理数组元素的情况


```bash
#!/bin/bash
names=(Tom Jeny David)
for (( i=0;i<${#names[*]};i++ ))
do
  echo ${names[$i]}
done
```

### 不通过索引遍历

- 这种方式使用 `for` 循环迭代数组 `array` 中的每个元素
  - 并将每个元素赋值给变量 `i`
  - 即：在每次迭代中，可以直接使用 `i` 来访问当前元素的值
- 这种方式适合于需要**依次访问数组元素**并执行某些操作的情况

```bash
#!/bin/bash
names=(Tom Jeny David)
index=0
for i in ${names[@]}
do
  echo "第${index}个元素的值为：${i}"
  let index++
done
```


## 删切替

### 删除

使用`unset array[index]`命令，可以删除数组中的特定元素

- `array` 是数组名
- `index` 是索引

### 切片

使用 `${array[@]:start:length}` 命令，可对数组进行切片

- `start` 是起始索引
- `length` 是要包括的元素的数量

### 替换

使用 `${array[@]/old/new}` 命令，可对数组的某个特定元素进行全量替换

- `array`是数组名
- `old` 是需要替换的元素
- `new` 是替换后的元素

Shell小笔记（三）

Shell 是一个用 C 语言编写的程序，它是用户使用 Linux 的桥梁……




## 条件测试语句

### 基本语法

（1）`test <条件>`

（2）`[ <条件> ]` 需要注意环境前后要有空格

结果：条件非空的话为 **True** (真)，反之为 **False**（假）

需要注意，在Shell中，通常情况下0为真，其他数值为假（特殊情况如字符串测试等除外）。

```bash
test homo ; echo $?
```

### 文件测试

配合操作符，可以实现文件或者目录类型的检测。

例如，检测当前路径下的 homo 是不是目录？ 

```bash
touch homo
test -d homo ； echo $? 
#或使用[ -d homo]；echo $?
```

以下是文件测试操作符与相应说明的对应关系

| **操作符** |             **说明**             |
| :--------: | :------------------------------: |
|     -d     |   测试是否为目录（Directory）    |
|     -a     | 测试目录或文件是否存在（Exist）  |
|     -f     |      测试是否为文件（File）      |
|     -r     |   测试当前用户是否可读（read）   |
|     -w     |  测试当前用户是否可写（write）   |
|     -x     | 测试当前用户是否可执行（excute） |

### 整数测试

整数测试通常用于数值之间的运算，在一些逻辑关系的判断中有应用。

例如判断 1+1+5+4 与 1+9+1 是否相等，可以这么写

```bash
echo $((1+1+5+4)) -eq $((1+9+1)) ; echo $?
```

以下是关系测试操作符与相应说明的对应关系

| 操作符 | 关系运算符 |              说明              |
| :----: | :--------: | :----------------------------: |
|  -eq   |     ==     |         等于（Equal）          |
|  -ne   |     !=     |      不等于（Not Equal）       |
|  -gt   |     >      |      大于（Greater Than）      |
|  -lt   |     <      |      小于（Lesser Than）       |
|  -le   |     <=     | 小于或等于（Lesser or Equal）  |
|  -ge   |     >=     | 大于或等于（Greater or Equal） |

### 字符串测试

字符串测试操作符的作用包括比较字符串是否相同、测试字符串的长度是否为0。

格式为： `[字符串1] 操作符 [字符串2]`

以下是字符串测试操作符与相应说明的对应关系

| 操作符 |           **含义**            |
| :----: | :---------------------------: |
|   -z   |  判断字符串长度是否 **为0**   |
|   -n   | 判断字符串长度是否 **不为0**  |
|   !    | 判断两边字符串是否 **不相等** |
|   =    |  判断两边字符串是否 **相等**  |

### 逻辑运算符

在Shell条件测试中，使用逻辑运算符实现复杂的条件测试，逻辑运算符用于操作两个变量。

格式为： `[表达式1] 操作符 [表达式2]`

注意：`-a` 和 `-o` 放在 `[ ]` 里面用，`&&`和 `||` 放在 `[ ]` 外面用

以下是逻辑运算操作符与相应说明的对应关系

|   操作符   | 含义 |
| :--------: | :--: |
|  -a 或 &&  |  与  |
| -o 或 \|\| |  或  |
|     !      |  否  |

## if条件

很常见的判断语句，不过要注意Shell中的流程控制不能为空（即如果`else`分支没有语句执行，就不需要写）。

### if单分支

```bash
if [条件表达式];then
    代码块
fi
```

### if双分支   

```bash
if [条件表达式];then
    代码块1
else
    代码块2
fi
```

### if多分支

```bash
if [条件表达式1];then
    代码块1
elif [条件表达式2];then
    代码块2
elif [条件表达式3];then
    代码块3
else
    代码块4
fi
```



## case条件

程序会获取case语句中的**变量值**

- 如果满足条件表达式1，则执行代码块 1

- 如果满足条件表达式2，则执行代码块2

- 如果满足条件表达式3，则执行代码块3

- 执行到双分号 `;;` ，则停止

- 如果都不满足，则执行`*)`后面的代码块（上面的双分号会被忽略）

  只要满足一个条件表达式就会跳出`case`语句主体，执行`esac`字符后面的命令

```bash
case 变量值 in
 条件表达式1)
    代码块1
		;;
 条件表达式2)
    代码块2
		;;
 条件表达式3)
	代码块3
		;;
  *)
	无匹配后代码块
esac
```

条件表达式的匹配符如下表所示

| **条件表达式** |     **说明**     |
| :------------: | :--------------: |
|       *        |     任意字符     |
|       ?        |   任意单个字符   |
|     [abc]      | a、b或c其中之一  |
|     [a-n]      | 从a到n的任一字符 |
|       \|       |     多重选择     |



## for循环

这是一个在编程语言中常见的循环，当然Shell也是支持的。

### 语法

- 当变量值在列表里

  for 循环即执行一次所有命令，使用变量名获取列表中的当前取值

- `in` 的取值列表支持替换、字符串和文件名

  如果不用它（`in`），for循环将使用命令行的位置参数


**通常写法**

```shell
for [变量名] in [取值列表]
do
	[循环体]
done	
```

**一行写法**

```shell
for [变量名] in [取值列表]; do [循环体] done;
```

💡提醒：写成一行（在终端直接执行）时，需要记得加 `;` 符号。

### 例子

**从 1 依次加到 100**

```bash
#!/bin/bash
#for循环之加法
sum=0 #创建结果变量，并赋值为0
#开始for循环（创建i变量，赋值0，当i小于等于100时，先赋值再自增）
for ((i=0;i<=100;i++))
do
    #将上一次的结果与当前数值相加
	sum=$[${sum}+${i}]
done
#输出结果
echo "从1依次加到100的总和为：" + ${sum}
```

## while循环

while 循环用于不断执行一系列命令，也用于从输入文件中读取数据。

### 语法

**常规写法**

```shell
while [条件表达式]
do
  [代码块]
done  
```

**无限循环**

```shell
while : #也可写成while true
do
  [循环体]
done  
```

### 例子

**读取键盘输入的信息**

```shell
#!/bin/bash
echo "按下 Crtl和D 退出"
echo -n '你想吃啥: '
while read FOOD
do
    echo "老板，来份：${FOOD}~"
done
```


## until循环

与while循环的处理方式相反，until 循环执行一系列命令直至条件为 `true` 时停止。

通常情况下，while循环优于until循环。

### 语法

如果条件表达式的返回值为 false，则继续执行循环体内的语句，否则跳出循环。

```shell
until [条件表达式]
do
  [循环体]
done
```

### 例子

**遍历输出0~9**

```shell
#!/bin/bash
a=0
until [ ! $a -lt 10 ]
do
  echo ${a}
  a=$[${a}+1]
done
```


## 跳出循环

在循环过程中，有时候需要在未达到循环结束条件时强制跳出循环。

循环的跳出的命令`break` 与  `continue`

**break**

- 允许跳出所有循环

**continue**

- 仅跳出当前循环

Shell小笔记（二）

Shell 是一个用 C 语言编写的程序，它是用户使用 Linux 的桥梁……




## 格式

打开文本编辑器（如vi或vim ），创建一个后缀名为`sh`的文件；开头第一行提示Shell使用的解释器类型，如`#!/bin/bash`，为保证解析正确建议写上。

例如编写一个名为`test.sh`的脚本：

```bash
#!/bin/bash
echo "test" #echo命令用于输出（打印）信息
```


## 使用方式

### `bash`或`sh` + 脚本名运行

```bash
[kaka@localhost ~]$ cat test.sh 
a='hello world'
echo $a

[kaka@localhost ~]$ bash test.sh 
hello world
```

### 给执行权限后直接运行

><h3>提示</h3>
>
>直接运行前需要为脚本赋予执行权限（`chmod +x <脚本的文件名>`）

````bash
[kaka@localhost ~]$ cat test.sh 
a='hello world'
echo $a

[kaka@localhost ~]$ ./test.sh
bash: ./test.sh: 权限不够

[kaka@localhost ~]$ chmod +x test.sh 
[kaka@localhost ~]$ ./test.sh
hello world
````

### 使用 `source` 或 `.` 运行

><h3>提示</h3>
>
>使用`source`相当于在当前终端运行该脚本，可以看到被赋值的变量显示在当前终端上。

```bash
[kaka@localhost ~]$ cat a.sh 
#!/bin/bash
A=5
echo $A

[kaka@localhost ~]$ bash a.sh 
5
[kaka@localhost ~]$ echo $A

[kaka@localhost ~]$ source a.sh 
5
[kaka@localhost ~]$ echo $A
5
```


## 变量

自定义变量、环境变量、位置变量、预定义变量

> <h3>变量名要求</h3>
>
> - 命名只能使用英文字母，数字和下划线，首个字符不能以数字开头
> - 中间不能有空格，可以使用下划线 `_`
> - 不能使用标点符号
> - 不能使用bash里的关键字（可用help命令查看保留关键字）
>
> <h3>如何使用</h3>
>
> 在变量名前加美元符号（`$`）即可
>
> 为了帮助解释器识别到变量的边界，可以在变量名外加入花括号（`{}`）

### 自定义变量

相当于局部变量，仅在当前会话中生效

格式：`<变量名>=<变量值>`，注意**等号两边不需要空格**

如果变量值存在空格，需要用双引号（`""`）或单引号（`''`）框起来

使用`unset <变量名>`撤销该自定义变量

### 环境变量

相当于全局变量，在所有会话中生效

例如`/etc/profile`文件存储着当前系统的环境变量

### 预定义变量

也称为特殊变量；这其中一部分是环境变量，有一部分是局部变量，这些变量保证了shell的正常运行

| 变量 |                             含义                             |
| :--: | :----------------------------------------------------------: |
|  $n  | 位置变量<br>`n`为数字，`$0`代表该脚本名称<br> `$1`代表第1个参数（以此类推），但从第十个开始要用花括号（`{}`）包含 |
|  $#  |                    获取所有输入参数的个数                    |
|  $*  |         获取命令行的所有参数，并将其**视为一个整体**         |
|  $@  |        获取命令行的所有参数，但**将每个参数进行拆分**        |
|  $?  | 获取最后一次命令执行的状态，正确执行为`0`，其余输出则不正常  |

创建一个名为`advance.sh`的文件，并写入以下内容

```shell
#!/bin/bash
echo '==========$n=========='
echo $0
echo $1
echo $2
echo '==========$#=========='
echo $#
echo '==========$*=========='
for i in "$*"; do
	echo $i
done	
echo '==========$@=========='
for i in "$@"; do
	echo $i
done	
echo '==========$?=========='
echo $?
```

使用`. advance.sh 1 2 3 4 5`命令，结果如下

```shell
==========$n==========
./advance.sh
1
2
==========$#==========
5
==========$*==========
1 2 3 4 5
==========$@==========
1
2
3
4
5
==========$?==========
0
```

### 只读变量

使用 `readonly` 命令可以将变量定义为只读变量，只读变量的值不能被改变、不能被撤销



## 赋值

> <h3>提示</h3>
>
> - 显示**变量的值**使用**双引号**
>
> - **单引号**中是**没有变量**的
> - 反引号（``）等价于 $() ，**反引号的Shell命令会被先执行**

### 直接赋值

格式：`<变量名>=<变量值>`，注意**等号两边不需要空格**

```shell
#!/bin/bash
num=10086 #直接赋值
echo $num
```

###  键盘读取赋值

格式：`read -p ["提示信息"] [变量名]`，可不带`-p ["提示信息"]`这个选项和参数

获取输入的单行数据，并赋值给变量名

```shell
#!/bin/bash
read INPUT #将键盘输入的单行数据赋值给INPUT变量名
echo $INPUT
```

### 通过命令行参数赋值

即通过**位置变量**进行调用

```shell
#!/bin/bash
echo $1 $2
```

### 利用命令的输出结果赋值

在赋值语句中使用反向单引号（ ``）

```shell
#!/bin/bash
DATE=`date +%F` #将当前年月日期（结果）赋值到DATE变量上
echo $DATE
```

其中`date +%F`等价于`$(date +%F)`

### 从文件中读取数据赋值

这种方式适用于处理大批量的数据，直接把相应的数据写入文件中。这种方式通常是循环一行行读入数据，即每循环一次，就从文件中读入一行数据，知道文件的结尾。

```shell
#!/bin/bash
ls *.sh > execfile #列举后缀名为sh的文件重定向至execfile
while read LINE #使用While循环读取每一行，并赋值到LINE这个变量中
do
     echo $LINE #输出每行内容
done < execfile
```



## 运算符

> 在bash中，变量的默认均为**字符串**类型，无法直接进行运算

### 基本语法

`“$((运算式))”` 或 `“$[运算式]”`

```bash
[kaka@localhost ~]$ a=10
[kaka@localhost ~]$ b=20
[kaka@localhost ~]$ sum=$(($a+$b)) #或 sum=$[$a+$b]
[kaka@localhost ~]$ echo $sum
30
```

### 使用expr计算

`expr` 是一款表达式计算工具，使用它能完成表达式的求值操作。

```bash
[kaka@localhost ~]$ a=10
[kaka@localhost ~]$ b=20
[kaka@localhost ~]$ expr $a + $b
30
```

### 使用let计算

```bash
[kaka@localhost ~]$ a=10
[kaka@localhost ~]$ b=20
[kaka@localhost ~]$ let sum=a+b
[kaka@localhost ~]$ echo $sum
30
```

### 算数运算符

| 运算符 |                     说明                      |                   举例                    |
| :----: | :-------------------------------------------: | :---------------------------------------: |
|   +    |                     加法                      |              `expr $a + $b`               |
|   -    |                     减法                      |              `expr $a - $b`               |
|   *    |                     乘法                      | `expr $a \* $b` <br>此处需要用`\`以防转译 |
|   /    |                     除法                      |              `expr $b / $a`               |
|   %    |                     取余                      |              `expr $b % $a`               |
|   =    |                     赋值                      |      `a=$b` <br>把变量 b 的值赋给 a       |
|   ==   |   相等<br>用于比较两个数字，相同则返回 true   |               `[$a == $b]`                |
|   !=   | 不相等<br>用于比较两个数字，不相同则返回 true |               `[$a != $b] `               |

注意：条件表达式要放在方括号之间，并且要有空格，例如: `[$a==$b]` 是错误的，必须写成 `[$a == $b]`。



## 替删改

###  替换

|             语法             |              含义              |
| :--------------------------: | :----------------------------: |
| ${变量名/旧字符串/新字符串}  | 将第一个旧字符串替换成新字符串 |
| ${变量名//旧字符串/新字符串} | 将全部的旧字符串替换成新字符串 |


例如将`www.abc.com`中的第一个`a`替换成`d`

```bash
var=www.abca.com
echo ${var/a/d}
```

例如将`114514`中的`1`全部替换成`9`

```bash
num=114514
echo ${num//1/9}
```

### 删除

|          语法           |                      含义                      |
| :---------------------: | :--------------------------------------------: |
| ${`变量名`#`关键字符`}  |  删除第一个关键字符前面的内容（从前往后匹配）  |
| $[`变量名`##`关键字符`] | 删除最后一个关键字符前面的内容（从前往后匹配） |
| $[`变量名`%`关键字符`]  |  删除第一个关键字符后面的内容（从后往前匹配）  |
| $[`变量名`%%`关键字符`] | 删除最后一个关键字符后面的内容（从后往前匹配） |

创建一个名为`del.sh`的文件，并写入以下内容

```shell
file=/dir1/dir2/abc.file

echo "输出名为file变量"
echo ${file}

echo '删除第一个 / 前面的内容（从前往后匹配）'
echo ${file#*/}

echo "删除最后一个 / 前面的内容（从前往后匹配）"
echo ${file##*/}

echo "删除第一个 / 后面的内容（从后往前匹配）"
echo ${file%/*}

echo "删除最后一个 / 后面的内容（从后往前匹配）"
echo ${file%%/*}
```

执行结果

```bash
输出名为file变量
/dir1/dir2/abc.file
删除第一个 / 前面的内容（从前往后匹配）
dir1/dir2/abc.file
删除最后一个 / 前面的内容（从前往后匹配）
abc.file
删除第一个 / 后面的内容（从后往前匹配）
/dir1/dir2
删除最后一个 / 后面的内容（从后往前匹配）
```

### 修改

使用 `${变量名-新的变量名}`进行替换


```bash
[kaka@localhost ~]$ unset num
[kaka@localhost ~]$ echo ${num-1919}
1919
[kaka@localhost ~]$ num=10010
[kaka@localhost ~]$ echo ${num-1919}
10010
```

Shell小笔记（一）

2023年5月的软考网络工程师考试可以说是相当的重量级，史无前例的综合论述题、猖狂的作弊情况（你甚至可以在考点的垃圾桶里翻出「答案」），让正常备考的考生苦不堪言……




## 报名

错过了去年下半年考试的报名时间（22年8月25日截止），于是我将目光转向23年5月这场考试，在3月中上传报名信息并缴纳好考试费后，惊喜（吓）便不断「涌现」……


## 复习

其实我个人的复习方式不是很规范：考虑到时间紧迫（不足1个月），会倾向于先了解下卷面题型，通过作答情况去针对性的补足；然后再系统性的过一下**OSI七层参考模型**的结构组成，并侧重二、三层的知识梳理。



## 赴考

5月27日，恰个早餐就打的去考点了。

<div align="center"> <img src="https://nixieka.top/static/img/372e16fc88fb16aaf75cb06544f8242d.372e16fc88fb16aaf75cb06544f8242d.jpeg" alt="" width = 60% height = 30% /> </div>


上半场的题目难度还算简单，如果有折腾过软路由的老哥应该能很快完成。


<div align="center"> <img src="https://nixieka.top/static/img/7c539ddc58ed2d9c5b547d083925fb90.%C3%A9%C2%80%C2%89%C3%A6%C2%8B%C2%A9%C3%A9%C2%A2%C2%98%C3%A8%C2%8A%C2%82%C3%A9%C2%80%C2%89-2pass.jpg" alt="" width = 80% height = 30% /> </div>


不过到了下半场嘛，难度可以说是陡然上升的；首先清一色的论述题就给大家来了个措手不及，同时送分题的占比明显变少（不到30分）。

:::info{title="23年5月份下半场的第一道大题"}
<div align="center"> <img src="https://nixieka.top/static/img/b64c776677dae396de2688c4546a413d.%C3%A8%C2%AF%C2%95%C3%A9%C2%A2%C2%981-2pass.jpg" alt="" width = 80% height = 30% /> </div>
:::

:::note{title="22年5月份下半场的第一道大题"}
<div align="center"> <img src="https://nixieka.top/static/img/bdacb0e1515974867eb35ed2d2d19ef1.22%C3%A5%C2%B9%C2%B45%C3%A6%C2%9C%C2%88%C3%A8%C2%AF%C2%95%C3%A9%C2%A2%C2%981-2pass.jpg" alt="" width = 80% height = 30% /> </div>

注：从22年11月开始，软考网工下半场的考题不再提供「备选答案」，变成真正意义上的填空题。
:::

虽然题目阴间，但还是硬着头皮做完了，差不多下午4点，可以交卷离场。


考完大家在吐槽阴间出题、泄题作弊的情况，有考生能在考点的地上、垃圾桶里捡到印有答案的小抄，有的考点抓了几十号作弊者……

<div align="center"> <img src="https://nixieka.top/static/img/854aa0d25887c6df6628e11821f62e41.%C3%A5%C2%90%C2%90%C3%A6%C2%A7%C2%BD-2pass.jpg" alt="" width = 75% height = 30% /> </div>


大家会有不舒服也不奇怪，以第一道路由题举例，挖空的位置可以说别出新意。

:::info{title="23年5月份下半场的第三道大题（节选）"}
<div align="center"> <img src="https://nixieka.top/static/img/40fb59f924a41b367773cd58da96288f.%C3%A8%C2%AF%C2%95%C3%A9%C2%A2%C2%983%C3%A8%C2%8A%C2%82%C3%A9%C2%80%C2%89-2pass.jpg" alt="" width = 80% height = 30% /> </div>

注：这一道题是BGP+OSPF；另外一道是RIP+BFD检测。
:::

与「网传作弊小抄」的契合度，很难不让人产生遐想。

:::note{title="网传小抄"}
<div align="center"> <img src="https://nixieka.top/static/img/01b7b47f92b93658227ad29107a21b33.%C3%A5%C2%9B%C2%BE%C3%A7%C2%89%C2%87.png" alt="" width = 40% height = 30% /> </div>
:::

说实话，泄题这件事一出来我自己也绷不住，毕竟投入产出不成正比。刚好题目和解析出来，跟着预估出成绩：上午56、下午47（软考需上午下午同时满足45分才算通过），考虑到自己有几道论述题没答到点子上，默默叹息：“不过的话，11月考网络规划师吧”。

<div align="center"> <img src="https://nixieka.top/static/img/ec901e7f7f06b4260732cd12449dfe98.%C3%A6%C2%88%C2%91%C3%A6%C2%9C%C2%89%C3%A9%C2%B1%C2%BC%C3%A9%C2%B1%C2%BC%C3%A7%C2%97%C2%87-2pass.jpg" alt="" width = 20% height = 30% /> </div>


## 惊喜

从考完到写稿子的时候已过去38天，依旧没有音信……（毕竟出了这么大件事情）


直到7月20日下午5点，突然收到成绩公布的通知，便打开软考官网查成绩，看得出大家都挺热情的，站点处于满载状态……

<div align="center"> <img src="https://nixieka.top/static/img/f65465f8f111e92c36d69df3f3190415.502-2pass.png" alt="" width = 50% height = 30% /> </div>


过了一会儿，总算查到。上午估多3分、下午超合格线2分，压线通过，运气不错。

<div align="center"> <img src="https://nixieka.top/static/img/d7f96ef477ce808e10530157cdf5b75e.%C3%A6%C2%88%C2%90%C3%A7%C2%BB%C2%A9.png" alt="" width = 40% height = 30% /> </div>


## 建议

:::info{title="2023-09更新"}

下半年的软考全部改为机试了

:::


复习提示：做原题只是为了更好的了解题型；理解好OSI参考模型的第二层与第三层；熟悉IPv4子网规划；记一记命令，必要时过一下eNSP模拟器。

最后，祝大家都能顺利通过考试，冲冲冲。