README.md

README.md

@@ -16,14 +16,14 @@
 
 > 本项目也支持对**其他 CDN / 网站 IP** 延迟测速（如：[CloudFront](https://github.com/XIU2/CloudflareSpeedTest/discussions/304)、[Gcore](https://github.com/XIU2/CloudflareSpeedTest/discussions/303) CDN），但下载测速需自行寻找地址
 
-> 对于**代理套 Cloudflare CDN** 的用户，须知这应为**备用方案**，而不应该是**唯一方案**，请勿过度依赖 [#217](https://github.com/XIU2/CloudflareSpeedTest/issues/217) [#188](https://github.com/XIU2/CloudflareSpeedTest/issues/188)
+> 对于**代理套 Cloudflare CDN** 的用户，须知这应为**备用方案**，而不应该是**唯一方案**，请勿过度依赖 [#382](https://github.com/XIU2/CloudflareSpeedTest/discussions/382) [#383](https://github.com/XIU2/CloudflareSpeedTest/discussions/383)
 
 ****
 ## \# 快速使用
 
 ### 下载运行
 
-1. 下载编译好的可执行文件 [蓝奏云](https://pan.lanzouf.com/b0742hkxe) / [Github](https://github.com/XIU2/CloudflareSpeedTest/releases) 并解压。  
+1. 下载编译好的可执行文件（ [Github Releases](https://github.com/XIU2/CloudflareSpeedTest/releases) / [蓝奏云](https://pan.lanzouf.com/b0742hkxe) ）并解压。  
 2. 双击运行 `CloudflareST.exe` 文件（Windows 系统），等待测速完成...
 
 <details>
@@ -41,10 +41,10 @@ mkdir CloudflareST
 cd CloudflareST
 
 # 下载 CloudflareST 压缩包（自行根据需求替换 URL 中 [版本号] 和 [文件名]）
-wget -N https://github.com/XIU2/CloudflareSpeedTest/releases/download/v2.2.2/CloudflareST_linux_amd64.tar.gz
+wget -N https://github.com/XIU2/CloudflareSpeedTest/releases/download/v2.2.4/CloudflareST_linux_amd64.tar.gz
 # 如果你是在国内服务器上下载，那么请使用下面这几个镜像加速：
-# wget -N https://download.fastgit.org/XIU2/CloudflareSpeedTest/releases/download/v2.2.2/CloudflareST_linux_amd64.tar.gz
+# wget -N https://download.fastgit.org/XIU2/CloudflareSpeedTest/releases/download/v2.2.4/CloudflareST_linux_amd64.tar.gz
-# wget -N https://ghproxy.com/https://github.com/XIU2/CloudflareSpeedTest/releases/download/v2.2.2/CloudflareST_linux_amd64.tar.gz
+# wget -N https://ghproxy.com/https://github.com/XIU2/CloudflareSpeedTest/releases/download/v2.2.4/CloudflareST_linux_amd64.tar.gz
 # 如果下载失败的话，尝试删除 -N 参数（如果是为了更新，则记得提前删除旧压缩包 rm CloudflareST_linux_amd64.tar.gz ）
 
 # 解压（不需要删除旧文件，会直接覆盖，自行根据需求替换 文件名）
@@ -100,10 +100,10 @@ IP 地址           已发送  已接收  丢包率  平均延迟  下载速度
 # 2. 延迟排序（延迟从低到高排序，不同丢包率的会分开独立排序，因此可能会有一些延迟低但丢包的 IP 被排到后面）
 # 3. 下载测速（从延迟最低的 IP 开始依次下载测速，默认测够 10 个就会停止）
 # 4. 速度排序（速度从高到低排序）
-# 5. 输出结果（可依靠参数控制是否输出到命令行(-p 0)/文件(-o "")）
+# 5. 输出结果（通过参数控制是否输出到命令行(-p 0)或输出到文件(-o "")）
 ```
 
-测速结果第一行就是**既下载速度最快、又平均延迟最低的最快 IP**！至于拿来干嘛？取决于你~
+测速结果第一行就是**既下载速度最快、又平均延迟最低的最快 IP**！
 
 完整结果保存在当前目录下的 `result.csv` 文件中，用**记事本/表格软件**打开，格式如下：
 
@@ -130,7 +130,7 @@ https://github.com/XIU2/CloudflareSpeedTest
     -n 200
         延迟测速线程；越多延迟测速越快，性能弱的设备 (如路由器) 请勿太高；(默认 200 最多 1000)
     -t 4
-        延迟测速次数；单个 IP 延迟测速次数，为 1 时将过滤丢包的IP；(默认 4 次)
+        延迟测速次数；单个 IP 延迟测速的次数；(默认 4 次)
     -dn 10
         下载测速数量；延迟测速并排序后，从最低延迟起下载测速的数量；(默认 10 个)
     -dt 10
@@ -150,9 +150,11 @@ https://github.com/XIU2/CloudflareSpeedTest
         匹配指定地区；地区名为当地机场三字码，英文逗号分隔，支持小写，支持 Cloudflare、AWS CloudFront，仅 HTTPing 模式可用；(默认 所有地区)
 
     -tl 200
-        平均延迟上限；只输出低于指定平均延迟的 IP，可与其他上限/下限搭配；(默认 9999 ms)
+        平均延迟上限；只输出低于指定平均延迟的 IP，各上下限条件可搭配使用；(默认 9999 ms)
     -tll 40
-        平均延迟下限；只输出高于指定平均延迟的 IP，可与其他上限/下限搭配；(默认 0 ms)
+        平均延迟下限；只输出高于指定平均延迟的 IP；(默认 0 ms)
+    -tlr 0.2
+        丢包几率上限；只输出低于/等于指定丢包率的 IP，范围 0.00~1.00，0 过滤掉任何丢包的 IP；(默认 1.00)
     -sl 5
         下载速度下限；只输出高于指定下载速度的 IP，凑够指定数量 [-dn] 才会停止测速；(默认 0.00 MB/s)
 
@@ -248,13 +250,14 @@ D:\ABC\CloudflareST\CloudflareST.exe -n 500 -t 4 -dn 20 -dt 5 -o " "
 
 ****
 ``` bash
-# 测速 IPv4 时，需要指定 IPv4 数据文件（-f 默认值就是 ip.txt，所以该参数可省略）
+# 指定自带的 IPv4 数据文件可测速这些 IPv4 地址（-f 默认值就是 ip.txt，所以该参数可省略）
 CloudflareST.exe -f ip.txt
 
-# 测速 IPv6 时，需要指定 IPv6 数据文件（v2.1.0 版本后支持 IPv4+IPv6 混合测速并移除了 -ipv6 参数）
+# 指定自带的 IPv6 数据文件可测速这些 IPv6 地址
+# 另外，v2.1.0 版本后支持 IPv4+IPv6 混合测速并移除了 -ipv6 参数，因此一个文件内可以同时包含 IPv4+IPv6 地址
 CloudflareST.exe -f ipv6.txt
 
-# 当然你也可以将 IPv4 IPv6 混合在一起测速，也可以直接通过参数指定要测速的 IP
+# 也可以直接通过参数指定要测速的 IP
 CloudflareST.exe -ip 1.1.1.1,2606:4700::/32
 ```
 
@@ -279,6 +282,8 @@ HTTP 协议适用于快速测试某域名指向某 IP 时是否可以访问，
 
 > 注意：HTTPing 本质上也算一种**网络扫描**行为，因此如果你在服务器上面运行，需要**降低并发**(`-n`)，否则可能会被一些严格的商家暂停服务。如果你遇到 HTTPing 首次测速可用 IP 数量正常，后续测速越来越少甚至直接为 0，但停一段时间后又恢复了的情况，那么也可能是被 运营商、Cloudflare CDN 认为你在网络扫描而**触发临时限制机制**，因此才会过一会儿就恢复了，建议**降低并发**(`-n`)减少这种情况的发生。
 
+> 另外，本软件 HTTPing 仅获取**响应头(response headers)**，并不获取正文内容（即 URL 文件大小不影响 HTTPing 测试，但如果你还要下载测速的话，那么还是需要一个大文件的），类似于 curl -i 功能。
+
 ``` bash
 # 只需加上 -httping 参数即可切换到 HTTP 协议延迟测速模式
 CloudflareST.exe -httping
@@ -288,6 +293,7 @@ CloudflareST.exe -httping -httping-code 200
 
 # 通过 -url 参数来指定 HTTPing 测试地址（可以是任意网页 URL，不局限于具体文件地址）
 CloudflareST.exe -httping -url https://cf.xiu2.xyz/url
+# 如果你要 HTTPing 测试其他网站/CDN，那么指定一个该网站/使用该 CDN 的地址（因为软件默认地址是 Cloudflare 的，只能用于测试 Cloudflare 的 IP）
 
 # 注意：如果测速地址为 HTTP 协议，记得加上 -tp 80（这个参数会影响 延迟测速/下载测速 时使用的端口）
 # 同理，如果要测速 80 端口，那么也需要加上 -url 参数来指定一个 http:// 协议的地址才行（且该地址不会强制重定向至 HTTPS），如果是非 80 443 端口，那么需要确定该下载测速地址是否支持通过该端口访问。
@@ -307,6 +313,8 @@ CloudflareST.exe -httping -tp 80 -url http://cdn.cloudflare.steamstatic.com/stea
 
 ``` bash
 # 该功能支持 Cloudflare CDN、AWS CloudFront CDN，且这两个 CDN 的机场三字码是通用的
+# 注意：如果你要用于筛选 AWS CloudFront CDN 地区，那么要通过 -url 参数指定一个使用该 CDN 的地址（因为软件默认地址是 Cloudflare 的）
+
 # 指定地区名后，延迟测速后得到的结果就都是指定地区的 IP 了（也可以继续进行下载测速）
 # 节点地区名为当地 机场三字码，指定多个时用英文逗号分隔，v2.2.3 版本后支持小写
 
@@ -315,7 +323,7 @@ CloudflareST.exe -cfcolo HKG,KHH,NRT,LAX,SEA,SJC,FRA,MAD
 # 注意，该参数只有在 HTTPing 延迟测速模式下才可用（因为要访问网页来获得）
 ```
 
-> 两个 CDN 机场三字码通用，各地区见：https://www.cloudflarestatus.com/
+> 两个 CDN 机场三字码通用，因此各地区名可见：https://www.cloudflarestatus.com/
 
 </details>
 
@@ -407,7 +415,7 @@ CloudflareST.exe -tp 80 -url http://cdn.cloudflare.steamstatic.com/steam/apps/59
 
 ****
 
-#### \# 自定义测速条件（指定 延迟/下载速度 的目标范围）
+#### \# 自定义测速条件（指定 延迟/丢包/下载速度 的目标范围）
 
 <details>
 <summary><code><strong>「 点击展开 查看内容 」</strong></code></summary>
@@ -416,20 +424,12 @@ CloudflareST.exe -tp 80 -url http://cdn.cloudflare.steamstatic.com/steam/apps/59
 
 > 注意：延迟测速进度条右边的**可用数量**，仅指延迟测速过程中**未超时的 IP 数量**，和延迟上下限条件无关。
 
-- 指定 **[平均延迟下限]** 条件
-
-``` bash
-# 平均延迟下限：40 ms （一般除了移动直连香港外，几乎不存在低于 100ms 的，自行测试适合的下限延迟）
-# 平均延迟下限和其他的上下限参数一样，都可以单独使用、互相搭配使用！
-CloudflareST.exe -tll 40
-```
-
 - 仅指定 **[平均延迟上限]** 条件
 
 ``` bash
-# 平均延迟上限：200 ms，下载速度下限：0 MB/s，数量：10 个（可选）
+# 平均延迟上限：200 ms，下载速度下限：0 MB/s
 # 即找到平均延迟低于 200 ms 的 IP，然后再按延迟从低到高进行 10 次下载测速
-CloudflareST.exe -tl 200 -dn 10
+CloudflareST.exe -tl 200
 ```
 
 > 如果**没有找到一个满足延迟**条件的 IP，那么不会输出任何内容。
@@ -444,6 +444,14 @@ CloudflareST.exe -tl 200 -dn 10
 CloudflareST.exe -tl 200 -dd
 ```
 
+- 仅指定 **[丢包几率上限]** 条件
+
+``` bash
+# 丢包几率上限：0.25
+# 即找到丢包率低于等于 0.25 的 IP，范围 0.00~1.00，如果 -tlr 0 则代表过滤掉任何丢包的 IP
+CloudflareST.exe -tlr 0.25
+```
+
 ****
 
 - 仅指定 **[下载速度下限]** 条件
@@ -474,7 +482,7 @@ CloudflareST.exe -tl 200 -sl 5.6 -dn 10
 > 如果**没有找到一个满足速度**条件的 IP，那么会忽略条件输出所有 IP 测速结果（方便你下次测速时调整条件）。  
 > 所以建议先不指定条件测速一遍，看看平均延迟和下载速度大概在什么范围，避免指定条件**过低/过高**！
 
-> 因为Cloudflare 公开的 IP 段是**回源 IP+任播 IP**，而**回源 IP**是无法使用的，所以下载测速是 0.00。  
+> 因为 Cloudflare 公开的 IP 段是**回源 IP+任播 IP**，而**回源 IP**是无法使用的，所以下载测速是 0.00。  
 > 运行时可以加上 `-sl 0.01`（下载速度下限），过滤掉**回源 IP**（下载测速低于 0.01MB/s 的结果）。
 
 </details>

main.go

@@ -28,7 +28,7 @@ https://github.com/XIU2/CloudflareSpeedTest
     -n 200
         延迟测速线程；越多延迟测速越快，性能弱的设备 (如路由器) 请勿太高；(默认 200 最多 1000)
     -t 4
-        延迟测速次数；单个 IP 延迟测速次数，为 1 时将过滤丢包的IP；(默认 4 次)
+        延迟测速次数；单个 IP 延迟测速的次数；(默认 4 次)
     -dn 10
         下载测速数量；延迟测速并排序后，从最低延迟起下载测速的数量；(默认 10 个)
     -dt 10
@@ -46,9 +46,11 @@ https://github.com/XIU2/CloudflareSpeedTest
         匹配指定地区；地区名为当地机场三字码，英文逗号分隔，仅 HTTPing 模式可用；(默认 所有地区)
 
     -tl 200
-        平均延迟上限；只输出低于指定平均延迟的 IP，可与其他上限/下限搭配；(默认 9999 ms)
+        平均延迟上限；只输出低于指定平均延迟的 IP，各上下限条件可搭配使用；(默认 9999 ms)
     -tll 40
-        平均延迟下限；只输出高于指定平均延迟的 IP，可与其他上限/下限搭配；(默认 0 ms)
+        平均延迟下限；只输出高于指定平均延迟的 IP；(默认 0 ms)
+    -tlr 0.2
+        丢包几率上限；只输出低于/等于指定丢包率的 IP，范围 0.00~1.00，0 过滤掉任何丢包的 IP；(默认 1.00)
     -sl 5
         下载速度下限；只输出高于指定下载速度的 IP，凑够指定数量 [-dn] 才会停止测速；(默认 0.00 MB/s)
 
@@ -72,6 +74,7 @@ https://github.com/XIU2/CloudflareSpeedTest
         打印帮助说明
 `
 	var minDelay, maxDelay, downloadTime int
+	var maxLossRate float64
 	flag.IntVar(&task.Routines, "n", 200, "延迟测速线程")
 	flag.IntVar(&task.PingTimes, "t", 4, "延迟测速次数")
 	flag.IntVar(&task.TestCount, "dn", 10, "下载测速数量")
@@ -85,6 +88,7 @@ https://github.com/XIU2/CloudflareSpeedTest
 
 	flag.IntVar(&maxDelay, "tl", 9999, "平均延迟上限")
 	flag.IntVar(&minDelay, "tll", 0, "平均延迟下限")
+	flag.Float64Var(&maxLossRate, "tlr", 1, "丢包几率上限")
 	flag.Float64Var(&task.MinSpeed, "sl", 0, "下载速度下限")
 
 	flag.IntVar(&utils.PrintNum, "p", 10, "显示结果数量")
@@ -104,6 +108,7 @@ https://github.com/XIU2/CloudflareSpeedTest
 	}
 	utils.InputMaxDelay = time.Duration(maxDelay) * time.Millisecond
 	utils.InputMinDelay = time.Duration(minDelay) * time.Millisecond
+	utils.InputMaxLossRate = float32(maxLossRate)
 	task.Timeout = time.Duration(downloadTime) * time.Second
 	task.HttpingCFColomap = task.MapColoMap()
 
@@ -125,8 +130,8 @@ func main() {
 
 	fmt.Printf("# XIU2/CloudflareSpeedTest %s \n\n", version)
 
-	// 开始延迟测速
+	// 开始延迟测速 + 过滤延迟/丢包
-	pingData := task.NewPing().Run().FilterDelay()
+	pingData := task.NewPing().Run().FilterDelay().FilterLossRate()
 	// 开始下载测速
 	speedData := task.TestDownloadSpeed(pingData)
 	utils.ExportCsv(speedData) // 输出文件

task/ip.go

@@ -49,6 +49,7 @@ func newIPRanges() *IPRanges {
 	}
 }
 
+// 如果是单独 IP 则加上子网掩码，反之则获取子网掩码(r.mask)
 func (r *IPRanges) fixIP(ip string) string {
 	// 如果不含有 '/' 则代表不是 IP 段，而是一个单独的 IP，因此需要加上 /32 /128 子网掩码
 	if i := strings.IndexByte(ip, '/'); i < 0 {
@@ -64,6 +65,7 @@ func (r *IPRanges) fixIP(ip string) string {
 	return ip
 }
 
+// 解析 IP 段，获得 IP、IP 范围、子网掩码
 func (r *IPRanges) parseCIDR(ip string) {
 	var err error
 	if r.firstIP, r.ipNet, err = net.ParseCIDR(r.fixIP(ip)); err != nil {
@@ -98,40 +100,48 @@ func (r *IPRanges) getIPRange() (minIP, hosts byte) {
 }
 
 func (r *IPRanges) chooseIPv4() {
-	minIP, hosts := r.getIPRange()
+	if r.mask == "/32" { // 单个 IP 则无需随机，直接加入自身即可
-	for r.ipNet.Contains(r.firstIP) {
+		r.appendIP(r.firstIP)
-		if TestAll { // 如果是测速全部 IP
+	} else {
-			for i := 0; i <= int(hosts); i++ { // 遍历 IP 最后一段最小值到最大值
+		minIP, hosts := r.getIPRange()    // 返回第四段 IP 的最小值及可用数目
-				r.appendIPv4(byte(i) + minIP)
+		for r.ipNet.Contains(r.firstIP) { // 只要该 IP 没有超出 IP 网段范围，就继续循环随机
+			if TestAll { // 如果是测速全部 IP
+				for i := 0; i <= int(hosts); i++ { // 遍历 IP 最后一段最小值到最大值
+					r.appendIPv4(byte(i) + minIP)
+				}
+			} else { // 随机 IP 的最后一段 0.0.0.X
+				r.appendIPv4(minIP + randIPEndWith(hosts))
 			}
-		} else { // 随机 IP 的最后一段 0.0.0.X
+			r.firstIP[14]++ // 0.0.(X+1).X
-			r.appendIPv4(minIP + randIPEndWith(hosts))
+			if r.firstIP[14] == 0 {
-		}
+				r.firstIP[13]++ // 0.(X+1).X.X
-		r.firstIP[14]++ // 0.0.(X+1).X
+				if r.firstIP[13] == 0 {
-		if r.firstIP[14] == 0 {
+					r.firstIP[12]++ // (X+1).X.X.X
-			r.firstIP[13]++ // 0.(X+1).X.X
+				}
-			if r.firstIP[13] == 0 {
-				r.firstIP[12]++ // (X+1).X.X.X
 			}
 		}
 	}
 }
 
 func (r *IPRanges) chooseIPv6() {
-	var tempIP uint8
+	if r.mask == "/128" { // 单个 IP 则无需随机，直接加入自身即可
-	for r.ipNet.Contains(r.firstIP) {
+		r.appendIP(r.firstIP)
-		if r.mask != "/128" {
+	} else {
+		var tempIP uint8                  // 临时变量，用于记录前一位的值
+		for r.ipNet.Contains(r.firstIP) { // 只要该 IP 没有超出 IP 网段范围，就继续循环随机
 			r.firstIP[15] = randIPEndWith(255) // 随机 IP 的最后一段
 			r.firstIP[14] = randIPEndWith(255) // 随机 IP 的最后一段
-		}
+
-		targetIP := make([]byte, len(r.firstIP))
+			targetIP := make([]byte, len(r.firstIP))
-		copy(targetIP, r.firstIP)
+			copy(targetIP, r.firstIP)
-		r.appendIP(targetIP)
+			r.appendIP(targetIP) // 加入 IP 地址池
-		for i := 13; i >= 0; i-- {
+
-			tempIP = r.firstIP[i]
+			for i := 13; i >= 0; i-- { // 从倒数第三位开始往前随机
-			r.firstIP[i] += randIPEndWith(255)
+				tempIP = r.firstIP[i]              // 保存前一位的值
-			if r.firstIP[i] >= tempIP {
+				r.firstIP[i] += randIPEndWith(255) // 随机 0~255，加到当前位上
-				break
+				if r.firstIP[i] >= tempIP {        // 如果当前位的值大于等于前一位的值，说明随机成功了，可以退出该循环
+					break
+				}
 			}
 		}
 	}
@@ -140,10 +150,14 @@ func (r *IPRanges) chooseIPv6() {
 func loadIPRanges() []*net.IPAddr {
 	ranges := newIPRanges()
 	if IPText != "" { // 从参数中获取 IP 段数据
-		IPs := strings.Split(IPText, ",")
+		IPs := strings.Split(IPText, ",") // 以逗号分隔为数组并循环遍历
 		for _, IP := range IPs {
-			ranges.parseCIDR(IP)
+			IP = strings.TrimSpace(IP) // 去除首尾的空白字符（空格、制表符、换行符等）
-			if isIPv4(IP) {
+			if IP == "" {              // 跳过空的（即开头、结尾或连续多个 ,, 的情况）
+				continue
+			}
+			ranges.parseCIDR(IP) // 解析 IP 段，获得 IP、IP 范围、子网掩码
+			if isIPv4(IP) {      // 生成要测速的所有 IPv4 / IPv6 地址（单个/随机/全部）
 				ranges.chooseIPv4()
 			} else {
 				ranges.chooseIPv6()
@@ -159,9 +173,13 @@ func loadIPRanges() []*net.IPAddr {
 		}
 		defer file.Close()
 		scanner := bufio.NewScanner(file)
-		for scanner.Scan() {
+		for scanner.Scan() { // 循环遍历文件每一行
-			ranges.parseCIDR(scanner.Text())
+			line := strings.TrimSpace(scanner.Text()) // 去除首尾的空白字符（空格、制表符、换行符等）
-			if isIPv4(scanner.Text()) {
+			if line == "" {                           // 跳过空行
+				continue
+			}
+			ranges.parseCIDR(line) // 解析 IP 段，获得 IP、IP 范围、子网掩码
+			if isIPv4(line) {      // 生成要测速的所有 IPv4 / IPv6 地址（单个/随机/全部）
 				ranges.chooseIPv4()
 			} else {
 				ranges.chooseIPv6()

task/tcping.go

@@ -64,9 +64,9 @@ func (p *Ping) Run() utils.PingDelaySet {
 		return p.csv
 	}
 	if Httping {
-		fmt.Printf("开始延迟测速（模式：HTTP，端口：%d，平均延迟上限：%v ms，平均延迟下限：%v ms)\n", TCPPort, utils.InputMaxDelay.Milliseconds(), utils.InputMinDelay.Milliseconds())
+		fmt.Printf("开始延迟测速（模式：HTTP，端口：%d，平均延迟上限：%v ms，平均延迟下限：%v ms，丢包几率上限：%.2f )\n", TCPPort, utils.InputMaxDelay.Milliseconds(), utils.InputMinDelay.Milliseconds(), utils.InputMaxLossRate)
 	} else {
-		fmt.Printf("开始延迟测速（模式：TCP，端口：%d，平均延迟上限：%v ms，平均延迟下限：%v ms)\n", TCPPort, utils.InputMaxDelay.Milliseconds(), utils.InputMinDelay.Milliseconds())
+		fmt.Printf("开始延迟测速（模式：TCP，端口：%d，平均延迟上限：%v ms，平均延迟下限：%v ms，丢包几率上限：%.2f )\n", TCPPort, utils.InputMaxDelay.Milliseconds(), utils.InputMinDelay.Milliseconds(), utils.InputMaxLossRate)
 	}
 	for _, ip := range p.ips {
 		p.wg.Add(1)

utils/csv.go

@@ -11,16 +11,18 @@ import (
 )
 
 const (
-	defaultOutput = "result.csv"
+	defaultOutput         = "result.csv"
-	maxDelay      = 9999 * time.Millisecond
+	maxDelay              = 9999 * time.Millisecond
-	minDelay      = 0 * time.Millisecond
+	minDelay              = 0 * time.Millisecond
+	maxLossRate   float32 = 1.0
 )
 
 var (
-	InputMaxDelay = maxDelay
+	InputMaxDelay    = maxDelay
-	InputMinDelay = minDelay
+	InputMinDelay    = minDelay
-	Output        = defaultOutput
+	InputMaxLossRate = maxLossRate
-	PrintNum      = 10
+	Output           = defaultOutput
+	PrintNum         = 10
 )
 
 // 是否打印测试结果
@@ -42,16 +44,17 @@ type PingData struct {
 
 type CloudflareIPData struct {
 	*PingData
-	recvRate      float32
+	lossRate      float32
 	DownloadSpeed float64
 }
 
-func (cf *CloudflareIPData) getRecvRate() float32 {
+// 计算丢包率
-	if cf.recvRate == 0 {
+func (cf *CloudflareIPData) getLossRate() float32 {
+	if cf.lossRate == 0 {
 		pingLost := cf.Sended - cf.Received
-		cf.recvRate = float32(pingLost) / float32(cf.Sended)
+		cf.lossRate = float32(pingLost) / float32(cf.Sended)
 	}
-	return cf.recvRate
+	return cf.lossRate
 }
 
 func (cf *CloudflareIPData) toString() []string {
@@ -59,7 +62,7 @@ func (cf *CloudflareIPData) toString() []string {
 	result[0] = cf.IP.String()
 	result[1] = strconv.Itoa(cf.Sended)
 	result[2] = strconv.Itoa(cf.Received)
-	result[3] = strconv.FormatFloat(float64(cf.getRecvRate()), 'f', 2, 32)
+	result[3] = strconv.FormatFloat(float64(cf.getLossRate()), 'f', 2, 32)
 	result[4] = strconv.FormatFloat(cf.Delay.Seconds()*1000, 'f', 2, 32)
 	result[5] = strconv.FormatFloat(cf.DownloadSpeed/1024/1024, 'f', 2, 32)
 	return result
@@ -89,17 +92,22 @@ func convertToString(data []CloudflareIPData) [][]string {
 	return result
 }
 
+// 延迟丢包排序
 type PingDelaySet []CloudflareIPData
 
+// 延迟条件过滤
 func (s PingDelaySet) FilterDelay() (data PingDelaySet) {
-	if InputMaxDelay > maxDelay || InputMinDelay < minDelay {
+	if InputMaxDelay > maxDelay || InputMinDelay < minDelay { // 当输入的延迟条件不在默认范围内时，不进行过滤
+		return s
+	}
+	if InputMaxDelay == maxDelay && InputMinDelay == minDelay { // 当输入的延迟条件为默认值时，不进行过滤
 		return s
 	}
 	for _, v := range s {
-		if v.Delay > InputMaxDelay { // 平均延迟上限
+		if v.Delay > InputMaxDelay { // 平均延迟上限，延迟大于条件最大值时，后面的数据都不满足条件，直接跳出循环
 			break
 		}
-		if v.Delay < InputMinDelay { // 平均延迟下限
+		if v.Delay < InputMinDelay { // 平均延迟下限，延迟小于条件最小值时，不满足条件，跳过
 			continue
 		}
 		data = append(data, v) // 延迟满足条件时，添加到新数组中
@@ -107,18 +115,30 @@ func (s PingDelaySet) FilterDelay() (data PingDelaySet) {
 	return
 }
 
+// 丢包条件过滤
+func (s PingDelaySet) FilterLossRate() (data PingDelaySet) {
+	if InputMaxLossRate >= maxLossRate { // 当输入的丢包条件为默认值时，不进行过滤
+		return s
+	}
+	for _, v := range s {
+		if v.getLossRate() > InputMaxLossRate { // 丢包几率上限
+			break
+		}
+		data = append(data, v) // 丢包率满足条件时，添加到新数组中
+	}
+	return
+}
+
 func (s PingDelaySet) Len() int {
 	return len(s)
 }
-
 func (s PingDelaySet) Less(i, j int) bool {
-	iRate, jRate := s[i].getRecvRate(), s[j].getRecvRate()
+	iRate, jRate := s[i].getLossRate(), s[j].getLossRate()
 	if iRate != jRate {
 		return iRate < jRate
 	}
 	return s[i].Delay < s[j].Delay
 }
-
 func (s PingDelaySet) Swap(i, j int) {
 	s[i], s[j] = s[j], s[i]
 }
@@ -129,11 +149,9 @@ type DownloadSpeedSet []CloudflareIPData
 func (s DownloadSpeedSet) Len() int {
 	return len(s)
 }
-
 func (s DownloadSpeedSet) Less(i, j int) bool {
 	return s[i].DownloadSpeed > s[j].DownloadSpeed
 }
-
 func (s DownloadSpeedSet) Swap(i, j int) {
 	s[i], s[j] = s[j], s[i]
 }