Une Plongée Profonde Dans Les Expressions Régulières Avec Golang

Les expressions régulières sont une caractéristique clé de chaque langage de programmation dans le développement de logiciels. Il est pratique lorsque vous devez créer une logique de validation des données qui compare les valeurs d'entrée à un modèle. Golang est livré avec un package regexp intégré qui vous permet d'écrire des expressions régulières de toute complexité.

Correspondances de base avec la fonction regex

Le package regexp fournit un certain nombre de fonctions pour gérer les correspondances de modèles.
Pour cet article, nous allons expérimenter les fonctions de base et les plus utiles pour gérer les correspondances de modèles.

`MatchString`

La MatchStringfonction vérifie si la chaîne d'entrée contient une correspondance du modèle d'expression régulière. Il accepte un modèle d'expression régulière et une chaîne en tant que paramètres et renvoie trues'il y a une correspondance. Si le modèle ne parvient pas à se compiler, des erreurs sont renvoyées.

Voici un extrait de l'explication ci-dessus :

package main
import (
    "fmt"
    "regexp"
)
func main() {
    inputText := "I love new york city"
    match, err := regexp.MatchString("[A-z]ork", inputText)
    if err == nil {
        fmt.Println("Match:", match)
    } else {
        fmt.Println("Error:", err)
    }
}

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

Match: true

`FindStringIndex`

FindStringIndexrenvoie uniquement la première correspondance, en progressant de gauche à droite. La correspondance est exprimée sous la forme d'une inttranche, la première valeur indiquant le début de la correspondance dans la chaîne et le second nombre indiquant le nombre de caractères correspondants. Un nilrésultat signifie qu'aucune correspondance n'a été trouvée.

Voici un exemple de cas d'utilisation de la FindStringIndexméthode :

package main
import (
    "fmt"
    "regexp"
)
func getSubstring(s string, indices []int) string {
    return string(s[indices[0]:indices[1]])
}
func main() {
    pattern := regexp.MustCompile("H[a-z]{4}|[A-z]ork")
    welcomeMessage := "Hello guys, welcome to new york city"
    firstMatchIndex := pattern.FindStringIndex(welcomeMessage)
    fmt.Println("First matched index", firstMatchIndex[0], "-", firstMatchIndex[1],
        "=", getSubstring(welcomeMessage, firstMatchIndex))
}

Ici, nous avons écrit une getSubstringfonction personnalisée qui renvoie une sous-chaîne composée des valeurs de la inttranche et de la chaîne d'entrée. Le package regexp a la FindStringfonction intégrée qui obtient le même résultat.

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

First matched index 0 - 5 = Hello

`FindString`

Cette méthode renvoie uniquement la première chaîne correspondante, en progressant de gauche à droite par le modèle compilé.

Une chaîne vide sera retournée si aucune correspondance n'est faite. S'il n'y a pas de correspondance, la valeur de retour est une chaîne vide, mais elle sera également vide si l'expression régulière correspond avec succès à une chaîne vide. Si vous devez faire la distinction entre ces cas, utilisez les méthodes FindStringIndexou .FindStringSubmatch

Voici un exemple de cas d'utilisation de la FindStringméthode :

package main
import (
    "fmt"
    "regexp"
)
func main() {
    pattern := regexp.MustCompile("H[a-z]{4}|[A-z]ork")
    welcomeMessage := "Hello guys, welcome to new york city"
    firstMatchSubstring := pattern.FindString(welcomeMessage)
    fmt.Println("First matched substring:", firstMatchSubstring)
}

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

First matched substring: Hello

`FindAllString`(s, max)

Cette méthode prend une chaîne et des intarguments et renvoie une tranche de chaîne contenant toutes les correspondances trouvées dans la chaîne d'entrée par le modèle compilé dans la chaîne d'entrée. Le nombre maximum de correspondances est spécifié par l' intargument max, avec -1n'indiquant aucune limite. S'il n'y a pas de correspondance, un nilrésultat est renvoyé.

Voici un exemple de cas d'utilisation de la FindAllStringméthode :

package main
import (
    "fmt"
    "regexp"
)
func main() {
    pattern := regexp.MustCompile("H[a-z]{4}|[A-z]ork")
    welcomeMessage := "Hello guys, welcome to new york city"
    allSubstringMatches := pattern.FindAllString(welcomeMessage, -1)
    fmt.Println(allSubstringMatches)
}

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

[Hello york]

`FindAllStringIndex`(s, max)

La FindAllStringIndexméthode est la Allversion de FindStringIndex. Il prend une chaîne et des intarguments et renvoie une tranche de inttranches de toutes les correspondances successives du modèle. S'il n'y a pas de correspondance, un résultat nul est renvoyé.

L'appel d'une FindAllméthode avec le intparamètre de 0ne renverra aucun résultat, et l'appel avec le intparamètre de 1renverra une tranche de inttranche de la première chaîne correspondante à partir de la gauche. Le intparamètre de -1renvoie une tranche de inttranches de toutes les correspondances successives du motif.

La tranche renvoyée contient deux intvaleurs, la première valeur indiquant le début de la correspondance dans la chaîne et la seconde indiquant le nombre de caractères correspondants.

Voici un exemple de cas d'utilisation de la FindAllStringIndexméthode :

package main
import (
    "fmt"
    "regexp"
)
func getSubstring(s string, indices []int) string {
    return string(s[indices[0]:indices[1]])
}
func main() {
    pattern := regexp.MustCompile("H[a-z]{4}|[A-z]ork")
    welcomeMessage := "Hello guys, welcome to new york city"
    allIndices := pattern.FindAllStringIndex(welcomeMessage, -1)
    fmt.Println(allIndices)
    for i, idx := range allIndices {
        fmt.Println("Index", i, "=", idx[0], "-",
            idx[1], "=", getSubstring(welcomeMessage, idx))
    }
}

Ici, nous avons écrit une boucle for de base qui appelle notre getSubstringfonction personnalisée qui renvoie une sous-chaîne composée des valeurs de la inttranche et de la chaîne d'entrée.

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

\[[0 5\] [27 31]]
Index 0 = 0 - 5 = Hello
Index 1 = 27 - 31 = york

Compiler et réutiliser des modèles d'expressions régulières

La méthode Compile compile un modèle d'expression régulière afin qu'il puisse être réutilisé dans des requêtes plus complexes.

attern, compileErr := regexp.Compile("[A-z]ork")

Voici comment écrire un modèle de compilation dans Golang :

package main
import (
    "fmt"
    "regexp"
)
func main() {
    pattern, compileErr := regexp.Compile("[A-z]ork")
    correctAnswer := "Yes, I love new york city"
    question := "Do you love new york city?"
    wrongAnswer := "I love dogs"
    if compileErr == nil {
        fmt.Println("Question:", pattern.MatchString(question))
        fmt.Println("Correct Answer:", pattern.MatchString(correctAnswer))
        fmt.Println("Wrong Answer:", pattern.MatchString(wrongAnswer))
    } else {
        fmt.Println("Error:", compileErr)
    }
}

Parce que le modèle n'a besoin d'être compilé qu'une seule fois, c'est plus efficace. La MatchStringfonction est définie par une instance du RegExptype, qui est renvoyée par la Compilefonction.

La compilation d'un modèle vous donne également accès aux fonctionnalités et techniques d'expression régulière.

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

Question : vrai Bonne réponse : vrai Mauvaise réponse : faux

Utilisation d'une expression régulière pour diviser des chaînes

La Splitméthode divise une chaîne en utilisant les correspondances faites par une expression régulière. Il prend une chaîne et des intarguments et renvoie une tranche des sous-chaînes fractionnées. Le intparamètre de -1renvoie une tranche de sous-chaînes de toutes les correspondances successives du modèle.

`split`(s, max)

package main
import (
    "fmt"
    "regexp"
)
func main() {
    pattern := regexp.MustCompile("guys|york")
    welcomeMessage := "Hello guys, welcome to new york city"
    split := pattern.Split(welcomeMessage, -1)
    for _, s := range split {
        if s != "" {
            fmt.Println("Substring:", s)
        }
    }
}

Ici, nous avons écrit une forboucle de base pour imprimer chaque sous-chaîne scindée.

Vous pouvez expérimenter davantage en remplaçant -1par d'autres nombres.

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

[Hello  , welcome to new   city]
Substring: Hello 
Substring: , welcome to new 
Substring:  city

Sous-expressions

Les sous-expressions facilitent la récupération des sous-chaînes à partir d'une région correspondante en permettant l'accès aux sections d'une expression régulière. Les sous-expressions sont indiquées entre parenthèses. Il peut être utilisé pour identifier les régions de contenu qui sont importantes dans le modèle :

pattern := regexp.MustCompile("welcome ([A-z]*) new ([A-z]*) city")

`FindStringSubmatch`

La FindStringSubmatchméthode est une méthode de sous-expression qui fait la même chose que la FindStringméthode mais renvoie en plus les sous-chaînes correspondant aux expressions :

package main
import (
    "fmt"
    "regexp"
)
func main() {
    pattern := regexp.MustCompile("welcome ([A-z]*) new ([A-z]*) city")
    welcomeMessage := "Hello guys, welcome to new york city"
    subStr := pattern.FindStringSubmatch(welcomeMessage)
    fmt.Println(subStr)

    for _, s := range subStr {
        fmt.Println("Match:", s)
    }
}

Ici, nous avons défini deux sous-expressions, une pour chaque composant variable du modèle.

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

[welcome to new york city to york]
Match: welcome to new york city
Match: to
Match: york

Nommer les sous-expressions

Les sous-expressions peuvent également être nommées pour faciliter le traitement des sorties résultantes.

Voici comment nommer une sous-expression : entre parenthèses, ajoutez un point d'interrogation, suivi d'une majuscule P, suivi du nom entre crochets.

Voici un extrait de l'explication ci-dessus :

pattern := regexp.MustCompile("welcome (?P<val1>[A-z]*) new (?P<val2>[A-z]*) city")

Ici, les sous-expressions reçoivent les noms val1et val2.

Les méthodes d'expression régulière pour les sous-expressions

`SubexpNames()`

Cette méthode renvoie une tranche contenant les noms des sous-expressions, exprimées dans l'ordre dans lequel elles sont définies :

package main
import (
    "fmt"
    "regexp"
)
func main() {
    pattern := regexp.MustCompile("welcome (?P<val1>[A-z]*) new (?P<val2>[A-z]*) city")
    replaced := pattern.SubexpNames()
    fmt.Println(replaced)
}

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

[ val1 val2]

`NumSubexp()`

Cette méthode renvoie le nombre de sous-expressions :

package main
import (
    "fmt"
    "regexp"
)
func main() {
    pattern := regexp.MustCompile("welcome (?P<val1>[A-z]*) new (?P<val2>[A-z]*) city")
    replaced := pattern.NumSubexp()
    fmt.Println(replaced)
}

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

Consultez la documentation Golang pour plus de méthodes d'expression régulière pour les sous-expressions.

Utilisation d'une expression régulière pour remplacer des sous-chaînes

Le package regexp fournit un certain nombre de méthodes pour remplacer les sous-chaînes.

`ReplaceAllString`( `s`, `template`)

Cette méthode prend la chaîne et un templateparamètre et remplace la partie correspondante de la ou des chaînes par le modèle spécifié, qui est développé avant d'être inclus dans le résultat pour s'adapter aux sous-expressions :

package main
import (
    "fmt"
    "regexp"
)
func main() {
    pattern := regexp.MustCompile("welcome (?P<val1>[A-z]*) new (?P<val2>[A-z]*) city")
    welcomeMessage := "Hello guys, welcome to new york city"
    template := "(value 1: ${val1}, value 2: ${val2})"
    replaced := pattern.ReplaceAllString(welcomeMessage, template)
    fmt.Println(replaced)
}

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

Hello guys, (value 1: to, value 2: york)

`ReplaceAllLiteralString`( `s`, sous)

Cette méthode prend la chaîne et un templateparamètre et remplace le morceau correspondant de la ou des chaînes par le modèle spécifié, qui est inclus dans le résultat sans être développé pour les sous-expressions :

package main
import (
    "fmt"
    "regexp"
)
func main() {
    pattern := regexp.MustCompile("welcome (?P<val1>[A-z]*) new (?P<val2>[A-z]*) city")
    welcomeMessage := "Hello guys, welcome to new york city"
    template := "(value 1: ${val1}, value 2: ${val2})"
    replaced := pattern.ReplaceAllLiteralString(welcomeMessage, template)
    fmt.Println(replaced)
}

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

Hello guys, (value 1: ${val1}, value 2: ${val2})

Utiliser une fonction pour remplacer le contenu correspondant

La ReplaceAllStringFuncméthode substitue le contenu généré par une fonction à la partie correspondante de la chaîne d'entrée :

package main
import (
    "fmt"
    "regexp"
)
func main() {
    pattern := regexp.MustCompile("welcome ([A-z]*) new ([A-z]*) city")
    welcomeMessage := "Hello guys, welcome to new york city"
    replaced := pattern.ReplaceAllStringFunc(welcomeMessage, func(s string) string {
        return "here is the replacement content for the matched string."
    })
    fmt.Println(replaced)
}

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

Bonjour les gars, voici le contenu de remplacement pour la chaîne correspondante

Conclusion

Dans cet article, nous avons exploré le package go regexp , ainsi que ses méthodes intégrées pour gérer les correspondances de base à complexes avec regex et compiler et réutiliser des modèles d'expression régulière.

Vous pouvez consulter la documentation go regexp pour plus d'informations sur les expressions régulières avec Golang.

Source : https://blog.logrocket.com/deep-dive-regular-expressions-golang/

#golang

What is GEEK

Buddha Community

Une Plongée Profonde Dans Les Expressions Régulières Avec Golang

Léon Peltier

1657703340

Une Plongée Profonde Dans Les Expressions Régulières Avec Golang

Les expressions régulières sont une caractéristique clé de chaque langage de programmation dans le développement de logiciels. Il est pratique lorsque vous devez créer une logique de validation des données qui compare les valeurs d'entrée à un modèle. Golang est livré avec un package regexp intégré qui vous permet d'écrire des expressions régulières de toute complexité.

Correspondances de base avec la fonction regex

Le package regexp fournit un certain nombre de fonctions pour gérer les correspondances de modèles.
Pour cet article, nous allons expérimenter les fonctions de base et les plus utiles pour gérer les correspondances de modèles.

`MatchString`

La MatchStringfonction vérifie si la chaîne d'entrée contient une correspondance du modèle d'expression régulière. Il accepte un modèle d'expression régulière et une chaîne en tant que paramètres et renvoie trues'il y a une correspondance. Si le modèle ne parvient pas à se compiler, des erreurs sont renvoyées.

Voici un extrait de l'explication ci-dessus :

package main
import (
    "fmt"
    "regexp"
)
func main() {
    inputText := "I love new york city"
    match, err := regexp.MatchString("[A-z]ork", inputText)
    if err == nil {
        fmt.Println("Match:", match)
    } else {
        fmt.Println("Error:", err)
    }
}

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

Match: true

`FindStringIndex`

FindStringIndexrenvoie uniquement la première correspondance, en progressant de gauche à droite. La correspondance est exprimée sous la forme d'une inttranche, la première valeur indiquant le début de la correspondance dans la chaîne et le second nombre indiquant le nombre de caractères correspondants. Un nilrésultat signifie qu'aucune correspondance n'a été trouvée.

Voici un exemple de cas d'utilisation de la FindStringIndexméthode :

package main
import (
    "fmt"
    "regexp"
)
func getSubstring(s string, indices []int) string {
    return string(s[indices[0]:indices[1]])
}
func main() {
    pattern := regexp.MustCompile("H[a-z]{4}|[A-z]ork")
    welcomeMessage := "Hello guys, welcome to new york city"
    firstMatchIndex := pattern.FindStringIndex(welcomeMessage)
    fmt.Println("First matched index", firstMatchIndex[0], "-", firstMatchIndex[1],
        "=", getSubstring(welcomeMessage, firstMatchIndex))
}

Ici, nous avons écrit une getSubstringfonction personnalisée qui renvoie une sous-chaîne composée des valeurs de la inttranche et de la chaîne d'entrée. Le package regexp a la FindStringfonction intégrée qui obtient le même résultat.

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

First matched index 0 - 5 = Hello

`FindString`

Cette méthode renvoie uniquement la première chaîne correspondante, en progressant de gauche à droite par le modèle compilé.

Une chaîne vide sera retournée si aucune correspondance n'est faite. S'il n'y a pas de correspondance, la valeur de retour est une chaîne vide, mais elle sera également vide si l'expression régulière correspond avec succès à une chaîne vide. Si vous devez faire la distinction entre ces cas, utilisez les méthodes FindStringIndexou .FindStringSubmatch

Voici un exemple de cas d'utilisation de la FindStringméthode :

package main
import (
    "fmt"
    "regexp"
)
func main() {
    pattern := regexp.MustCompile("H[a-z]{4}|[A-z]ork")
    welcomeMessage := "Hello guys, welcome to new york city"
    firstMatchSubstring := pattern.FindString(welcomeMessage)
    fmt.Println("First matched substring:", firstMatchSubstring)
}

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

First matched substring: Hello

`FindAllString`(s, max)

Cette méthode prend une chaîne et des intarguments et renvoie une tranche de chaîne contenant toutes les correspondances trouvées dans la chaîne d'entrée par le modèle compilé dans la chaîne d'entrée. Le nombre maximum de correspondances est spécifié par l' intargument max, avec -1n'indiquant aucune limite. S'il n'y a pas de correspondance, un nilrésultat est renvoyé.

Voici un exemple de cas d'utilisation de la FindAllStringméthode :

package main
import (
    "fmt"
    "regexp"
)
func main() {
    pattern := regexp.MustCompile("H[a-z]{4}|[A-z]ork")
    welcomeMessage := "Hello guys, welcome to new york city"
    allSubstringMatches := pattern.FindAllString(welcomeMessage, -1)
    fmt.Println(allSubstringMatches)
}

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

[Hello york]

`FindAllStringIndex`(s, max)

La FindAllStringIndexméthode est la Allversion de FindStringIndex. Il prend une chaîne et des intarguments et renvoie une tranche de inttranches de toutes les correspondances successives du modèle. S'il n'y a pas de correspondance, un résultat nul est renvoyé.

L'appel d'une FindAllméthode avec le intparamètre de 0ne renverra aucun résultat, et l'appel avec le intparamètre de 1renverra une tranche de inttranche de la première chaîne correspondante à partir de la gauche. Le intparamètre de -1renvoie une tranche de inttranches de toutes les correspondances successives du motif.

La tranche renvoyée contient deux intvaleurs, la première valeur indiquant le début de la correspondance dans la chaîne et la seconde indiquant le nombre de caractères correspondants.

Voici un exemple de cas d'utilisation de la FindAllStringIndexméthode :

package main
import (
    "fmt"
    "regexp"
)
func getSubstring(s string, indices []int) string {
    return string(s[indices[0]:indices[1]])
}
func main() {
    pattern := regexp.MustCompile("H[a-z]{4}|[A-z]ork")
    welcomeMessage := "Hello guys, welcome to new york city"
    allIndices := pattern.FindAllStringIndex(welcomeMessage, -1)
    fmt.Println(allIndices)
    for i, idx := range allIndices {
        fmt.Println("Index", i, "=", idx[0], "-",
            idx[1], "=", getSubstring(welcomeMessage, idx))
    }
}

Ici, nous avons écrit une boucle for de base qui appelle notre getSubstringfonction personnalisée qui renvoie une sous-chaîne composée des valeurs de la inttranche et de la chaîne d'entrée.

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

\[[0 5\] [27 31]]
Index 0 = 0 - 5 = Hello
Index 1 = 27 - 31 = york

Compiler et réutiliser des modèles d'expressions régulières

La méthode Compile compile un modèle d'expression régulière afin qu'il puisse être réutilisé dans des requêtes plus complexes.

attern, compileErr := regexp.Compile("[A-z]ork")

Voici comment écrire un modèle de compilation dans Golang :

package main
import (
    "fmt"
    "regexp"
)
func main() {
    pattern, compileErr := regexp.Compile("[A-z]ork")
    correctAnswer := "Yes, I love new york city"
    question := "Do you love new york city?"
    wrongAnswer := "I love dogs"
    if compileErr == nil {
        fmt.Println("Question:", pattern.MatchString(question))
        fmt.Println("Correct Answer:", pattern.MatchString(correctAnswer))
        fmt.Println("Wrong Answer:", pattern.MatchString(wrongAnswer))
    } else {
        fmt.Println("Error:", compileErr)
    }
}

Parce que le modèle n'a besoin d'être compilé qu'une seule fois, c'est plus efficace. La MatchStringfonction est définie par une instance du RegExptype, qui est renvoyée par la Compilefonction.

La compilation d'un modèle vous donne également accès aux fonctionnalités et techniques d'expression régulière.

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

Question : vrai Bonne réponse : vrai Mauvaise réponse : faux

Utilisation d'une expression régulière pour diviser des chaînes

La Splitméthode divise une chaîne en utilisant les correspondances faites par une expression régulière. Il prend une chaîne et des intarguments et renvoie une tranche des sous-chaînes fractionnées. Le intparamètre de -1renvoie une tranche de sous-chaînes de toutes les correspondances successives du modèle.

`split`(s, max)

package main
import (
    "fmt"
    "regexp"
)
func main() {
    pattern := regexp.MustCompile("guys|york")
    welcomeMessage := "Hello guys, welcome to new york city"
    split := pattern.Split(welcomeMessage, -1)
    for _, s := range split {
        if s != "" {
            fmt.Println("Substring:", s)
        }
    }
}

Ici, nous avons écrit une forboucle de base pour imprimer chaque sous-chaîne scindée.

Vous pouvez expérimenter davantage en remplaçant -1par d'autres nombres.

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

[Hello  , welcome to new   city]
Substring: Hello 
Substring: , welcome to new 
Substring:  city

Sous-expressions

Les sous-expressions facilitent la récupération des sous-chaînes à partir d'une région correspondante en permettant l'accès aux sections d'une expression régulière. Les sous-expressions sont indiquées entre parenthèses. Il peut être utilisé pour identifier les régions de contenu qui sont importantes dans le modèle :

pattern := regexp.MustCompile("welcome ([A-z]*) new ([A-z]*) city")

`FindStringSubmatch`

La FindStringSubmatchméthode est une méthode de sous-expression qui fait la même chose que la FindStringméthode mais renvoie en plus les sous-chaînes correspondant aux expressions :

package main
import (
    "fmt"
    "regexp"
)
func main() {
    pattern := regexp.MustCompile("welcome ([A-z]*) new ([A-z]*) city")
    welcomeMessage := "Hello guys, welcome to new york city"
    subStr := pattern.FindStringSubmatch(welcomeMessage)
    fmt.Println(subStr)

    for _, s := range subStr {
        fmt.Println("Match:", s)
    }
}

Ici, nous avons défini deux sous-expressions, une pour chaque composant variable du modèle.

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

[welcome to new york city to york]
Match: welcome to new york city
Match: to
Match: york

Nommer les sous-expressions

Les sous-expressions peuvent également être nommées pour faciliter le traitement des sorties résultantes.

Voici comment nommer une sous-expression : entre parenthèses, ajoutez un point d'interrogation, suivi d'une majuscule P, suivi du nom entre crochets.

Voici un extrait de l'explication ci-dessus :

pattern := regexp.MustCompile("welcome (?P<val1>[A-z]*) new (?P<val2>[A-z]*) city")

Ici, les sous-expressions reçoivent les noms val1et val2.

Les méthodes d'expression régulière pour les sous-expressions

`SubexpNames()`

Cette méthode renvoie une tranche contenant les noms des sous-expressions, exprimées dans l'ordre dans lequel elles sont définies :

package main
import (
    "fmt"
    "regexp"
)
func main() {
    pattern := regexp.MustCompile("welcome (?P<val1>[A-z]*) new (?P<val2>[A-z]*) city")
    replaced := pattern.SubexpNames()
    fmt.Println(replaced)
}

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

[ val1 val2]

`NumSubexp()`

Cette méthode renvoie le nombre de sous-expressions :

package main
import (
    "fmt"
    "regexp"
)
func main() {
    pattern := regexp.MustCompile("welcome (?P<val1>[A-z]*) new (?P<val2>[A-z]*) city")
    replaced := pattern.NumSubexp()
    fmt.Println(replaced)
}

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

Consultez la documentation Golang pour plus de méthodes d'expression régulière pour les sous-expressions.

Utilisation d'une expression régulière pour remplacer des sous-chaînes

Le package regexp fournit un certain nombre de méthodes pour remplacer les sous-chaînes.

`ReplaceAllString`( `s`, `template`)

Cette méthode prend la chaîne et un templateparamètre et remplace la partie correspondante de la ou des chaînes par le modèle spécifié, qui est développé avant d'être inclus dans le résultat pour s'adapter aux sous-expressions :

package main
import (
    "fmt"
    "regexp"
)
func main() {
    pattern := regexp.MustCompile("welcome (?P<val1>[A-z]*) new (?P<val2>[A-z]*) city")
    welcomeMessage := "Hello guys, welcome to new york city"
    template := "(value 1: ${val1}, value 2: ${val2})"
    replaced := pattern.ReplaceAllString(welcomeMessage, template)
    fmt.Println(replaced)
}

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

Hello guys, (value 1: to, value 2: york)

`ReplaceAllLiteralString`( `s`, sous)

Cette méthode prend la chaîne et un templateparamètre et remplace le morceau correspondant de la ou des chaînes par le modèle spécifié, qui est inclus dans le résultat sans être développé pour les sous-expressions :

package main
import (
    "fmt"
    "regexp"
)
func main() {
    pattern := regexp.MustCompile("welcome (?P<val1>[A-z]*) new (?P<val2>[A-z]*) city")
    welcomeMessage := "Hello guys, welcome to new york city"
    template := "(value 1: ${val1}, value 2: ${val2})"
    replaced := pattern.ReplaceAllLiteralString(welcomeMessage, template)
    fmt.Println(replaced)
}

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

Hello guys, (value 1: ${val1}, value 2: ${val2})

Utiliser une fonction pour remplacer le contenu correspondant

La ReplaceAllStringFuncméthode substitue le contenu généré par une fonction à la partie correspondante de la chaîne d'entrée :

package main
import (
    "fmt"
    "regexp"
)
func main() {
    pattern := regexp.MustCompile("welcome ([A-z]*) new ([A-z]*) city")
    welcomeMessage := "Hello guys, welcome to new york city"
    replaced := pattern.ReplaceAllStringFunc(welcomeMessage, func(s string) string {
        return "here is the replacement content for the matched string."
    })
    fmt.Println(replaced)
}

Compilez et exécutez le code ci-dessus, et vous obtiendrez le résultat suivant :

Bonjour les gars, voici le contenu de remplacement pour la chaîne correspondante

Conclusion

Dans cet article, nous avons exploré le package go regexp , ainsi que ses méthodes intégrées pour gérer les correspondances de base à complexes avec regex et compiler et réutiliser des modèles d'expression régulière.

Vous pouvez consulter la documentation go regexp pour plus d'informations sur les expressions régulières avec Golang.

Source : https://blog.logrocket.com/deep-dive-regular-expressions-golang/

#golang

WebClues Infotech

1617882011

Hire Dedicated Golang Developers | Golang Web Development Company

Does your business need a robust system across large-scale network servers then developing your app with a Golang programming language is the way to go. Golang is generally used for the development of highly secured, High Speed and High Modularity apps such as a FinTech Industry.

Want to develop a Highly secured app for your business?

Then hire a dedicated Golang developer from WebClues Infotech that are highly skilled in carrying out the work in a timely and qualitative output. With WebClues Infotech you get the assurance that we know what are the customers’ expectations and how to deliver on them on time.

Get your desired Golang Developer based on your project requirement!!

Share your requirements here https://www.webcluesinfotech.com/contact-us/

Book Free Interview with Golang developer: https://bit.ly/3dDShFg

#hire golang developer #hire go language developer #dedicated golang app developers #golang web development company #hire golang developers india #hire expert golang developers

React Interview Questions & Answers

1625631360

How to Upload and Store Images in MySQL using Node.js and Express

Today we are going to explore the basic usage of Express-FileUpload. In addition to this, I will show you how you can save/update a user record with a profile image that you can upload.

Chapters:
0:00 Introduction:
1:16 NPM Project Setup
3:54 Creating Express Server
5:51 Setting up Layouts & Routes
9:46 Express Upload Form
21:50 User Card
33:40 Database
52:05 Ending

Source Files:
https://raddy.co.uk/blog/upload-and-store-images-in-mysql-using-node-js-express-express-fileupload-express-handlebars/

#node.js #express #express-fileupload #express-handlebars #mysql #upload and store images

Mobinius Technologies

1602065961

Golang Web Development:Th Best Programming Language in 2020

https://www.mobinius.com/blogs/golang-web-development-company

#golang web development #golang-app-development-company #golang-development-solutions #hire-golang-developers #golang-development-services

Ajay Kapoor

1624960485

Golang vs. Node.JS: Who Trumps the Battle of Backend Frameworks?

Full blog here

The backend of your application is truly the essential part of your product. No matter how much you appreciate the design, the application’s success lies in its backend. A scalable backend that effectively implements the required business logic is the primary goal of programmers.

Therefore, it is crucial to choose the most powerful and scalable technology. There are plenty of languages in the market that can form the backend of any application, Node.js and Golang are the two most popular technologies among them.

They are real and developed languages that have recently been used in various outstanding projects. Golang is an open-source programming language, whereas Node.js is an open-source server framework. They both are gaining popularity for various reasons.

According to a development stat, it is observed that almost 50% out of 58,543 respondents use Node.js as their preferred app development tool.

Golang, on the other hand, has overtaken other programming languages in the application development market and has gained huge recognition over the past few years.

But, which backend framework is best for you? In this article, I’ll make a healthy comparison of two of Google’s most popular backend development tools based on several essential features and various other factors.

Golang developers for hire

#best backend frameworks #node or golang #golang or nodejs #nodejs vs golang #golang vs nodejs #top backend frameworks

Une Plongée Profonde Dans Les Expressions Régulières Avec Golang

Correspondances de base avec la fonction regex

MatchString

FindStringIndex

FindString

FindAllString(s, max)

FindAllStringIndex(s, max)

Compiler et réutiliser des modèles d'expressions régulières

Utilisation d'une expression régulière pour diviser des chaînes

split(s, max)

Sous-expressions

FindStringSubmatch

Nommer les sous-expressions

Les méthodes d'expression régulière pour les sous-expressions

SubexpNames()

NumSubexp()

Utilisation d'une expression régulière pour remplacer des sous-chaînes

ReplaceAllString( s, template)

ReplaceAllLiteralString( s, sous)

Utiliser une fonction pour remplacer le contenu correspondant

Conclusion

What is GEEK

Buddha Community

Une Plongée Profonde Dans Les Expressions Régulières Avec Golang

Correspondances de base avec la fonction regex

MatchString

FindStringIndex

FindString

FindAllString(s, max)

FindAllStringIndex(s, max)

Compiler et réutiliser des modèles d'expressions régulières

Utilisation d'une expression régulière pour diviser des chaînes

split(s, max)

Sous-expressions

FindStringSubmatch

Nommer les sous-expressions

Les méthodes d'expression régulière pour les sous-expressions

SubexpNames()

NumSubexp()

Utilisation d'une expression régulière pour remplacer des sous-chaînes

ReplaceAllString( s, template)

ReplaceAllLiteralString( s, sous)

Utiliser une fonction pour remplacer le contenu correspondant

Conclusion

Hire Dedicated Golang Developers | Golang Web Development Company

How to Upload and Store Images in MySQL using Node.js and Express

Golang Web Development:Th Best Programming Language in 2020

Golang vs. Node.JS: Who Trumps the Battle of Backend Frameworks?

`MatchString`

`FindStringIndex`

`FindString`

`FindAllString`(s, max)

`FindAllStringIndex`(s, max)

`split`(s, max)

`FindStringSubmatch`

`SubexpNames()`

`NumSubexp()`

`ReplaceAllString`( `s`, `template`)

`ReplaceAllLiteralString`( `s`, sous)

`MatchString`

`FindStringIndex`

`FindString`

`FindAllString`(s, max)

`FindAllStringIndex`(s, max)

`split`(s, max)

`FindStringSubmatch`

`SubexpNames()`

`NumSubexp()`

`ReplaceAllString`( `s`, `template`)

`ReplaceAllLiteralString`( `s`, sous)