Comment détecter si une variable est une chaîne dans Golang

Méthode pour détecter si une variable est une chaîne : 1. Utilisez l'identifiant de formatage "%T", syntaxe "fmt.Printf("variable count=%v is of type %T n", count, count)" 2. Utilisez Reflect.TypeOf(), la syntaxe est "reflect.TypeOf(variable)" ; 3. Utilisez Reflect.ValueOf().Kind() pour la détection. 4. Utilisez les assertions de type pour regrouper les types.

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

Golang détecte si une variable est une chaîne en vérifiant le type de la variable. Voici plusieurs méthodes.

Go fournit plusieurs méthodes pour vérifier le type de variables, notamment l'identifiant de formatage de chaîne %T, les méthodes de réflexion : Reflect.TypeOf, Reflect.ValueOf.Kind, ainsi que l'utilisation d'assertions de type et de méthodes de changement de casse. Ces quatre types de méthodes sont présentés ci-dessous à travers des exemples.

Identifiant de formatage %T

L'utilisation de l'identifiant de formatage de chaîne %T est le moyen le plus simple de vérifier le type. %T est le package fmt, vous pouvez utiliser fmt.Printf pour afficher le type de variable :

import (
	"fmt"
)

func main() {

	var count int = 42
	var message string = "go find type"
	var isCheck bool = true
	var amount float32 = 10.2

	fmt.Printf("variable count=%v is of type %T \n", count, count)
	fmt.Printf("variable message='%v' is of type %T \n", message, message)
	fmt.Printf("variable isCheck='%v' is of type %T \n", isCheck, isCheck)
	fmt.Printf("variable amount=%v is of type %T \n", amount, amount)
}

//OutPut

variable count=42 is of type int
variable message='go find type' is of type string
variable isCheck='true' is of type bool
variable amount=10.2 is of type float32

Utilisez la fonction du package Reflect

Si la méthode ci-dessus n'est pas utile ou si vous souhaitez obtenir plus d'informations sur le tapez, vous pouvez utiliser les fonctions TypeOf et ValueOf().Kind du package Reflect.

reflect.TypeOf()

Si vous transmettez une valeur de variable à la méthode TypeOf, le type de variable sera renvoyé. Bien sûr, des variables peuvent également être transmises, mais il est également pris en charge de transmettre des valeurs de variables directement au lieu de variables. Le code est le suivant :

fmt.Printf("%v", reflect.TypeOf(10))
//int
fmt.Printf("%v", reflect.TypeOf("Go Language"))
//string

Voici un exemple complet de différents types de variables :

package main

import (
	"fmt"
	"reflect"
)

func main() {

	var days int = 42
	var typemessage string = "go find type"
	var isFound bool = false
	var objectValue float32 = 10.2

	fmt.Printf("variable days=%v is of type %v \n", days, reflect.TypeOf(days))
	fmt.Printf("variable typemessage='%v' is of type %v \n", typemessage, reflect.TypeOf(typemessage))
	fmt.Printf("variable isFound='%v' is of type %v \n", isFound, reflect.TypeOf(isFound))
	fmt.Printf("variable objectValue=%v is of type %v \n", objectValue, reflect.TypeOf(objectValue))
}

//OUTPUT 

variable days=42 is of type int
variable typemessage='go find type' is of type string
variable isCheck='false' is of type bool
variable amount=10.2 is of type float32
variable acounts=Savings is of type string

. Reflect.ValueOf().Kind()

Vous pouvez également utiliser ValueOf().Kind() pour obtenir le type de la variable. Reflect.ValueOf() renvoie une nouvelle valeur basée sur la variable transmise, puis obtient le type de variable via la méthode Kind :

package main

import (
	"fmt"
	"reflect"
)

func main() {

	var days int = 42
	var typemessage string = "go find type"
	var isFound bool = false
	var objectValue float32 = 10.2

	fmt.Printf("variable days=%v is of type %v \n", days, reflect.ValueOf(days).Kind())
	fmt.Printf("variable typemessage='%v' is of type %v \n", typemessage, reflect.ValueOf(typemessage).Kind())
	fmt.Printf("variable isFound='%v' is of type %v \n", isFound, reflect.ValueOf(isFound).Kind())
	fmt.Printf("variable objectValue=%v is of type %v \n", objectValue, reflect.ValueOf(objectValue).Kind())
}

//OUTPUT 

variable days=42 is of type int
variable typemessage='go find type' is of type string
variable isCheck='false' is of type bool
variable objectValue=10.2 is of type float32

L'inconvénient de cette méthode est que de nouvelles variables doivent être générées, ce qui peut augmenter la mémoire. usage.

Utilisation des assertions de type

Cette section présente une autre méthode qui est l'assertion de type. Écrivez une méthode typeofObject ci-dessous pour effectuer un jugement de type :

func typeofObject(variable interface{}) string {
	switch variable.(type) {
	case int:
		return "int"
	case float32:
		return "float32"
	case bool:
		return "boolean"
	case string:
		return "string"
	default:
		return "unknown"
	}
}

fmt.Println("Using type assertions")
fmt.Println(typeofObject(count))
fmt.Println(typeofObject(message))
fmt.Println(typeofObject(isCheck))
fmt.Println(typeofObject(amount))

//OUTPUT
Using type assertions
int
string
boolean
float64

L'avantage de cette méthode est qu'elle peut regrouper les types. Par exemple, nous pouvons identifier tous les types int32, int64, uint32 et uint64 comme "int".

【Recommandations associées : Tutoriel vidéo Go, Enseignement de la programmation】

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!