So erkennen Sie, ob eine Variable in Golang eine Zeichenfolge ist

Methode zum Erkennen, ob eine Variable eine Zeichenfolge ist: 1. Verwenden Sie die Formatierungskennung „%T“, Syntax „fmt.Printf(“variable count=%v ist vom Typ %T n“, count, count)“; Verwenden Sie „reflect.TypeOf()“, die Syntax lautet „reflect.TypeOf(variable)“. 3. Verwenden Sie „reflect.ValueOf().Kind()“ zur Erkennung. 4. Verwenden Sie Typzusicherungen, um Typen zu gruppieren.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, GO Version 1.18, Dell G3-Computer.

Golang erkennt, ob eine Variable eine Zeichenfolge ist, indem es den Typ der Variablen überprüft. Hier sind mehrere Methoden.

Go bietet mehrere Methoden zum Überprüfen des Variablentyps, einschließlich der Zeichenfolgenformatierungskennung %T, Reflexionsmethoden: Reflect.TypeOf, Reflect.ValueOf.Kind sowie die Verwendung von Typzusicherungen und Methoden zum Wechseln der Groß-/Kleinschreibung. Diese vier Arten von Methoden werden im Folgenden anhand von Beispielen vorgestellt.

%T-Formatierungskennung

Die Verwendung der %T-Zeichenfolgenformatierungskennung ist die einfachste Möglichkeit, den Typ zu überprüfen. %T ist das FMT-Paket. Sie können fmt.Printf verwenden, um den Variablentyp anzuzeigen:

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

Verwenden Sie die Reflect-Paketfunktion

Wenn die obige Methode nicht nützlich ist oder Sie weitere Informationen darüber erhalten möchten Typ können Sie die Funktionen TypeOf und ValueOf().Kind des Reflect-Pakets verwenden.

reflect.TypeOf()

Wenn Sie einen Variablenwert an die TypeOf-Methode übergeben, wird der Variablentyp zurückgegeben. Natürlich können auch Variablen übergeben werden, es wird jedoch auch unterstützt, Variablenwerte direkt anstelle von Variablen zu übergeben. Der Code lautet wie folgt:

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

Hier ist ein vollständiges Beispiel für verschiedene Variablentypen:

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

reflektieren.ValueOf().Kind()

Sie können auch ValueOf().Kind() verwenden, um den Typ der Variablen abzurufen. Reflect.ValueOf() gibt einen neuen Wert basierend auf der übergebenen Variablen zurück und ruft dann den Variablentyp weiter über die Kind-Methode ab:

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

Der Nachteil dieser Methode besteht darin, dass neue Variablen generiert werden müssen, was den Speicher erhöhen kann Verwendung.

Typzusicherungen verwenden

In diesem Abschnitt wird eine weitere Methode vorgestellt, nämlich Typzusicherungen. Schreiben Sie unten eine Methode typeofObject, um eine Typbeurteilung durchzuführen:

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

Der Vorteil dieser Methode besteht darin, dass sie Typen gruppieren kann. Beispielsweise können wir alle Typen int32, int64, uint32 und uint64 als „int“ identifizieren.

【Verwandte Empfehlungen: Go-Video-Tutorial, Programmierunterricht】

Das obige ist der detaillierte Inhalt vonSo erkennen Sie, ob eine Variable in Golang eine Zeichenfolge ist. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!