sauter les caractères regex avant la recherche avec golang

Question

Cela permet de sauter les 2 premiers caractères et de commencer à faire correspondre les caractères de gauche à droite.

re := regexp.MustCompile("(^.{2})(\\/path\\/subpath((\\/.*)|()))")
fmt.Println(re.MatchString("c:/path/subpath/path/subpath/")) // true
fmt.Println(re.MatchString("c:/patch/subpath/path/subpath/")) // false

Remarquez que le second ne fonctionne pas, même si /path/subpath existe dans la chaîne. C'est parfait.

maintenant, si je ne sais pas combien de caractères il faut sauter et que je veux commencer la recherche au premier '/', j'ai essayé ceci

re2 := regexp.MustCompile("([^\\/])(\\/path\\/subpath((\\/.*)|()))")
fmt.Println(re2.MatchString("cddddd:/path/subpath/path/subpath"))  // true

ce qui est parfait. mais si je change le 1er chemin d'accès fmt.Println(re2.MatchString("cddddd:/patch/subpath/path/subpath")) // ceci est vrai aussi

Je ne veux pas que le dernier corresponde au deuxième /chemin/sous-chemin. Je veux pouvoir effectuer une recherche dans le premier groupe, commencer le deuxième groupe à partir de là et effectuer une correspondance de gauche à droite.

Toute aide serait très appréciée.

Answer 1

Cela vaut la peine d'être plus précis sur ce que vous voulez, énoncez ce que vous voulez en termes absolus, pas comme "le deuxième premier ne doit pas correspondre au troisième". Dites plutôt ;

Je veux capturer le chemin s'il commence par /path/subpath dans le deuxième groupe. Si un chemin contient /path/subpath quelque part après le début, alors je ne veux pas que ça corresponde.

De plus, les barres obliques ne sont pas spéciales dans les expressions rationnelles, et il n'est donc pas nécessaire de les escamoter deux fois pour rien.

La troisième expression, fait cela :

1. capturer tout ce qui n'est pas un slash dès l'ancre de départ
2. délimiter le groupe 1 du groupe 2 par :
3. exige que /chemin/sous-chemin soit en haut du chemin d'accès
4. capturer ce qui reste

C'est peut-être ce que vous voulez :

package main

import (
    "fmt"
    "regexp"
)

func main() {
    paths := []string{
        "c:/path/subpath/path/subpath/",
        "c:/patch/subpath/path/subpath/",
        "cddddd:/path/subpath/path/subpath",
    }

    re1 := regexp.MustCompile("(^.{2})(/path/subpath(/.*))")
    re2 := regexp.MustCompile("([^/])(/path/subpath((/.*)|()))")
    re3 := regexp.MustCompile(`^([^/]+):/path/subpath(/.*)`)

    for i, re := range []*regexp.Regexp{re1, re2, re3} {
        i++
        for _, s := range paths {
            fmt.Println(i, re.MatchString(s), s)
            if re.MatchString(s) {
                matches := re.FindStringSubmatch(s)
                for m, g := range matches {
                    m++
                    if m > 1 {
                        fmt.Printf("\n\t%d %v", m, g)
                    }
                }
            }
            println()
        }
        println()
    }
}

Sortie

$ go run so-regex-path.go 
(...)

3 true c:/path/subpath/path/subpath/

    2 c
    3 /path/subpath/
3 false c:/patch/subpath/path/subpath/

3 true cddddd:/path/subpath/path/subpath

    2 cddddd
    3 /path/subpath