Bagaimana untuk mengesan sama ada pembolehubah adalah rentetan dalam golang

Kaedah untuk mengesan sama ada pembolehubah ialah rentetan: 1. Gunakan pengecam pemformatan "%T", sintaks "fmt.Printf("variable count=%v is of type %T n", count, count) "; 2. Gunakan reflect.TypeOf(), sintaks "reflect.TypeOf(variable)"; 3. Gunakan reflect.ValueOf().Kind() untuk pengesanan; 4. Gunakan penegasan jenis untuk kumpulan jenis.

Persekitaran pengendalian tutorial ini: sistem Windows 7, GO versi 1.18, komputer Dell G3.

Golang mengesan sama ada pembolehubah ialah rentetan dengan menyemak jenis pembolehubah Berikut adalah beberapa kaedah.

Go menyediakan beberapa kaedah untuk menyemak jenis pembolehubah, termasuk pengecam pemformatan rentetan %T, kaedah refleksi: reflect.TypeOf, reflect.ValueOf.Kind, dan penggunaan penegasan jenis dan kaedah suis case. Empat jenis kaedah ini diperkenalkan di bawah melalui contoh.

Bendera pemformatan%T

Menggunakan bendera pemformatan rentetan %T ialah cara paling mudah untuk menyemak jenis. %T ialah pakej fmt Anda boleh menggunakan fmt.Printf untuk memaparkan jenis pembolehubah:

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

Gunakan fungsi pakej reflect

Jika kaedah di atas tidak berfungsi Jika anda ingin mendapatkan maklumat lanjut tentang jenis, anda boleh menggunakan TypeOf dan ValueOf().Fungsi jenis pakej reflect.

reflect.TypeOf()

Jika anda menghantar nilai pembolehubah kepada kaedah TypeOf, jenis pembolehubah akan dikembalikan. Sudah tentu, pembolehubah juga boleh diluluskan, tetapi ia juga disokong untuk menghantar nilai pembolehubah secara langsung dan bukannya pembolehubah Kodnya adalah seperti berikut:

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

Berikut ialah contoh lengkap jenis pembolehubah yang berbeza. :

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()

Anda juga boleh menggunakan ValueOf().Kind() untuk mendapatkan jenis pembolehubah. reflect.ValueOf() mengembalikan nilai baharu berdasarkan pembolehubah yang diluluskan, dan kemudian memperoleh lagi jenis pembolehubah melalui kaedah Jenis:

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

Kelemahan kaedah ini ialah pembolehubah baharu perlu dihasilkan, yang boleh meningkatkan memori yang diduduki.

Menggunakan penegasan jenis

Bahagian ini memperkenalkan kaedah lain ialah penegasan jenis. Tulis kaedah typeofObject di bawah untuk melakukan pertimbangan jenis:

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

Kelebihan kaedah ini ialah ia boleh mengumpulkan jenis Contohnya, kita boleh mengenal pasti semua jenis int32, int64, uint32 dan uint64 sebagai "int. ".

[Cadangan berkaitan: Pergi tutorial video, Pengajaran pengaturcaraan]

Atas ialah kandungan terperinci Bagaimana untuk mengesan sama ada pembolehubah adalah rentetan dalam golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!