Golang中使用正则表达式和前瞻断言(regex lookaheads)的技巧

在 Go 中确实不支持正则表达式的前瞻断言（lookaheads），但可以通过其他方式实现相同的密码复杂度验证。以下是几种替代方案：

方案1：使用多个独立的正则表达式组合验证

package main

import (
    "fmt"
    "regexp"
    "strings"
)

func validatePassword(password string) bool {
    // 基本长度检查
    if len(password) < 8 || len(password) > 16 {
        return false
    }
    
    // 检查允许的字符集
    allowedChars := regexp.MustCompile(`^[A-Za-z\d@#$%^&£*\ \-_\+=\[\]{}|\\:',?/~"();!\.]+$`)
    if !allowedChars.MatchString(password) {
        return false
    }
    
    // 检查至少包含小写字母
    hasLower := regexp.MustCompile(`[a-z]`)
    // 检查至少包含大写字母  
    hasUpper := regexp.MustCompile(`[A-Z]`)
    // 检查至少包含数字
    hasDigit := regexp.MustCompile(`\d`)
    // 检查至少包含特殊字符
    hasSpecial := regexp.MustCompile(`[^A-Za-z0-9]`)
    
    // 检查点号后面不能跟@（原正则中的 \.(?!@)）
    if strings.Contains(password, ".@") {
        return false
    }
    
    // 验证四种组合中的任意一种
    conditions := []bool{
        hasLower.MatchString(password) && hasUpper.MatchString(password) && hasDigit.MatchString(password),
        hasLower.MatchString(password) && hasUpper.MatchString(password) && hasSpecial.MatchString(password),
        hasLower.MatchString(password) && hasDigit.MatchString(password) && hasSpecial.MatchString(password),
        hasUpper.MatchString(password) && hasDigit.MatchString(password) && hasSpecial.MatchString(password),
    }
    
    // 至少满足一种组合条件
    for _, condition := range conditions {
        if condition {
            return true
        }
    }
    
    return false
}

func main() {
    testPasswords := []string{
        "Abc123!@#",      // 应该通过
        "password",       // 应该失败
        "ABC123!@#",      // 应该通过
        "abc123!@#",      // 应该失败（无大写）
        "Abcdefgh",       // 应该失败（无数字或特殊字符）
        "test.@example",  // 应该失败（点号后跟@）
        "test.example",   // 应该通过
    }
    
    for _, pwd := range testPasswords {
        result := validatePassword(pwd)
        fmt.Printf("密码: %-15s 验证结果: %t\n", pwd, result)
    }
}

方案2：使用字符串函数替代部分正则检查

package main

import (
    "fmt"
    "regexp"
    "strings"
    "unicode"
)

func validatePasswordOptimized(password string) bool {
    // 长度检查
    if len(password) < 8 || len(password) > 16 {
        return false
    }
    
    // 检查允许的字符
    allowedChars := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789@#$%^&£* -_+=[]{}|\\:',?/~\"();!."
    for _, char := range password {
        if !strings.ContainsRune(allowedChars, char) {
            return false
        }
    }
    
    // 检查点号后面不能跟@
    if strings.Contains(password, ".@") {
        return false
    }
    
    // 使用字符分类检查
    var hasLower, hasUpper, hasDigit, hasSpecial bool
    
    for _, char := range password {
        switch {
        case unicode.IsLower(char):
            hasLower = true
        case unicode.IsUpper(char):
            hasUpper = true
        case unicode.IsDigit(char):
            hasDigit = true
        case !unicode.IsLetter(char) && !unicode.IsDigit(char):
            hasSpecial = true
        }
    }
    
    // 检查四种组合条件
    return (hasLower && hasUpper && hasDigit) ||
           (hasLower && hasUpper && hasSpecial) ||
           (hasLower && hasDigit && hasSpecial) ||
           (hasUpper && hasDigit && hasSpecial)
}

func main() {
    passwords := []string{
        "Password123!",    // 应该通过
        "weak",           // 应该失败
        "STRONG123!",     // 应该通过  
        "mixed123",       // 应该失败（无特殊字符）
    }
    
    for _, pwd := range passwords {
        fmt.Printf("密码: %-15s 验证: %t\n", pwd, validatePasswordOptimized(pwd))
    }
}

方案3：封装为可重用的验证器

package main

import (
    "fmt"
    "regexp"
    "strings"
    "unicode"
)

type PasswordValidator struct {
    minLength    int
    maxLength    int
    allowedChars *regexp.Regexp
}

func NewPasswordValidator(min, max int) *PasswordValidator {
    return &PasswordValidator{
        minLength:    min,
        maxLength:    max,
        allowedChars: regexp.MustCompile(`^[A-Za-z\d@#$%^&£*\ \-_\+=\[\]{}|\\:',?/~"();!\.]+$`),
    }
}

func (pv *PasswordValidator) Validate(password string) (bool, []string) {
    var errors []string
    
    // 长度检查
    if len(password) < pv.minLength {
        errors = append(errors, fmt.Sprintf("密码长度不能少于%d位", pv.minLength))
    }
    if len(password) > pv.maxLength {
        errors = append(errors, fmt.Sprintf("密码长度不能超过%d位", pv.maxLength))
    }
    
    // 字符集检查
    if !pv.allowedChars.MatchString(password) {
        errors = append(errors, "密码包含不允许的字符")
    }
    
    // 点号检查
    if strings.Contains(password, ".@") {
        errors = append(errors, "点号后不能直接跟@符号")
    }
    
    // 复杂度检查
    complexityErrors := pv.checkComplexity(password)
    errors = append(errors, complexityErrors...)
    
    return len(errors) == 0, errors
}

func (pv *PasswordValidator) checkComplexity(password string) []string {
    var hasLower, hasUpper, hasDigit, hasSpecial bool
    
    for _, char := range password {
        switch {
        case unicode.IsLower(char):
            hasLower = true
        case unicode.IsUpper(char):
            hasUpper = true
        case unicode.IsDigit(char):
            hasDigit = true
        case !unicode.IsLetter(char) && !unicode.IsDigit(char):
            hasSpecial = true
        }
    }
    
    var errors []string
    
    // 检查是否满足四种组合之一
    validCombination := (hasLower && hasUpper && hasDigit) ||
        (hasLower && hasUpper && hasSpecial) ||
        (hasLower && hasDigit && hasSpecial) ||
        (hasUpper && hasDigit && hasSpecial)
    
    if !validCombination {
        errors = append(errors, "密码必须包含以下四种字符类型中的至少三种：小写字母、大写字母、数字、特殊字符")
    }
    
    return errors
}

func main() {
    validator := NewPasswordValidator(8, 16)
    
    testCases := []string{
        "ValidPass123!",
        "short",
        "NoSpecial123",
        "test.@invalid",
    }
    
    for _, pwd := range testCases {
        isValid, errors := validator.Validate(pwd)
        fmt.Printf("密码: %-15s 有效: %t\n", pwd, isValid)
        if len(errors) > 0 {
            for _, err := range errors {
                fmt.Printf("  - %s\n", err)
            }
        }
        fmt.Println()
    }
}

这些方案通过分解原始复杂正则表达式的各个部分，在 Go 中实现了相同的密码验证逻辑，同时避免了前瞻断言的使用。方案2的性能通常最好，因为它减少了正则表达式的使用。