Pourquoi les expressions régulières Go et Python produisent-elles des résultats différents ?

Comportement des expressions régulières dans différentes langues : Go contre Python

Lorsqu'ils tentent d'utiliser des expressions régulières dans Go, les développeurs peuvent rencontrer un comportement inattendu. Par exemple, considérons le code suivant :

package main

import (
    "fmt"
    "regexp"
)

func main() {
    a := "parameter=0xFF"
    regex := "^.+=\b0x[A-F][A-F]\b$"
    result, err := regexp.MatchString(regex, a)
    fmt.Println(result, err) // Prints: false <nil>
}

Ce code ne correspond pas à la chaîne d'entrée attendue, bien qu'il fonctionne correctement en Python :

import re

p = re.compile(r"^.+=\b0x[A-F][A-F]\b$")
m = p.match("parameter=0xFF")
if m is not None:
    print(m.group())  # Prints: parameter=0xFF

La cause première de cet écart réside dans les différences entre les chaînes littérales dans Go et Python. Dans Go, les chaînes littérales sont considérées comme « cuites » par défaut, ce qui signifie qu'elles sont interprétées pour les caractères spéciaux comme les séquences d'échappement. Cependant, pour les expressions régulières, ce comportement est problématique.

Pour résoudre ce problème, Go fournit des littéraux de chaîne bruts. Les littéraux de chaîne brute sont placés entre guillemets arrière (`) au lieu de guillemets ("). Ils ignorent les caractères spéciaux ou les séquences d'échappement, garantissant que le littéral est interprété exactement comme il est écrit.

Par conséquent, pour résoudre le problème avec le code Go, l'expression régulière doit être spécifiée sous forme de chaîne littérale brute :

var regex = `^.+=\b0x[A-F][A-F]\b$`

Avec cette modification, le code correspondra désormais correctement à la chaîne d'entrée et produira le résultat souhaité. résultat.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!