Comment puis-je nettoyer et valider les champs de chaîne dans les structures à l'aide de Reflection in Go ?

Itération des champs de chaîne dans les structures à l'aide de la réflexion

Lorsque vous travaillez avec des structures complexes contenant des champs de chaîne, il est souvent nécessaire de nettoyer ou de valider ces champs . Bien que l'itération manuelle puisse devenir inévolutive, l'utilisation de la réflexion offre une solution flexible.

Implémentation de l'itération de champ

Pour parcourir les champs d'une structure à l'aide de la réflexion, suivez ces étapes :

• Obtenir un pointeur vers la structure : Passez un pointeur vers la structure car il permet la modification du champ.
• Récupérez la valeur de la structure : Utilisez Reflect.ValueOf pour obtenir la structure Value représentant votre structure.
• Itérer sur les champs : Parcourez les champs de la structure Value à l'aide des méthodes NumField et Field.
• Vérifier le type de champ : Ne prendre en compte que les champs de type chaîne.
• Modifier les champs de chaîne : Coupez les espaces ou appliquez d'autres modifications aux champs de chaîne identifiés.
• Définissez le champ modifié : Utilisez field.SetString pour redéfinir la valeur modifiée dans la structure d'origine.

Gestion des erreurs et validation

Dans votre cas spécifique, vous souhaitez valider les champs et vérifier les longueurs maximales spécifiées par les balises de champ :

• Gestion des erreurs : Créez un type d'erreur personnalisé pour représenter les erreurs rencontrées.
• Collecte des erreurs : Collectez les erreurs rencontrées dans une tranche de chaînes d'erreur.
• Analyse des balises de champ : Analysez les balises de champ pour les valeurs de longueur maximale à l'aide du champ .Tag.Get("max").
• Validation de la longueur : Comparez les valeurs des champs avec les longueurs maximales et ajoutez les erreurs si les limites sont dépassées.
• Retour d'erreur : Renvoie les erreurs collectées le cas échéant.

Exemple de code

Voici un exemple d'implémentation :

<code class="go">package main

import (
    "fmt"
    "reflect"
    "strings"
)

type MyStruct struct {
    A, B, C string
    I int
    D string
    J int
}

func main() {
    ms := MyStruct{"Green ", " Eggs", " and ", 2, " Ham      ", 15}

    msValuePtr := reflect.ValueOf(&ms)
    msValue := msValuePtr.Elem()

    var invalid []string

    for i := 0; i < msValue.NumField(); i++ {
        field := msValue.Field(i)

        if field.Type() != reflect.TypeOf("") {
            continue
        }

        str := field.Interface().(string)
        str = strings.TrimSpace(str)
        field.SetString(str)

        maxTag := field.Tag.Get("max")
        if maxTag != "" {
            maxLength, _ := strconv.Atoi(maxTag)
            runeCount := unicode.RuneCountInString(str)
            if runeCount > maxLength {
                invalid = append(invalid, "Field exceeded max length")
            }
        }
    }

    if len(invalid) > 0 {
        fmt.Println("Validation errors:")
        for _, err := range invalid {
            fmt.Println(err)
        }
    } else {
        fmt.Println("Validation successful")
    }
}</code>

Ce code montre comment nettoyer les champs de chaîne et valider les longueurs en fonction des balises de champ.

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!