东辰行迹

使用frp搭建免费的内网穿透

Mon, 30 Oct 2023 19:00:00 +0800

frp介绍

frp 是一个专注于内网穿透的高性能的反向代理应用，支持 TCP、UDP、HTTP、HTTPS 等多种协议，且支持 P2P 通信。可以将内网服务以安全、便捷的方式通过具有公网 IP 节点的中转暴露到公网。

Github地址：fatedier/frp: A fast reverse proxy to help you expose a local server behind a NAT or firewall to the internet. (github.com)

配置教程

配置frp穿透，首先必须要有一台具有外网ip的服务器(即：可以外网访问)。如果没有，接下来的教程就不用看了。配置教程主要分为两个部分，一是服务器端(外网服务器)的配置；二是客户端(内网服务器)配置。

下载frp

选择和系统一致的包进行下载。下载的文件包中有服务器端和客户端，需要在Windows部署客户端需要额外下载windows版本的包。

Linux_amd64： 
Linux_arm： 
Windows_amd64：

安装frps

服务端的安装以Linux为例，默认监听7500端口。

#下载包
wget https://github.com/fatedier/frp/releases/download/v0.52.3/frp_0.52.3_linux_amd64.tar.gz 

#解压
tar -zxvf frp_0.52.3_linux_amd64.tar.gz 

#拷贝文件到指定目录
cd frp_0.52.3_linux_amd64
cp frps /usr/frp/frps
cp frps.toml /usr/frp/frps.toml

#编辑frps.toml
vim /usr/frp/frps.toml

#begin
[common]
#请按自己需求更改
#frp监听的端口，默认是7000
bind_port = 7876 #frps服务端与客户端通信端口    

#frp管理后台配置
dashboard_port = 7451
dashboard_user = "" #用户名
dashboard_pwd = ""  #口令
enable_prometheus = true

vhost_http_port = 9721  #http服务需要用到的端口
vhost_https_port = 9722 #https服务需要用到的端口
max_pool_count = 50

#推荐使用，只有共享密钥(secretKey)与服务器端一致的用户才能访问该服务
sk = "blog.xuanzhe.club" 

#日志相关
log_file = ./frps.log
log_level = info
log_max_days = 3
#end

#编辑frps.service
vim /etc/systemd/system/frps.service

#begin
[Unit]
# 服务名称，可自定义
Description = frp server
After = network.target syslog.target
Wants = network.target

[Service]
Type = simple
# 启动frps的命令，需修改为您的frps的安装路径
ExecStart = /usr/frp/frps -c /usr/frp/frps.toml

[Install]
WantedBy = multi-user.target
#end

#启动frps
systemctl start frps
#自启frps
systemctl enable frps
#停止frps
systemctl stop frps
#重启frps
systemctl restart frps
#查看frps状态
systemctl status frps

#添加监听端口
#frps与客户端通信端口
sudo firewall-cmd --permanent --add-port=7876/tcp
#frp管理后台端口
sudo firewall-cmd --permanent --add-port=7451/tcp
#远程代理端口号
sudo firewall-cmd --permanent --add-port=4526/tcp
sudo firewall-cmd --reload

安装frpc

客户端以Windows为例

解压下载的包，编辑frpc.toml文件

#部署的外网IP
serverAddr = ""
#外网服务绑定的端口
serverPort = 7876

[[proxies]]
name = "2550720300"
type = "tcp"
sk = "blog.xuanzhe.club"
localIP = "127.0.0.1"
localPort = 3389
remotePort = 4526

添加frpc到服务

如果choco无法启动

win+x
选择打开powershell（管理员）
执行以下命令

Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))

安装完成后，cmd执行以下命令：

#安装命令
choco install dart-sdk
#更新命令
choco upgrade dart-sdk
#安装nssm
choco install  nssm
#安装服务
nssm install frpc

打开NSSM的服务安装程序，填写如下的信息后，点击安装服务。

注：remotePort与每个客户端绑定，不可重复使用。如需绑定不同网段的内网设备，需要使用不一样的端口。

参考文章：

计算机组成和体系结构知识点题型

Fri, 20 Oct 2023 11:01:55 +0800

可靠性

某计算机系统由下图所示的部件构成，假定每个部件的千小时可靠度都为R，则该系统的千小时可靠度为（）。

由于系统构成串联系统时，其中任何一个子系统失效就足以使系统失效，其可靠度等于各子系统可靠度的乘积。

构成并联系统时，只要有一个子系统正常工作，系统就能正常工作。设每个子系统的可靠性分别以R₁，R₂ ... R_N表示，则并联系统的可靠度为：

R=1-（1-R₁)（1-R₂)（1-R₃）...（1-R）

因此，本系统的可靠度为R（1-（1-R）²）²

系统类型	可靠性	失效率
串联系统	R=R₁×R₂×...×R_n	λ=λ₁+λ₂₊...+λ_n
并联系统	R=1-(1-R₁)×(1-R₂)×...×(1-R_n)
模冗余系统

更新时间：2023年10月11日 17:46:32

总线系统

在计算机系统中采用总线结构，便于实现系统的积木化构造，同时可以（）。

提供数据传输速度
提高数据传输量
减少信息传输线的数量
减少指令系统的复杂性

总线是在计算机中连接两个或多个功能部件的一组共享的信息传输线，它的主要特征就是多个部件共享传输介质。它是构成计算机系统的骨架，是各个功能部件之间进行信息传输的公共通道，借助总线的连接，计算机各个部件之间可以传送地址、数据和各种控制信息。在计算机系统中采用总线结构，便于实现系统的积木化构造，同时可以有效减少信息传输线的数量。

更新时间：2023年10月12日 22:35:26

流水线的计算

若指令流水线把一条指令分为取值、分析和执行三部分，且三部分的时间分别是取值2ns、分析2ns、执行1ns。

流水线周期是多少？
100条指令全部执行完备需要多少时间？
流水线的吞吐率是多少？

流水线的周期为花费时间最长的阶段所花费的时间，所以流水线的周期就是2ns。

根据理论公式，T=（2+2+1）+（100-1）*2=5+99*2=203ns

根据实践公式，T=（3+100-1）*2=204ns

理论吞吐率：TP=100/203

实际吞吐率：TP=100/204

①关于流水线的周期，我们需要知道的是，流水线周期（△t）为指令执行阶段中执行时间最长的一段。

②流水线的计算公式为：

　　完成一条指令所需的时间+（指令条数-1）*流水线周期，在这个公式中，又存在理论公式和实践公式。

　　理论公式：（ t₁+ t₂+ ... + t_n）+（n-1）× △t

　　实践公式：（ k + n - 1）× △t k为一条指令所包含的部分的多少

③吞吐率的计算公式为：

TP=n/T_k=n/（kΔt+(n−1)Δt）

更新时间：2023年10月13日 17:25:49

存储系统

计算机系统的主存主要是由（5）构成的。

DRAM
SRAM
Cache
EEPROM

主存主要采用动态随机存储器DRAM

Cache采用静态随机存储器SRAM

EEPROM是电擦除可编程的只读存储器

更新时间：2023年10月18日 17:47:58

高速缓存Cache

（2017年下半年上午试题6）以下关于Cache（高速缓冲存储器）的叙述中，不正确的是（ A ）。

Cache的设置扩大了主存的容量
Cache的内容是主存部分内容的拷贝
Cache的命中率并不随其容量增大线性地提高
Cache位于主存与CPU之间

更新时间：

（2016年下半年上午试题6）一下关于Cache与主存间地址映射的叙述中，正确的是（ D ）。

操作系统负责管理Cache与主存之间的地址映射
程序员需要通过编程来处理Cache与主存之间的地址映射
应用软件对Cache与主存的地址映射进行调度
有硬件自动完成Cache与主存之间的地址映射

更新时间：

主存与Cache的地址映射方式中，（）方式可以实现主存的任意一块装入Cache中任意位置，只有装满才需要替换。

全相联
直接映射
组相联
串并联

全相联映射：各主存块可以映射到cache的任意数据块。
直接相连映射：各主存块只能映射到cache中的固定块。
组相连映射：各主存块只能映射到cache固定组中的任意块。

更新时间：2023年10月18日 13:40:30

某内存64块，cache有4块，一个块为4个字节，按字节编址。

采用全相联映射方式，写出cache和主存地址格式。
采用直接映射方式，写出cache和主存地址格式。

全相联映射方式中主存的主存块标记是全部块标记，

根据主存和cache的对应关系，一个块为4个字节，能得出主存和cache的块内地址的位数都是2位，根据cache的块数是4，得出cache块的位数是2。

因为主存的块数为64块，得出主存块标记的位数是6位。

cache：4块=4*4字节=2的4次方字节，cache的总位数是4。

主存：64块=64*4字节=2的8次方字节，主存的总位数是8

由题意得：一个块4个字节，就是2的2次方，可以得出cache的块内地址为2位，又因为cache的总位数是4，所以得出cache块有（4-2）位

更新时间：2023年10月18日 17:26:47

主存的编址

内存地址从AC000H到C7FFFH，共有（）K个地址单元，如果该内存地址按字（16bit）编址，由28片存储器芯片构成。已知构成此内存的芯片每片有16K个存储单元，则该芯片每个存储单元存储（）位。

A. 96 B. 112 C. 132 D. 156
A. 4 B. 8 C. 16 D. 24

地址单元数量：

十六进制计算：C7FFF - AC000 + 1 = C8000 -AC000 = 1C000

十进制：（1C000）₁₆ = （ 1 × 16⁴ + 12 × 16³ ）÷ 1024 =（ 1 × 16⁴ + 12 × 16³ ）÷ （ 4 × 16²） = 16 × 4 + 3 × 16 = 112

单元存储数量：

112 × 16 ÷ 28 × 16 = 4

更新时间：2023年10月18日 13:11:21

存储管理

分页存储管理

进程P有6个页面，页号为0~5，页面大小为4K，页面变换表如下所示。表中状态位等于1和0分别表示页面存在内存和不存在内存。假设系统给进程P分配了4个存储块，进程P要访问的逻辑地址为十六进制5A29H，那么该地址经过变换后，其物理地址应为十六进制（1）；如果进程P要访问的页面4不在内存，那么应该淘汰页号为（2）的页面。

页号	页帧号	状态位	访问位	修改位
0	2	1	1	0
1	3	1	0	1
2	5	1	1	0
3	-	0	0	0
4	-	0	0	0
5	6	1	1	1

（1）A. 1A29H B. 3A29H C. 5A29H D. 6A29H

（2）A. 0 B. 1 C. 2 D. 5

（1）查表可知：页号5对应的物理块号为6，十六进制为：6H，把原来的5A29H中的5换成6即可（因为其页内地址不变），即最终物理地址为：6A29H

（2）查表可知：在内存的页有0、1、2、5，被访问过的页有1、2、5，被淘汰的页首先必须在内存中，淘汰的页号是最近没有被访问的页号，最后是没有修改的页号，即应该淘汰的页号为：1

更新时间：2023年10月18日 18:12:22

页面置换算法

假设系统为某进程分配了三个内存块，并考虑到有以下页面号引用串（会依次访问这些页面）：7，0，1，2，0，3，0，4，2，3，0，3，2，1，2，0，1，7，0，1

最佳置换算法（OPT，optimal）：每次选择淘汰的是以后永不使用，或者在最长时间内不再被访问的页面，这样可以保证最低的缺页率。

访问页面	7	0	1	2	0	3	0	4	2	3	0	3	2	1	2	0	1	7	0	1
内存块1	7	7	7	2		2		2			2			2				7
内存块2		0	0	0		0		4			0			0				0
内存块3			1	1		3		3			3			1				1
是否缺页	√	√	√	√		√		√			√			√				√

更新时间：2023年10月18日 18:37:21

输入输出技术

计算机系统中常用的输入/输出控制方式有无条件传送、中断、程序查询和DMA方式等。当采用（）方式时，不需要CPU执行程序指令来传送数据。

中断
程序查询
无条件传送
DMA

程序控制输入输出方法主要有四种：

中断
程序查询：利用查询方式进行输入/输出，就是通过CPU执行程序来查询外设的状态，判断外设是否准备好接收数据或准备好向CPU输入数据。根据这种状态，CPU有针对地为外设的输入/输出服务。
无条件传送：可以无条件地随时接收CPU发来的输出数据，也能够无条件地随时向CPU提供需要的输入数据。
DMA（直接内存存取）：是指数据在内存与I/O设备间的直接成块传送，即在内存与I/O设备间传送一个数据块的过程，不需要CPU的任何干涉，是一种完全由DMA硬件完成I/O操作的方式。

更新时间：2023年10月20日 10:49:55

校验码

以下关于检验码的叙述中，正确的是（ A ）。（2009下半年）

海明码利用多组数位的奇偶性来检错和纠错
海明码的码距必须大于等于1
循环冗余校验码具有很强的检错和纠错能力
循环冗余校验码的码距必定为1

海明码的码距必须大于1，等于2可以检错，大于等于3可能纠错

循环冗余校验码的码距等于2，只能检错，不能纠错

更新时间：2023年10月20日 11:10:49

奇偶校验码

以下关于采用奇偶校验方法的叙述中，正确的是（ C ）。（2018年下半年）

若所有奇数位出错，则可以检测出错误但无法纠正错误
若所有偶数位出错，则可以检测出错误并加以纠正
若有奇数个数据位出错，则可以检测出该错误但无法纠正错误
若有偶数个数据位出错，则可以检测出该错误并加以纠正

奇偶校验码的码距为2 ，所以可以检出1位错或奇数位错，无纠错能力。

更新时间：2023年10月20日 13:14:12

海明码

以下关于海明码的叙述中，正确的是（ A ）

海明码利用奇偶性进行检错和纠错
海明码的码距为1
海明码可以检错不能纠错
海明码中数据位的长度必须与校验位相同

已知数据信息为16位，最少应附加（）位校验位，已实现海明码纠错。（2016年下半年）

2^k -4 ≥ 16 +k

2^k - k ≥ 20

k ≥ 5

海明码（Hamming Code）是由贝尔实验室的Richard Hamming设计的，是一种利用奇偶性来检错和纠错的校验方法。海明码的构成方法是在数据之间的特定位置上插入k个校验位，通过扩大码距来实现检错和纠错。

设数据位为 n 位，校验位是 k 位，则 n 和 k 必须满足以下关系：

更新时间：2023年10月20日 11:01:35

海明码利用奇偶性检错和纠错，通过在n个数据位之间插入k个校验位，扩大数据编码的码距。若 n=48，则 k 应该（至少）为（ 6 ）。（2014年上半年）
已知数据信息为16位，至少应附加（ 5 ）位校验位，以实现海明纠错码。（2016年下半年）

以10位数据为例，其海明码表示为D₉D₈D₇D₆D₅D₄P₄D₃D₂D₁P₃D₀P₂P₁中，其中D_i（0 ≤ i ≤ 9）表示数据位，P_j（1 ≤ j ≤ 4）表示检验位，数据位D₉由P₄、P₃和P₂进行校验（从右至左D₉的位序为14，即等8+4+2，因此用第8位的P₄、第4位的P₃和第2位的P₂校验），数据位D₅由（ B ）进行校验。（2018年上半年）

P₄P₁
P₄P₂
P₄P₃P₁
P₃P₂P₁

D₉	D₈	D₇	D₆	D₅	D₄	P₄	D₃	D₂	D₁	P₃	D₀	P₂	P₁
14	13	12	11	10	9	8	7	6	5	4	3	2	1

D₅ P₄ P₂

10 = 8 + 2

更新时间：2023年10月21日 15:40:58

RISC与CISC

	RISC（精简指令计算机）	CISC（复杂指令计算机）
指令种类	少、精简	多、丰富
指令复杂度	简单	复杂
指令长度	固定	变化
寻址方式	少	复杂多样
（译码）实现方式	硬布线控制逻辑（组合逻辑控制器）	微程序控制技术
通用寄存器数量	多、大量	一般
流水线技术	适合	不适合

系统开发基础知识点题型

Wed, 11 Oct 2023 16:12:26 +0800

软件容错技术

冗余技术通常分为4类，其中（）按照工作方法可以分为静态、动态和混合冗余。

冗余技术一般包括时间冗余、信息冗余、结构冗余和冗余附加技术，其中结构冗余按照工作方法可以分为静态、动态和混合冗余。

更新时间：2023年10月11日 16:38:49

操作系统知识点题型

Wed, 11 Oct 2023 16:06:59 +0800

死锁资源数计算

某系统中仅有5个并发进程竞争某类资源，且都需要3个该类资源，那么至少有（）个该类资源，才能保证系统不会发生死锁。

题目告诉我们有5个并发进程，且都需要3个资源，那么最坏的情况就是，每个进程都获得了比需要少一个的资源，即5个进程都分配了2个资源，如果这个时候，系统还有多的一个资源，那么无论分给那个进程，都不会死锁，这个时候是11个资源。因此系统只要有11个资源，那么无论怎么分配资源都不会死锁。

更新时间：2023年10月11日 16:38:35

计算机网络知识点题型

Wed, 11 Oct 2023 13:09:47 +0800

子网划分与路由汇聚

分配给某公司的网络地址是210.115.192.0/20，该网络可以被划分为（）个C类子网，该公司的子网地址是（）。

IP：210.115.192.1

IP：11010010.01110011.11000000.00000000

子网掩码：255.255.255.0/24

子网掩码：11111111.11111111.11111111.00000000

子网掩码：255.255.240.0/20

子网掩码：11111111.11111111.11110000.00000000/20

子网数=2^24-20=16

子网范围：192~192+2⁰+2¹+2²=192~207

由于分配给公司网络的地址块是210.115.192.0/20，C类子网网络号24位，留给子网掩码的比特数只有4位，所以只能划分为2⁴=16个C类子网。

分析IP地址块：210.115.192.0/20，网络号有20位。前2段220.115.共有16位二进制，一定在网络号范围，主要分析的是第三段192，转换为二进制结果即为1100 0000。可以将该IP写作210.115.1100 0000.0000 0000，前20位是网络号，后12位是主机号。注意：此处有2个0是网络号部分，不是主机号部分。

接着将这个地址块划分为C类地址，网络号需要24位，扩展了4位子网号，子网号是从主机号分出来的，新的IP地址结构为：原网络号+子网号+主机号，即210.115.1100 0000.0000 0000，只有中间的4个0才是子网号变化的范围，取值为0000-1111，综合其他数值也就是210.115.1100 0000.0000 0000 -210.115.1100 1111.0000 0000，也就是210.115.192.0-210.115.207.0范围。

220.17.192.0/20需要划分成标准的C类子网，其子网掩码长度应该扩长到24位，增加了4比特的网络位，可以产生2^4=16个标准C类子网。对于220.17.192.0/20网络，前两段八位组是网络位，第三段8位组中有4位是网络位，我们把第IP八位组第三段用二进制展开是192=1100 0000，后四位可以变化的值是0000~1111，亦即子网位变化值，与前四位合并后是1100 0000~1100 1111，转换成十进制为192~207，所以220.17.192.0/20得出的划分成16个标准C类子网是：

220.17.192.0/24，220.17.193.0/24，220.17.194.0/24，220.17.195.0/24，220.17.196.0/24，220.17.197.0/24，220.17.198.0/24，220.17.199.0/24，220.17.200.0/24，220.17.201.0/24，220.17.202.0/24，220.17.203.0/24，220.17.204.0/24，220.17.205.0/24，220.17.206.0/24，220.17.207.0/24。

IP地址根据网络号和主机号来分，分为A、B、C三类及特殊地址D、E。全0和全1的都保留不用。

A类：(1.0.0.0-126.0.0.0)（默认子网掩码：255.0.0.0或 0xFF000000）第一个字节为网络号，后三个字节为主机号。该类IP地址的最前面为“0”，所以地址的网络号取值于1~126之间。一般用于大型网络。

B类：(128.0.0.0-191.255.0.0)（默认子网掩码：255.255.0.0或0xFFFF0000）前两个字节为网络号，后两个字节为主机号。该类IP地址的最前面为“10”，所以地址的网络号取值于128~191之间。一般用于中等规模网络。

C类：(192.0.0.0-223.255.255.0)（子网掩码：255.255.255.0或 0xFFFFFF00）前三个字节为网络号，最后一个字节为主机号。该类IP地址的最前面为“110”，所以地址的网络号取值于192~223之间。一般用于小型网络。

D类：是多播地址。该类IP地址的最前面为“1110”，所以地址的网络号取值于224~239之间。一般用于多路广播用户[1] 。

E类：是保留地址。该类IP地址的最前面为“1111”，所以地址的网络号取值于240~255之间。

在IP地址3种主要类型里，各保留了3个区域作为私有地址，其地址范围如下：

A类地址：10.0.0.0～10.255.255.255

B类地址：172.16.0.0～172.31.255.255

C类地址：192.168.0.0～192.168.255.255

更新时间：2023年10月11日 15:44:34

Go实战（篇三）使用接口封装SQL操作

Wed, 10 Aug 2022 14:14:04 +0800

图片待插入

引言

在C++中，通过使用关键字public、protected和private实现对类的封装和继承。其中public和private实现了类的封装，protected实现了类的继承。在Java中，类的修饰添加了两个个关键字default和friendly。其中default同一包中的类可以访问，声明时没有加修饰符，认为是friendly。比较内容见表1。

表1 关键字比较
	C++	Java	C#	Go
public	可以被该类中的函数、子类的函数、友元函数访问，也可以由该类的对象访问	具有最大的访问权限，可以访问任何一个在classpath下的类、接口、异常等。它往往用于对外的情况，也就是对象或类对外的一种接口的形式。	公有访问，不受任何限制。	Go的关键字中没有public
private	可以被该类中的函数、子类的函数、友元函数访问，但不可以由该类的对象访问	访问权限仅限于类的内部，是一种封装的体现，例如，大多数成员变量都是修饰符为private的，它们不希望被其他任何外部的类访问。	私有访问，只限于本类成员访问，子类、实例都不能访问。	Go的关键字中没有private
protected	可以被该类中的函数、友元函数访问，但不可以由子类的函数、该类的对象、访问	主要的作用就是用来保护子类的。它的含义在于子类可以用它修饰的成员，其他的不可以，它相当于传递给子类的一种继承的东西	保护访问，只限于本类和子类访问，实例不能访问。	Go的关键字中没有protected
internal	C++的关键字中没有interface	用于声明仅包含抽象方法的特殊类型的类	内部访问，只限于本项目内访问，其他不能访问。	Go的关键字中没有internal
default	通过default关键字恢复构造函数	有时候也称为friendly，它是针对本包访问而设计的，任何处于本包下的类、接口、异常等，都可以相互访问，即使是父类没有用protected修饰的成员也可以。	C#的关键字中没有default，这里不讨论switch语句。	Go的关键字中没有default

为什么要进行封装

提到封装的好处，我们想从函数说起。在我们学习计算机编程语言时，是不是习惯将一系列操作全部写在main函数中。在学到函数章节时，才会开始尝试并习惯将不同的操作写在不同的函数中。函数的使用，可以提高编码效率，较少定位错误的时间。在面对对象编程中，一个对象涉及多个变量和方法，在对象内部函数不受限制。对对象进行封装，使用者就不必关注方法是如何实现的。封装的好处如下：

提高了数据的安全性：调用者不能够通过变量名、属性名的方式来修改某个私有的成员属性
操作简单：封装后，调用者在使用的时候，只需调用方法即可，调用者不需要再进行判断
隐藏了实现：实现过程对调用者是不可见的，调用者只需调用方法即可，不知道具体实现过程

代码实现

数据库表结构如表2所示。

表2 user_login_info表
名字	类型	排序规则	属性	空	默认	额外
userID	int(10)		UNSIGNED	否	无	AUTO_INCREMENT
userNum (主键)	varchar(20)	uft8mb4_general_ci		否	无
userPhone	varchar(11)	uft8mb4_general_ci		是	NULL
userMail	varchar(50)	uft8mb4_general_ci		是	NULL
userPwd	varchar(32)	uft8mb4_general_ci		否	无
userRole	varchar(7)	uft8mb4_general_ci		是	NULL
userLockTime	time			是	NULL
created	timestamp			否	CURRENT_TIMESTAMP
updated	timestamp			否	CURRENT_TIMESTAMP	ON UPDATE CURRENT_TIMESTAMP

sqlhelper的代码如下：

package toolkit

import (
   "database/sql"
   "fmt"
   _ "github.com/go-sql-driver/mysql"
   "log"
   "time"
)

const (
   USERNAME = ""
   PASSWORD = ""
   NETWORK  = "tcp"
   SERVER   = "127.0.0.1"
   PORT     = 3306
   DATABASE = ""
)

type Search interface {
   UserLogin(account string, password string, actype int) bool
   UserRegister(account string, password string, actype int) bool
   UserUpdate(account string, password string, actype int) bool
   UserCancel(account string, password string, actype int) bool
}

type User struct {
}

func (user User) UserInfo() {

}

func (user User) UserLogin(account string, password string, actype int) bool {
   db := open()
   defer db.Close()
   var sql string
   switch actype {
   case 0:
      sql = fmt.Sprintf("select userNum,userPwd from user_login_info where userNum ='%s' and userPwd = '%s';", account, password)
   case 1:
      sql = fmt.Sprintf("select userNum,userPwd from user_login_info where userPhone ='%s' and userPwd = '%s';", account, password)
   case 2:
      sql = fmt.Sprintf("select userNum,userPwd from user_login_info where userMail ='%s' and userPwd = '%s';", account, password)
   }
   rows, err := db.Query(sql)
   if err != nil {
      fmt.Println("query failed:", err)
      return false
   }
   for rows.Next() {
      var userNum, userPasswd string
      err = rows.Scan(&userNum, &userPasswd)
      //err = rows.Scan(&infos.fileID, &infos.fileName, &infos.fileSize, &infos.fileSource, &infos.filePayment, &infos.fileDownloads, &infos.userID, &infos.created, &infos.updated)
      if err != nil {
         fmt.Println("scan failed:", err)
      }
      if userNum == account && userPasswd == password {
         return true
      }
   }

   return false
}

func (user User) UserRegister(account string, password string, actype int) bool {
   db := open()
   defer db.Close()
   var sql string
   switch actype {
   case 0:
      sql = fmt.Sprintf("select 1 from user_login_info where userNum ='%s' limit 1;", account)
   case 1:
      sql = fmt.Sprintf("select 1 from user_login_info where userPhone ='%s' limit 1;", account)
   case 2:
      sql = fmt.Sprintf("select 1 from user_login_info where userMail ='%s' limit 1;", account)
   }
   rows, err := db.Query(sql)
   if err != nil {
      fmt.Println("query failed:", err)
      return false
   }
   num := 0
   for rows.Next() {
      err = rows.Scan(&num)
      if err != nil {
         fmt.Println("scan failed:", err)
      }

      fmt.Println(num)
   }
   var operation Operation
   if num == 1 {
      operation = new(Record)
      operation.Writer(fmt.Sprintf("user %s register fault at %s, because it exist", account, time.Now().Format("20060102")))
      return false
   } else {
      sql := fmt.Sprintf("insert into user_login_info (userNum,userPwd) values ('%s','%s')", account, password)
      _, err := db.Exec(sql)

      if err != nil {
         operation = new(SQL_ERROE_SAVEPATH)
         operation.Writer(err.Error() + "," + time.Now().Format("20060102"))
         return false
      }
      operation = new(Record)
      operation.Writer(fmt.Sprintf("user %s register successful at %s", account, time.Now().Format("20060102")))
      return true
   }

   return false
}

func (user User) UserUpdate(account string, password string, actype int) bool {
   db := open()
   defer db.Close()
   if user.UserLogin(account, password, actype) == true {
      return false
   }

   var sql string
   switch actype {
   case 0:
      sql = fmt.Sprintf("update user_login_info set userPwd ='%s' where userNum ='%s';", password, account)
   case 1:
      sql = fmt.Sprintf("update user_login_info set userPwd ='%s' where userPhone ='%s';", password, account)
   case 2:
      sql = fmt.Sprintf("update user_login_info set userPwd ='%s' where userMail ='%s';", password, account)
   }
   result, err := db.Exec(sql)
   if err != nil {
      fmt.Println("update fault:", err)
      return false
   }
   idAff, err := result.RowsAffected()
   if err != nil {
      log.Println("RowsAffected failed:", err)
      return false
   }

   if idAff == 0 {
      return false
   }

   return true
}

func (user User) UserCancel(account string, password string, actype int) bool {
   db := open()
   defer db.Close()
   if user.UserLogin(account, password, actype) == false {
      return false
   }
   var sql string
   switch actype {
   case 0:
      sql = fmt.Sprintf("delete from user_login_info where userNum ='%s';", account)
   case 1:
      sql = fmt.Sprintf("delete from user_login_info where userPhone ='%s';", account)
   case 2:
      sql = fmt.Sprintf("delete from user_login_info where userMail ='%s';", account)
   }
   result, err := db.Exec(sql)
   if err != nil {
      fmt.Println("delete fault:", err)
      return false
   }
   idAff, err := result.RowsAffected()
   if err != nil {
      log.Println("RowsAffected failed:", err)
      return false
   }
   if idAff == 0 {
      return false
   }

   return true
}

func open() *sql.DB {
   conn := fmt.Sprintf("%s:%s@%s(%s:%d)/%s", USERNAME, PASSWORD, NETWORK, SERVER, PORT, DATABASE)
   //fmt.Println("conn:", conn)

   db, err := sql.Open("mysql", conn)

   if err != nil {
      fmt.Println("connection to mysql fault:", err)
      return db
   }
   db.SetConnMaxLifetime(100 * time.Second)
   db.SetMaxOpenConns(100)
   return db

}

以登陆为例，代码如下：

account := "account"
password := "password"
actype := "actype"
var search Search
search = new(User)
loginsuc := search.UserLogin(account, password, actypeInt)
fmt.Println(loginsuc)

写在最后的话

以上就是接口封装SQL操作的介绍了，暂时先写这么多，后面也会进行完善。

你知道的越多，你不知道的越多，人才们的【三连】就是我创作的最大动力，我们下期见！

注：如果本篇博客有任何错误和建议，欢迎人才们留言，你快说句话啊！

Go实战（篇二）使用接口构建对象

Tue, 09 Aug 2022 20:30:28 +0800

什么是接口？

面向对象编程(OOP)中三个基本特征分别是封装，继承，多态。在 Go 语言中封装和继承是通过 struct 来实现的，而多态则是通过接口(interface)来实现的。

接口是一种重要的实现运行时多态的方式，也是一种协议。它规范了传入的对象所必须具备的某些特征，从而保证在调用时既不会发生错误又不需要提前检查。虽然继承也能起到相同的效果，但是很多场景下使用继承会导致逻辑关系混乱，不利于抽象。

高级语言	C#
定义	接口定义协定。实现该协定的任何 class 或 struct 必须提供接口中定义的成员的实现。从 C# 8.0 开始，接口可为成员定义默认实现。它还可以定义 static 成员，以便提供常见功能的单个实现。从 C# 11 开始，接口可以定义 static abstract 或 static virtual 成员来声明实现类型必须提供声明的成员。通常，static virtual 方法声明实现必须定义一组重载运算符
接口示例	interface ISampleInterface { void SampleMethod(); } class ImplementationClass : ISampleInterface { // Explicit interface member implementation: void ISampleInterface.SampleMethod() { // Method implementation. } static void Main() { // Declare an interface instance. ISampleInterface obj = new ImplementationClass(); // Call the member. obj.SampleMethod(); } }

高级语言	C++
定义	所谓的接口，即将内部实现细节封装起来，外部用户用过预留的接口可以使用接口的功能而不需要知晓内部具体细节。C++中，通过类实现面向对象的编程，而在基类中只给出纯虚函数的声明，然后在派生类中实现纯虚函数的具体定义的方式实现接口，不同派生类实现接口的方式也不尽相同，从而实现多态。
接口示例	#include <iostream> using namespace std; class Shape { public: // 提供接口框架的纯虚函数 virtual int getArea() = 0; void setWidth(int w) { width = w; } void setHeight(int h) { height = h; } protected: int width; int height; }; // 派生类 class Rectangle: public Shape { public: int getArea() { return (width * height); } }; class Triangle: public Shape { public: int getArea() { return (width * height)/2; } };

如何使用接口？

在面向对象编程(OOP)中，我们用不同类型的变量描述一个对象，使用关键字“new”创建对象，随后使用该变量引用该对象的公开方法。

在Go语言中，也有类似的方法可以用接口实现。声明一个human结构体，并构造Human接口实现Get、Set和Say方法，代码如下：

package main

import (
   "fmt"
)

//创建Human接口
//这里实现的接口类似OOP中的“public”关键字
type Human interface {
   //这里用类进行描述
   //Set一个human类，并返回该类型。如果没有返回，这个类的属性全部为空
   Set(name string, sex string, age int) human
   //Get方法，获取name属性
   Name() string
   //Get方法，获取sex属性
   Sex() string
   //Get方法，获取age属性
   Age() int
   //Say方法，输出对象的值
   Say(h human)
}

type human struct {
   name string
   sex  string
   age  int
}

func (h human) Set(name string, sex string, age int) human {
   h.name = name
   h.sex = sex
   h.age = age
   return h
}

func (h human) Name() string {
   return h.name
}

func (h human) Sex() string {
   return h.sex
}

func (h human) Age() int {
   return h.age
}

func (h human) Say(hu human) {
   fmt.Printf("I'm a %d-year-old %s,my name is %s.\n", hu.age, hu.sex, hu.name)
}

func main() {

   //创建接口，可以看成new出一个无参对象
   //因为接口中不存在参数，所以这里使用的是一个human类型，而不是对象
   method := Human(new(human))
   hu := method.Set("Bob", "boy", 25)
   fmt.Printf("I'm a %d-year-old %s,my name is %s.\n", hu.age, hu.sex, hu.name)
   hu.Say(method.Set("Alice", "girl", 24))
   fmt.Printf("I'm a %d-year-old %s,my name is %s.\n", hu.age, hu.sex, hu.name)

}

/*
输出的结果为：
I'm a 25-year-old boy,my name is Bob.
I'm a 24-year-old girl,my name is Alice.
I'm a 25-year-old boy,my name is Bob.

*/

写在最后的话

以上就是Go语言操接口的介绍了，暂时先写这么多，后面也会进行完善。

你知道的越多，你不知道的越多，人才们的【三连】就是我创作的最大动力，我们下期见！

注：如果本篇博客有任何错误和建议，欢迎人才们留言，你快说句话啊！

参考：

Go实战（篇一）数据库相关操作

Thu, 28 Jul 2022 10:31:27 +0800

数据库相关操作

在信息时代，数据库技术成为软件设计与开发必不可少一部分。下面对GO连接数据库做出详细介绍。

1 配置环境

选择环境如下：

操作系统：Ubuntu 22.04LTS x64
sdk版本：go version go1.18.4 linux/amd64

在官网下载sdk，下载完成后解压到指定目录，在这里不对sdk的安装再做赘述，可参考文章如下文章：

Go学习笔记（篇一）配置Go开发环境_Go_轩哲驿站 (xuanzhe.club)

在这里需要额外添加一条环境变量，所有的环境变量如下：

# 指定sdk的目录
export GOROOT=/opt/sdk/go
# 指定gopath的目录，用来表明你写的go项目的存放路径
export GOPATH=/opt/sdk/go/gopath

export PATH=$PATH:$GOROOT/bin
# 设置GOPROXY的代理
export GOPROXY=https://goproxy.cn,direct

在/etc/profile文件添加以上内容后，输入命令：

# 重载环境变量，让新添加的内容生效
source /etc/profile

检查配置是否生效，需要输入go version，显示安装的sdk版本表明系统已成功部署Go语言开发环境；输入go env，相应的变量有对应的值，打印的内容如下：

GO111MODULE=""
GOARCH="amd64"
GOBIN=""
GOCACHE="/home/userName/.cache/go-build"
GOENV="/home/userName/.config/go/env"
GOEXE=""
GOEXPERIMENT=""
GOFLAGS=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOINSECURE=""
GOMODCACHE="/opt/sdk/go/gopath/pkg/mod"
GONOPROXY=""
GONOSUMDB=""
GOOS="linux"
#已载入GOPATH环境变量
GOPATH="/opt/sdk/go/gopath"
GOPRIVATE=""
#已载入GOPOXY环境变量
GOPROXY=""
#已载入GOROOT环境变量
GOROOT="/opt/sdk/go"
GOSUMDB="sum.golang.org"
GOTMPDIR=""
GOTOOLDIR="/opt/sdk/go/pkg/tool/linux_amd64"
GOVCS=""
GOVERSION="go1.18.4"
GCCGO="gccgo"
GOAMD64="v1"
AR="ar"
CC="gcc"
CXX="g++"
CGO_ENABLED="1"
GOMOD="/dev/null"
GOWORK=""
CGO_CFLAGS="-g -O2"
CGO_CPPFLAGS=""
CGO_CXXFLAGS="-g -O2"
CGO_FFLAGS="-g -O2"
CGO_LDFLAGS="-g -O2"
PKG_CONFIG="pkg-config"
GOGCCFLAGS="-fPIC -m64 -pthread -fmessage-length=0 -fdebug-prefix-map=/tmp/go-build4047345889=/tmp/go-build -gno-record-gcc-switches"

2 启动Goland

完成环境配置后，启动Goland，在这里不对Goland的安装和激活进行详细介绍，可以通过Ubuntu的软件商城快速安装。（中文可以在File->Settings->Plugins->Marketplace中搜索Chinese，选中搜索结果中的”Chinese(Simplified)Language Pack/中文语言包“进行安装）

新建Go项目，确定项目信息后，点击创建。创建的目录结构如下：

├─awesomeProject

│ ├─main

│ ├─toolkit

│ │ ├─sqlhelper

│ ├─go.mod

├─项目名称

│ ├─main包，一般有且只有一个，放置main.go

│ ├─toolkit包，一般将项目内的文件夹称为包

│ │ ├─sqlhelper包，处理sql操作的集合

│ ├─go.mod一个Modules，是相关Go包的集合

3 添加依赖

这里的数据库选择的是MySQL，安装的依赖包是github.com/go-sql-driver/mysql。在终端输入如下命令：

#可以优先切换权限使用su命令，避免创建目录时出现权限不足
#出现“su 认证失败”，是因为root用户默认是锁定的，输入“sudo passwd root”修改密码
go get github.com/go-sql-driver/mysql
# 可能需要的操作
# 生成 mod 文件（切换到模块根目录）
go mod init modulename
# 清理无效依赖，增加缺失依赖
go mod tidy

4 编写代码

在sqlhelper包创建command.go，用于统一管理sql命令；在main包创建main.go，作为程序的入口。

以下代码仅作为展示，部分代码没有按照规范进行缩进、命名和重用，数据库也没有做出约束，command.go的代码如下：

package sqlhelper

import (
	"database/sql"
	"fmt"
	_ "github.com/go-sql-driver/mysql"
	"time"
)

const (
	USERNAME = ""
	PASSWORD = ""
	NETWORK  = "tcp"
	SERVER   = "127.0.0.1"
	PORT     = 3306
	DATABASE = ""
)

type FileInfo struct {
	fileID        int
	fileName      string
	fileSize      string
	fileSource    string
	fileState     string
	filePayment   int
	fileDownloads int
	userID        int
	created       string
	updated       string
}

func Open() *sql.DB {
	conn := fmt.Sprintf("%s:%s@%s(%s:%d)/%s", USERNAME, PASSWORD, NETWORK, SERVER, PORT, DATABASE)
	fmt.Println("conn:", conn)

	db, err := sql.Open("mysql", conn)

	if err != nil {
		fmt.Println("connection to mysql fault:", err)
		return db
	}
	db.SetConnMaxLifetime(100 * time.Second)
	db.SetMaxOpenConns(100)
	return db

}

func CreateTable(db *sql.DB) {
	if db == nil {
		fmt.Println("db is not init or open")
		return
	}
	sql := "CREATE TABLE NewTable (" +
		"userNum varchar(10) NULL," +
		"userPasswd varchar(32) NULL," +
		"created TIMESTAMP DEFAULT CURRENT_TIMESTAMP," +
		"updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP on update CURRENT_TIMESTAMP )" +
		"ENGINE=InnoDB " +
		"DEFAULT CHARSET=gbk " +
		"COLLATE=gbk_chinese_ci;"
	_, err := db.Exec(sql)
	if err != nil {
		fmt.Println("create table failed:", err)
		return
	}
	fmt.Println("create table successful !")
}

func DeleteTable(db *sql.DB) {
	if db == nil {
		fmt.Println("db is not init or open")
		return
	}
	sql := "DROP TABLE NewTable;"
	_, err := db.Query(sql)
	if err != nil {
		fmt.Println("delete table failed:", err)
		return
	}
	fmt.Println("delete table successful !")
}

func QueryUser(db *sql.DB) {
	if db == nil {
		fmt.Println("db is not init or open")
		return
	}
	sql := "select userNum,userPasswd from NewTable"
	rows, err := db.Query(sql)
	if err != nil {
		fmt.Println("query failed:", err)
		return
	}
	for rows.Next() {
		var userNum, userPasswd string
		err = rows.Scan(&userNum, &userPasswd)
		//err = rows.Scan(&infos.fileID, &infos.fileName, &infos.fileSize, &infos.fileSource, &infos.filePayment, &infos.fileDownloads, &infos.userID, &infos.created, &infos.updated)
		if err != nil {
			fmt.Println("scan failed:", err)
		}

		fmt.Println(userNum, userPasswd)
	}
}

func InsertUser(db *sql.DB) {
	if db == nil {
		fmt.Println("db is not init or open")
		return
	}
	sql := "INSERT INTO NewTable" +
		"(userNum, userPasswd, created, updated)" +
		"VALUES('0123456789', '0123456789', NULL, NULL);"
	_, err := db.Exec(sql)
	if err != nil {
		fmt.Println("insert failed:", err)
		return
	}
	fmt.Println("insert a date successful !")

	data := []map[string]string{
		{"userNum": "test1", "userPasswd": "0123456789"},
		{"userNum": "test2", "userPasswd": "0123456789"},
		{"userNum": "test3", "userPasswd": "0123456789"},
		{"userNum": "test4", "userPasswd": "0123456789"},
		{"userNum": "test5", "userPasswd": "0123456789"},
	}

	//insert more data
	var sqls string
	for i := range data {
		sqls = "INSERT INTO NewTable" +
			"(userNum, userPasswd, created, updated) VALUES(" +
			"'" + data[i]["userNum"] + "', " +
			"'" + data[i]["userPasswd"] + "', " +
			"NULL, NULL);"
		//fmt.Println(data[i]["userNum"], data[i]["userPasswd"])
		_, err = db.Exec(sqls)
		if err != nil {
			fmt.Println("insert data fault:", err)
			return
		}
	}

	fmt.Println("insert data successful !")
}

func UpdateUser(db *sql.DB) {
	if db == nil {
		fmt.Println("db is not init or open")
		return
	}

	sql := "UPDATE NewTable set userNum='newName' where userNum='test4';"

	_, err := db.Exec(sql)
	if err != nil {
		fmt.Println("update fault:", err)
		return
	}
	fmt.Println("update date successful !")
}

func DeleteUser(db *sql.DB) {
	if db == nil {
		fmt.Println("db is not init or open")
		return
	}
	sql := "DELETE FROM NewTable where userNum='0123456789';"

	_, err := db.Exec(sql)
	if err != nil {
		fmt.Println("delete fault:", err)
		return
	}
	fmt.Println("delete date successful !")

}

在main函数中进行调用，代码如下：

package main

import (
	"database/sql"
	"fmt"
	"awesomeProject/toolkit/sqlhelper"
)

func main() {
	fmt.Println("open sql connection")
	var DB *sql.DB
	DB = sqlhelper.Open()

	sqlhelper.CreateTable(DB)

	sqlhelper.InsertUser(DB)

	sqlhelper.QueryUser(DB)

	sqlhelper.UpdateUser(DB)

	sqlhelper.DeleteUser(DB)

	sqlhelper.DeleteTable(DB)

	defer DB.Close()
}

5 可能会遇到的问题

1)数据库连接信息正确，出现Connection refused

检查mysqld服务是否正常启动

# 检查mysqld服务状态
service mysqld status
# 启动mysqld服务
service mysqld start
# 关闭mysqld服务
service mysqld stop

写在最后

以上就是Go语言操作MySQL的介绍了，暂时先写这么多，后面也会进行完善。

你知道的越多，你不知道的就越多，人才们的【三连】就是我创作的最大动力，我们下期见！

注：如果本篇博客有任何错误和建议，欢迎人才们留言，你快说句话啊！

Go学习笔记（篇四）流程控制

Tue, 26 Jul 2022 10:06:38 +0800

流程控制

1 条件语句

GO编程语言中if的语法如下：

if 布尔表达式 {
  /*在布尔表达式为true时执行*/
}

if 在布尔表达式为 true 时，其后紧跟的语句块执行，如果为 false 则不执行。

实例如下，用if比较两个数的大小：

package main

import "fmt"

func main() {
   var a, b int

   fmt.Scanf("%d %d", &a, &b)

   if a > b {
      fmt.Printf("%d>%d\n", a, b)
   } else if a == b {
      fmt.Printf("%d=%d\n", a, b)
   } else {
      fmt.Printf("%d<%d\n", a, b)
   }
}

关于条件语句，需要注意以下几点：

布尔表达式不需要使用括号将条件包含起来；
不论语句体内有几条语句，花括号{ }都是必须存在的；
左花括号 { 必须与if或者else处于同一行；
在if之后，布尔表达式之前，可以添加变量初始化语句，使用 ; 间隔；
在具有返回值的函数中，不允许return语句出现在if……else……结构中；

2 选择语句

根据传入条件的不同，选择语句会执行不同的语句。

实例如下，判断变量中储存的数据类型：

package main

import "fmt"

func valueType(value interface{}) {

   switch i := value.(type) {
   case nil:
      fmt.Println("变量的类型是", i)
   case int:
      fmt.Println("变量的类型是int型")
   case float64:
      fmt.Println("变量的类型是float64型")
   case func(int) float64:
      fmt.Println("变量的类型是func(int)型")
   case bool:
      fmt.Println("变量的类型是bool型")
   case string:
      fmt.Println("变量的类型是string型")
   default:
      fmt.Println("未知")
   }
}

func main() {
   a := 32
   b := 32.2
   c := "32"
   d := false
   var e interface{}
   valueType(a)
   valueType(b)
   valueType(c)
   valueType(d)
   valueType(e)
}

/*
打印结果如下：
变量的类型是int型
变量的类型是float64型
变量的类型是string型
变量的类型是bool型
变量的类型是 <nil>
*/

关于条件语句，需要注意以下几点：

左花括号 { 必须与switch处于同一行；
条件表达式不限制为常量或者整数；
单个case中，可以出现多个结果选项；
不需要break来明确退出一个case；
只有在case中明确添加fallthrough关键字，才会继续执行下一个case；
不设定switch之后的条件表达式，这个switch结构与多个if……else……的逻辑作用等同。

3 循环语句

在GO语言编程中，循环语句只支持for关键字，不支持while和do-while结构。关键字for的基本使用方法与C/C++中非常接近，代码如下：

sum := 0
for i := 0; i < 10; i++ {
   fmt.Print(sum+i, " ")
}

在循环体中，如果条件语句永远不为false则会进行无限循环（俗称死循环）。

实例如下，数字累加至100后退出循环：

package main

import (
   "fmt"
)

func main() {
   sum := 0
   for true {
      sum++
      if sum == 100 {
         break
      }
   }
}

关于循环语句，需要注意以下几点：

左花括号 { 必须与for处于同一行
Go语言不支持以逗号为间隔的多个赋值语句，必须使用平行赋值的方法来初始化多个变量；
Go语言的for循环支持continue和break来控制循环，额外提供了更高级的break，可以选择中断哪一个循环。

实例如下，在一组二维整形数组中查找某个数：

package main

import (
   "fmt"
)

func main() {

   sum := [4][7]int{
      {58, 15, 26, 35, 48, 95, 41},
      {55, 32, 15, 25, 12, 9, 253},
      {96, 21, 6, 25, 84, 25, 100},
      {8, 106, 56, 85, 37, 66, 59}}
JLoop:
   for i := 0; i < 4; i++ {
      for j := 0; j < 7; j++ {
         fmt.Print(sum[i][j], " ")
         if sum[i][j] == 12 {
            break JLoop
         }
      }
   }
}
/*
打印结果如下：
58 15 26 35 48 95 41 55 32 15 25 12 
*/

4 跳转语句

在C语言中有goto跳转语句，一般在编写小游戏时经常使用，有来处理一些条件判断。在Go语言中也有goto关键字，虽然不主张使用goto，但在一些场合下被证明是最合适的。

goto语句的语义非常简单，就是跳转到本函数内的某个标签，在这里就不进行举例了。

参考：

Go 语言条件语句 | 菜鸟教程 (runoob.com)

Go学习笔记（篇三）数据类型

Mon, 25 Jul 2022 20:44:54 +0800

数据类型

Go语言内置以下这些类型：

表3-1 Go语言支持的数据类型
基础类型	关键字	复合类型
布尔类型	bool	指针（pointer）
整形	int8、byte、int16、unit、uintptr	数组（array）
浮点类型	float32、float64	切片（slice）
复数类型	complex64、complex128	字典（map）
字符串	string	通道（chan）
字符类型	rune	结构体（struct）
错误类型	error	接口（interface）

1 布尔类型

布尔类型不能接受其他类型的赋值，不支持自动或强制的类型转换。以下是bool类型的用法示例：

表3-2 bool类型的使用示例
正确用法	错误用法
var b bool b = (1!=0) fmt.Println("Result:",b) //打印结果为Result:true	var b bool b = 1 //错误编译 b = bool(1) //错误编译

2 整形

整形是所有编程语言里最基础的数据类型。Go语言支持的整形类型如下表所示：

表3-3 Go语言支持的整形类型
类型	长度（字节）	值范围
int8	1	-128 ~ 127
uint8（即byte）	1	0 ~ 225
int16	2	-32 768 ~ 32 767
uint16	2	0 ~ 65 535
int32	4	-2 147 483 648 ~ 2 147 483 647
uint32	4	0 ~ 4 294 967 295
int64	8	-9 223 372 036 854 775 808 ~ 9 223 372 036 854 775 807
int	平台相关	平台相关
uint	平台相关	平台相关
uintptr	同指针	在32位平台下为4字节，64位平台下为8字节

2.1 类型表示

int和int32在Go语言里被认为是两种不同的类型，编译器不会自动做类型转换，使用强制类型转换可以解决这个问题，但要注意数据损失和溢出的问题（在这里不做具体分析），样例如下：

表3-4 int类型表示用法
正确用法	错误用法
var v1 int32 v2 := 64 v1 = int32(v2) //编译正确	var v1 int32 v2 := 64 v1 = v2 //编译错误

2.2 数值运算

表3-5 Go语言支持的数值运算
符号	功能	例子
+	加法运算	6 + 3 = 9
-	减法运算	6 - 3 = 3
*	乘法运算	6 * 3 = 18
/	除法运算	6 / 3 = 2
%	取余运算	6 % 3 = 0

2.3 比较运算

Go语言支持以下的几种比较运算符：>、<、==、>=、<=和!=。和大多数其他编程语言相同，在这里就不做具体说明了。（需要注意的是不同类型的整形数不能直接比较，但可以直接与字面常量进行比较）

2.4 位运算

Go语言支持表3-6所示的运算符。

表3-6 Go语言支持的运算符
运算	含义	样例
x << y	左移	124 << 2 //结果为496
x >> y	右移	124 >> 2 //结果为31
x ^ y	异或	124 ^ 2 //结果为126
x & y	与	124 & 2 //结果为0
x \| y	或	124 \| 2 //结果为126
^x	取反	^124 //结果为-125

3 浮点型

浮点型用于表示包含小数点的数据，比如1.234就是一个浮点型数据。Go语言中的浮点类型采用IEEE-754标准的表达方式。

3.1 浮点数表示

Go语言定义了两个类型float32和float64，分别等价于C语言的float类型和double类型，样例如下：

var fvalue1 float 32
fvalue1 = 12
fvalue2 := 12.0 //如果不加小数点，fvalue2会被推导为整形
fvalue3 := float32(fvalue2) //必须使用强制类型转换，直接赋值将导致编译错误

3.2 浮点数比较

因为浮点数不是一种精确的表达方式，所以直接使用“==”来判断两个浮点数是否相等会导致不稳定的结果。下面是一种推荐的替代方案：

import "math"

4 复数类型

复数实际上由两个实数（在计算机中用浮点数表示）构成，一个表示实部（real），一个表示虚部（imag）。样例如下：

package main //必须有一个main包
 
import "fmt"
 
func main() {
    var cvalue1 complex128 //声明
    cvalue1  = 2.1 + 3.14i  //赋值
    fmt.Println("cvalue1  = ", cvalue1 )
 
    //自动推导类型
    cvalue2 := 3.3 + 4.4i
    fmt.Printf("cvalue2 type is %T\n", cvalue2)
 
    //通过内建函数，取实部和虚部
    fmt.Println("real(cvalue2) = ", real(cvalue2), ", imag(cvalue2) = ", imag(cvalue2))
 
}

5 字符串

在Go语言中，字符串也是一种基本类型。相比之下，C/C++语言并不存在原生的字符串类型，通常使用字符数组来表示，并以字符指针来传递。字符串的声明和使用的样例如下：

package main

import "fmt"

func main() {
   var str string
   str = "Hello world"
   fmt.Println(str)
}

字符串的内容可以用类似于数组下标的方式获取，但与数组不同，字符串的内容不能在初始化后被修改。

5.1 字符串操作

平时常用的字符串操作如表3-7所示。

表3-7 字符串操作方法对照表
运算	含义	样例
x + y	字符串连接	"Hello" + "World" // 结果为HelloWorld
len(str)	字符串长度	len("HelloWorld") // 结果为10
s[i]	取字符	"HelloWorld"[1] // 结果为'e'

5.2 字符串遍历

Go语言支持两种方式遍历字符串，样例如下表所示：

表3-8 字符串变量方法表
字节数组遍历	Unicode字节遍历
package main import "fmt" func main() { str := "Hello,世界" n := len(str) for i := 0 ; i < n ; i++ { fmt.Println(i, str[i]) } } /* 运行结果 0 72 1 101 2 108 3 108 4 111 5 44 6 228 7 184 8 150 9 231 10 149 11 140 */	package main import "fmt" func main() { str := "Hello,世界" for i , ch := range str{ fmt.Println(i, ch) } } /* 运行结果 0 72 1 101 2 108 3 108 4 111 5 44 6 19990 9 30028 */

表3-8 字符串变量方法表

字节数组遍历

Unicode字节遍历

package main

import "fmt"

func main() {
   str := "Hello,世界"
   n := len(str)
   for i := 0 ; i < n ; i++ {
      fmt.Println(i, str[i])
   }
}
/* 运行结果
0 72
1 101
2 108
3 108
4 111
5 44
6 228
7 184
8 150
9 231
10 149
11 140
*/

package main

import "fmt"

func main() {
   str := "Hello,世界"
   for i , ch := range str{
      fmt.Println(i, ch)
   }
}

/* 运行结果
0 72
1 101
2 108
3 108
4 111
5 44
6 19990
9 30028
*/

6 字符类型

在Go语言中支持两种字符类型，一个是byte（实际上是unit8的别名），代表UTF-8字符串的单个字节的值；另一个是rune，代表单个Unicode字符。

7 数组

数组是Go语言编程中最常用的数据结构之一。顾名思义，数组就是指一系列同一类型数据的集合。数组中包含的每个数据被称为数组元素（element），一个数组包含的元素个数被称为数组的长度。以下为一些常规的数组声明方法：

var b [32]byte          //长度为32的数组，每个元素为一个字节
var s [32] struct{x,y int}   //复杂类型数组
var f1 [32] *float64       //指针数组
var f2 [2][4][4] float64     //等同于[2]([2]([2] float64))
var i [4][8] int         //二维数组

8 数组切片

数组的长度在定义之后无法再次修改；数组是值类型，每次传递都将产生一份副本。这些都是数组的特点，但这种数据结构无法完全满足开发者的真实需求。Go语言提供了数组切片（slice）这种数据类型来弥补数组的不足。

数字切片就像一个指向数组的指针，数组切片的数据结构可以抽象为以下3个变量：

一个指向原生数组的指针；
数组切片中的元素个数；
数组切片已分配的存储空间。

8.1 创建数组切片

创建数组切片的方法如下表所示：

基于数组

package main

import "fmt"

func main() {
   //定义数组
   var array [10]int = [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

   //基于前五个数组元素创建一个切片
   var slice []int = array[:5]
   //从第五个数组元素创建一个切片   array[5:]
   //数组转为切片 array[:]
   fmt.Println("Array:")
   for _, v := range array {
      fmt.Print(v, " ")
   }
   fmt.Println("")
   fmt.Println("Slice:")
   for _, v := range slice {
      fmt.Print(v, " ")
   }
}
//运行结果为：
//Array:
//0 1 2 3 4 5 6 7 8 9 
//Slice:              
//0 1 2 3 4

直接创建

package main

import "fmt"

func main() {
   //使用make()直接创建数组切片
   //创建一个初始元素个数为5的数组切片，元素初始值为0
   slice1 := make([]int, 5)
   fmt.Println(len(slice1))
   //创建一个初始元素个数为5的数组切片，元素初始值为0，并预留10个元素的存储空间
   slice2 := make([]int, 5, 10)
   fmt.Println(len(slice2))
   //直接创建并初始化包含5个元素的数组切片
   slice3 := []int{0, 1, 2, 3, 4}
   fmt.Println(len(slice3))
}
//运行结果为：
//5
//5
//5

8.2 切片常用的方法

8.2.1 遍历

操作数组元素的所有方法都适用于数组切片，比如数组切片也可以按下标读写元素，用len()函数获取元素的个数，并支持使用range关键字来快速遍历所有元素。

传统的元素遍历如下：

slice := []int{1, 2, 3, 4, 5}
for i := 0; i < len(slice ); i++ {
   fmt.Print(slice [i], " ")
}

使用range关键字可以让遍历代码显得更整洁。range表达式有两个返回值，第一个是索引，第二个是元素的值，代码如下：

slice := []int{1, 2, 3, 4, 5}
for i, v := range slice {
   fmt.Println("d[", i, "]=", v)
}

8.2.2 增减元素

使用append()操作切片，代码如下：

package main

import "fmt"

func main() {
   a := []int{1, 2, 3, 4, 5}
   fmt.Println("a =", a, "len=", len(a))
   d := make([]int, 0)
   //添加切片a的前2个元素，添加切片a下标从3开始之后的元素
   //总结一下：冒号在前是个数；冒号在后是下标，保留的是冒号没有数字的一侧
   //只有(int):和:(int)的用法。
   //添加一个切片要用...展开运算符
   d = append(a[:2], a[3:]...)
   fmt.Println("d =", d, "len=", len(d))
}
//删除切片中的第三个元素
//打印结果如下：
//a = [1 2 3 4 5] len= 5
//d = [1 2 4 5] len= 4

8.2.3 扩容

package main

import "fmt"

func main() {
   a := make([]int, 0)

   fmt.Printf("当前切片的长度:%d,容量:%d\n", len(a), cap(a))

   for i := 0; i < 10; i++ {
      a = append(a, i)
      fmt.Printf("当前切片的长度:%d,容量:%d\n", len(a), cap(a))
   }
}
//打印结果如下：
//当前切片的长度:0,容量:0
//当前切片的长度:1,容量:1  
//当前切片的长度:2,容量:2  
//当前切片的长度:3,容量:4  
//当前切片的长度:4,容量:4  
//当前切片的长度:5,容量:8  
//当前切片的长度:6,容量:8  
//当前切片的长度:7,容量:8  
//当前切片的长度:8,容量:8  
//在添加元素之前判断切片是否有剩余，如果没有剩余且容量小于1024，成倍增加容量
//在没有添加元素之前的容量是8，所以扩容量为8
//当前切片的长度:9,容量:16 
//当前切片的长度:10,容量:16

如果容量小于1024的时候，是成倍数的添加容量
如果容量大于1024的时候，是之前的1/4的来添加容量

9 map

Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。

Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。

9.1 map的常见用法

package main

import "fmt"

type StudentInfo struct {
   Name      string
   ClassRoom string
}

func main() {
   var students map[int]StudentInfo
   students = make(map[int]StudentInfo)

   //添加元素
   students[0] = StudentInfo{"小明", "三年级（1）班"}
   students[1] = StudentInfo{"小红", "三年级（1）班"}
   students[2] = StudentInfo{"小李", "三年级（2）班"}
   students[3] = StudentInfo{"小王", "三年级（2）班"}
   students[4] = StudentInfo{"小赵", "三年级（3）班"}

   //遍历元素
   fmt.Println("学生信息如下：")
   for _, student := range students {
      fmt.Println(student)
   }

   //查找元素
   stua, ok := students[3]
   if ok {
      fmt.Println("下标是3的学生信息：", stua)
   } else {
      fmt.Println("查找失败!")
   }

   //删除元素
   delete(students, 1)
   fmt.Println("新的学生信息如下：")
   for _, student := range students {
      fmt.Println(student)
   }

   //修改元素
   stub, ok := students[2]
   if ok {
      stub.ClassRoom = "三年级（3）班"
   } else {
      fmt.Println("查找失败!")
   }
   fmt.Println("修改后的学生信息：", stub)

}

参考：

东辰行迹

使用frp搭建免费的内网穿透

frp介绍

配置教程

下载frp

安装frps

安装frpc

计算机组成和体系结构 知识点 题型

可靠性

总线系统

流水线的计算

存储系统

高速缓存Cache

主存的编址

存储管理

分页存储管理

页面置换算法

输入输出技术

校验码

奇偶校验码

海明码

RISC与CISC

系统开发基础 知识点 题型

软件容错技术

操作系统 知识点 题型

死锁资源数计算

计算机网络 知识点 题型

子网划分与路由汇聚

Go实战（篇三）使用接口封装SQL操作

引言

为什么要进行封装

代码实现

写在最后的话

Go实战（篇二）使用接口构建对象

什么是接口？

如何使用接口？

写在最后的话

Go实战（篇一）数据库相关操作

数据库相关操作

1 配置环境

2 启动Goland

3 添加依赖

4 编写代码

5 可能会遇到的问题

写在最后

Go学习笔记（篇四）流程控制

流程控制

1 条件语句

2 选择语句

3 循环语句

4 跳转语句

Go学习笔记（篇三）数据类型

数据类型

1 布尔类型

2 整形

2.1 类型表示

2.2 数值运算

2.3 比较运算

2.4 位运算

3 浮点型

3.1 浮点数表示

3.2 浮点数比较

4 复数类型

5 字符串

5.1 字符串操作

5.2 字符串遍历

6 字符类型

7 数组

8 数组切片

8.1 创建数组切片

8.2 切片常用的方法

8.2.1 遍历

8.2.2 增减元素

8.2.3 扩容

9 map

9.1 map的常见用法

计算机组成和体系结构知识点题型

系统开发基础知识点题型

操作系统知识点题型

计算机网络知识点题型