Utilisez des expressions régulières en Golang pour vérifier si une chaîne est un nombre

En golang, les expressions régulières peuvent être utilisées pour vérifier facilement si une chaîne est un nombre. Voyons comment utiliser les expressions régulières pour la vérification numérique dans Golang.

Tout d'abord, nous devons importer le package d'expressions régulières associé, à savoir le package regexp. Dans Golang, le package regexp fournit une fonction MatchString, qui peut être utilisée pour vérifier si une chaîne est conforme aux règles d'une certaine expression régulière.

Ensuite, nous devons écrire une expression régulière pour la vérification numérique. En Golang, les nombres peuvent être des nombres entiers ou des nombres à virgule flottante, nous devons donc écrire deux expressions régulières pour vérifier respectivement les nombres entiers et les nombres à virgule flottante.

Expression régulière pour valider des entiers :

^[0-9]+$

La signification de cette expression régulière est qu'elle commence par les nombres 0-9, contient un ou plusieurs nombres 0-9 au milieu et se termine par les nombres 0-9. Cette expression régulière peut vérifier si une chaîne est un entier.

Expression régulière pour vérifier les nombres à virgule flottante :

^[0-9]+(.[0-9]+)?$

La signification de cette expression régulière est qu'elle commence par les nombres 0-9, contient 1 ou plusieurs chiffres 0-9 au milieu, et ensuite il peut y avoir un point décimal ".", suivi de Il est suivi d'un ou plusieurs chiffres de 0 à 9, et se termine enfin par le chiffre de 0 à 9. Cette expression régulière peut vérifier si une chaîne est un nombre à virgule flottante.

Maintenant, voyons comment utiliser ces deux expressions régulières pour la vérification numérique dans Golang :

package main

import (
    "fmt"
    "regexp"
)

func isNumber(str string) bool {
    // 整数的正则表达式
    integerPattern := "^[0-9]+$"

    // 浮点数的正则表达式
    floatPattern := "^[0-9]+(\.[0-9]+)?$"

    match, _ := regexp.MatchString(integerPattern, str)
    if match {
        return true
    }

    match, _ = regexp.MatchString(floatPattern, str)
    if match {
        return true
    }

    return false
}

func main() {
    fmt.Println(isNumber("123"))    // true
    fmt.Println(isNumber("12.3"))   // true
    fmt.Println(isNumber("abc"))    // false
    fmt.Println(isNumber("1a2b3c")) // false
}

Dans le code ci-dessus, nous avons écrit une fonction isNumber pour la vérification numérique. Cette fonction accepte une chaîne comme paramètre, puis utilise des expressions régulières entières et des expressions régulières à virgule flottante pour vérifier si la chaîne est un nombre. Si la vérification réussit, elle renvoie vrai, sinon elle renvoie faux.

Enfin, dans la fonction principale, nous appelons la fonction isNumber pour vérifier si une chaîne est un nombre. Comme vous pouvez le voir, si la chaîne d'entrée est un nombre, le résultat renvoyé par la fonction est vrai, sinon il est faux.

Dans le développement actuel, la vérification numérique est une opération très courante. L'utilisation d'expressions régulières nous permet d'effectuer plus facilement une vérification numérique. Ce qui précède est une introduction à l'utilisation d'expressions régulières pour vérifier si une chaîne est un nombre en Golang.

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!