按照标题与搜索词的相似度，进行排序

// 自定义排序函数，根据Item的Name字段与target字符串的相似性进行排序
func sortBySimilarity(items []item, target string) []item {
	items = filter(items, target)

	sort.Slice(items, func(i, j int) bool {
		// 计算每个Item的Name与target的相似性
		simI := levenshteinDistance(items[i].Title, target)
		simJ := levenshteinDistance(items[j].Title, target)

		// 假设我们想要相似性越高的越排在前面，因此返回simI < simJ
		// 如果你的相似性算法逻辑不同，这里的比较逻辑也需要相应调整
		return simI < simJ
	})

	return items
}

// 过滤掉不包含搜索词的记录
func filter(items []item, target string) []item {
	results := []item{}
	for _, v := range items {
		if strings.Contains(strings.ToLower(v.Title), strings.ToLower(target)) {
			results = append(results, v)
		}
	}

	return results
}

// levenshteinDistance 计算两个字符串之间的Levenshtein距离
func levenshteinDistance(s1, s2 string) int {
	len1 := len(s1)
	len2 := len(s2)
	if len1 < len2 {
		return levenshteinDistance(s2, s1)
	}
	if len2 == 0 {
		return len1
	}

	// 创建一个二维切片来存储计算过程中的中间结果
	dp := make([][]int, len1+1)
	for i := range dp {
		dp[i] = make([]int, len2+1)
	}

	// 初始化第一列
	for i := 0; i <= len1; i++ {
		dp[i][0] = i
	}

	// 初始化第一行
	for j := 0; j <= len2; j++ {
		dp[0][j] = j
	}

	// 填充剩余的dp表格
	for i := 1; i <= len1; i++ {
		for j := 1; j <= len2; j++ {
			cost := 0
			if s1[i-1] != s2[j-1] {
				cost = 1
			}
			dp[i][j] = min(
				dp[i-1][j]+1,      // 删除
				dp[i][j-1]+1,      // 插入
				dp[i-1][j-1]+cost, // 替换
			)
		}
	}

	return dp[len1][len2]
}

// min 返回两个整数中的较小值
func min(a, b, c int) int {
	if a <= b && a <= c {
		return a
	} else if b <= a && b <= c {
		return b
	}
	return c
}