Erfahren Sie mehr über Behauptungen vom Typ Golang

Das Folgende ist eine Einführung in Golang-Typ-Behauptungen aus der golang-Tutorial-Kolumne. Ich hoffe, dass es für Freunde in Not hilfreich sein wird!

Es gibt eine Serialize()-Funktion in PHP, die das Array zur Speicherung und Übertragung in einen String serialisieren kann.

Wenn Sie diese Art von String deserialisieren möchten, benötigen Sie nur eine einfache unserialize()-Funktion in PHP, um es zu vervollständigen. Aber in Golang ist das nicht so einfach. Man muss sich viel Mühe geben und viel Code schreiben.

Zu diesem Zeitpunkt möchte ich nur seufzen, PHP ist wirklich die beste Sprache der Welt!

Ich bin in der heutigen Entwicklung auf ein solches Problem gestoßen. Ich muss Golang verwenden, um PHP-serialisierte Zeichenfolgen zu analysieren, aber ich habe festgestellt, dass das Ergebnis nach dem Parsen ein Schnittstellentyp ist.

Plötzlich wusste ich nicht, wo ich anfangen sollte, aber nach dem Parsen bekam ich eine Schnittstelle.

Ich hatte das Gefühl, dass ich Typ verwenden musste Behauptungen, aber ich wusste nicht, wie man es benutzt, also habe ich beschlossen, es zu verwenden. Gehen Sie zur Community und fragen Sie, ich hoffe, die Großen können Ihnen eine Antwort geben.

Es funktioniert tatsächlich wirklich gut.

Veröffentlichen Sie den folgenden Code:

package main

import (
	"github.com/yvasiyarov/php_session_decoder/php_serialize"
	"fmt"
	"log"
)


func main() {
        // 序列化后的字符串
	str := `a:3:{s:4:"name";s:3:"tom";s:3:"age";s:2:"23";s:7:"friends";a:2:{i:0;a:1:{s:4:"name";s:5:"jerry";}i:1;a:1:{s:4:"name";s:4:"jack";}}}`
	
        // 反序列化
        decoder := php_serialize.NewUnSerializer(str)
	if result, err := decoder.Decode(); err != nil {
		panic(err)
	} else {
                // 此处进行类型断言
		decodeData, ok := result.(php_serialize.PhpArray)
		if !ok {
			log.Println(err)
		}

                // 断言后，即可获取内容
		name := decodeData["name"]
		age := decodeData["age"]
		fmt.Println(name, age)

                // 内层数据仍需再次断言
		friends, ok := decodeData["friends"].(php_serialize.PhpArray)
		if !ok {
			log.Println(err)
		}

                // 断言成功后即可获取内部数据
		for _,v := range friends {
			fmt.Printf("type:%T, value:%+v\n", v,v )
			friend, ok := v.(php_serialize.PhpArray)
			if !ok {
				log.Println(err)
			}
			friendName := friend["name"]
			fmt.Println(friendName)
		}
	}
}

Es kann ungefähr so ​​verstanden werden: Welcher Typ auch immer eine Variable ist, machen Sie eine Behauptung dieses Typs. Nach der Behauptung können Sie das Ergebnis erhalten

So bestimmen Sie den Typ einer Variablen ?

Drucken Sie es aus: fmt.Printf("%T", verb)

%T Dieser Platzhalter kann den Typ der Variablen anzeigen

Es gibt unten ein weiteres Beispiel:

package main

import (
	"github.com/yvasiyarov/php_session_decoder/php_serialize"
	"fmt"
	"log"
)

func main() {
	// 序列化后的字符串
	str := `a:3:{s:4:"name";s:3:"tom";s:3:"age";s:2:"23";s:7:"friends";a:2:{i:0;a:1:{s:4:"name";s:5:"jerry";}i:1;a:1:{s:4:"name";s:4:"jack";}}}`
	
	// 反序列化
	decoder := php_serialize.NewUnSerializer(str)
	result, err := decoder.Decode()
	if err != nil {
		panic(err)
	}
	// 类型断言
	t := result.(php_serialize.PhpArray)
	strVal := php_serialize.PhpValueString(t["name"])
	fmt.Println(strVal)
	
	switch t := result.(type) {
	default:
		fmt.Printf("unexpected type %T\n", t)
	case php_serialize.PhpArray:
		fmt.Println(t)
		fmt.Println(t["name"])
		fmt.Println(t["age"])

		switch f := t["friends"].(type) {
		default:
			fmt.Printf("unexpected type %T\n", t)
		case php_serialize.PhpArray:
			fmt.Println(f)
			fmt.Println(f[0])
			fmt.Println(f[1])
		}
	}
}

Die beiden oben genannten Demos können den Effekt erzielen. Nur die Schreibweise ist anders.

Später wurde mir ein anderes Paket vorgestellt, das auch den folgenden Effekt erzielen kann:

package main

import (
	"fmt"
	"log"
	"github.com/wulijun/go-php-serialize/phpserialize"
)

func main() {
	str := `a:3:{s:4:"name";s:3:"tom";s:3:"age";s:2:"23";s:7:"friends";a:2:{i:0;a:1:{s:4:"name";s:5:"jerry";}i:1;a:1:{s:4:"name";s:4:"jack";}}}`
	decodedRes, err := phpserialize.Decode(str)
	if err != nil {
		panic(err)
	}
	//fmt.Printf("%T\n", decodedRes) //type is map[interface{}]interface{}

	//type assert
	decodedData, ok := decodedRes.(map[interface{}]interface{})
	if !ok {
		fmt.Printf("unexpected type %T\n", decodedRes)
	}
	fmt.Println(decodedData["name"])
	fmt.Println(decodedData["age"])

	//fmt.Printf("%T\n", decodedData["friends"]) // type is map[interface{}]interface{}
	// type assert
	friendsRes, ok := decodedData["friends"].(map[interface{}]interface{})
	if !ok {
		fmt.Printf("unexpected type %T\n", decodedData["friends"])
	}
	for _,v := range friendsRes {
		//fmt.Printf("type: %T, val: %#v\n", v,v) // type is map[interface{}]interface{}
		friend, ok := v.(map[interface{}]interface{})
		if !ok {
			fmt.Printf("unexpected type %T\n", decodedData["friends"])
		}
		//fmt.Printf("type: %T, val: %#v\n", friend,friend) // type is map[interface{}]interface{}
		fmt.Println(friend["name"])
	}
}

Die Typen aller von diesem Paket analysierten Ergebnisse sind Map[Interface{}]Interface{}, also bei der Ausführung von Typzusicherungen Es kann sein einfacher und gröber.

Das obige ist der detaillierte Inhalt vonErfahren Sie mehr über Behauptungen vom Typ Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!