URL模式匹配与参数提取的高效策略

package main

import (
    "fmt"
    "strings"
)

// MatchURLPattern 匹配URL模式并提取标签。
// 该函数设计用于处理单个占位符的模式，如 "/some/{tag}/here"。
// 如果模式中没有占位符，则执行精确匹配。
func MatchURLPattern(pattern, target string) (map[string]string, bool) {
    // 查找占位符的起始和结束位置
    openBraceIndex := strings.Index(pattern, "{")
    closeBraceIndex := strings.Index(pattern, "}")

    // 情况1: 模式中没有占位符，进行精确匹配
    if openBraceIndex == -1 || closeBraceIndex == -1 || openBraceIndex > closeBraceIndex {
        if pattern == target {
            return make(map[string]string), true // 匹配成功，但无参数
        }
        return nil, false // 不匹配
    }

    // 提取占位符的名称
    tagName := pattern[openBraceIndex+1 : closeBraceIndex]

    // 将模式分割成前缀和后缀
    prefix := pattern[:openBraceIndex]
    suffix := pattern[closeBraceIndex+1:]

    // 检查目标字符串是否以正确的前缀开头
    if !strings.HasPrefix(target, prefix) {
        return nil, false
    }

    // 检查目标字符串是否以正确的后缀结尾
    // 特殊处理：如果后缀为空，则表示占位符在模式的末尾
    if suffix != "" {
        if !strings.HasSuffix(target, suffix) {
            return nil, false
        }
    } else {
        // 如果后缀为空，且目标URL的长度小于前缀，则无法匹配
        if len(target) < len(prefix) {
            return nil, false
        }
    }

    // 提取中间部分作为标签值
    // 计算中间部分的起始和结束索引
    valueStart := len(prefix)
    valueEnd := len(target) - len(suffix)

    // 确保提取的范围有效，例如避免 target 比 prefix+suffix 短
    if valueStart > valueEnd {
        return nil, false // 目标字符串太短，无法容纳前缀、占位符和后缀
    }

    tagValue := target[valueStart:valueEnd]

    // 存储结果
    result := make(map[string]string)
    result[tagName] = tagValue
    return result, true
}

func main() {
    // 示例用法
    pattern1 := "/some/{tag}/here"
    target1 := "/some/text/here"
    params1, matched1 := MatchURLPattern(pattern1, target1)
    fmt.Printf("模式: \"%s\", 目标: \"%s\"\n", pattern1, target1)
    fmt.Printf("  匹配: %t, 参数: %v\n", matched1, params1) // 预期: true, map[tag:text]

    pattern2 := "/user/{id}"
    target2 := "/user/123"
    params2, matched2 := MatchURLPattern(pattern2, target2)
    fmt.Printf("模式: \"%s\", 目标: \"%s\"\n", pattern2, target2)
    fmt.Printf("  匹配: %t, 参数: %v\n", matched2, params2) // 预期: true, map[id:123]

    pattern3 := "/static/path"
    target3 := "/static/path"
    params3, matched3 := MatchURLPattern(pattern3, target3)
    fmt.Printf("模式: \"%s\", 目标: \"%s\"\n", pattern3, target3)
    fmt.Printf("  匹配: %t, 参数: %v\n", matched3, params3) // 预期: true, map[] (无参数)

    pattern4 := "/some/{tag}/here"
    target4 := "/some/another/path" // 不匹配后缀
    params4, matched4 := MatchURLPattern(pattern4, target4)
    fmt.Printf("模式: \"%s\", 目标: \"%s\"\n", pattern4, target4)
    fmt.Printf("  匹配: %t, 参数: %v\n", matched4, params4) // 预期: false, nil

    pattern5 := "/api/{version}"
    target5 := "/api/" // 占位符为空值
    params5, matched5 := MatchURLPattern(pattern5, target5)
    fmt.Printf("模式: \"%s\", 目标: \"%s\"\n", pattern5, target5)
    fmt.Printf("  匹配: %t, 参数: %v\n", matched5, params5) // 预期: true, map[version:]

    pattern6 := "/api/{version}/resource"
    target6 := "/api/v1" // 目标太短，无法匹配后缀
    params6, matched6 := MatchURLPattern(pattern6, target6)
    fmt.Printf("模式: \"%s\", 目标: \"%s\"\n", pattern6, target6)
    fmt.Printf("  匹配: %t, 参数: %v\n", matched6, params6) // 预期: false, nil
}