golang 如何解析php serialize 序列化的数据

Question

1.我需要在golang中解析php 序列化生成的字符串
初步想法是将其解析成json字符串，然后再获取具体的值，
用了一个php_serialize包来解析，但是在解析之后得到了一个interface{}类型的结果
我不知道该如何解析这个interface{}

2.示例代码：

package main

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

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 {
        fmt.Println(result)
    }
}

打印结果：

map[name:tom age:23 friends:map[0:map[name:jerry] 1:map[name:jack]]]

3.这个result是一个 php_serialize.PhpValue 的类型，查看源码后发现这个PhpValue 是一个interface{}类型。

现在我想拿到result内部的详细数据，比如name，age，friends什么的，不知道该怎么做了，求教

Answer 1

一般interface{}都要类型确定，然后根据实际情况进行处理

/*
   Created by jinhan on 17-8-16.
   Tip:  一般interface{}都要类型确定，然后根据实际情况进行处理
   Update:
*/
package main

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

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 {
        // 观察可以看出interface的类型是：
        //php_serialize.PhpArray{"name":"tom", "age":"23", "friends":php_serialize.PhpArray{0:php_serialize.PhpArray{"name":"jerry"}, 1:php_serialize.PhpArray{"name":"jack"}}}
        fmt.Printf("%T | %#v\n\n\n", result, result)

        // 因为result是interface{},所以我们要确定它的类型，从上面打印的我们知道是php_serialize.PhpArray
        realtype_result, ok := result.(php_serialize.PhpArray)
        if ok {
            // 确定类型后我们可以打印出map里的内容，如下：
            /*
                type PhpArray map[PhpValue]PhpValue
                type PhpValue interface{}
            */
            fmt.Printf("realtype_result：%T | %#v\n", realtype_result, realtype_result)
            fmt.Printf("realtype_result['name']：%T | %#v\n", realtype_result["name"], realtype_result["name"])
            fmt.Printf("realtype_result['age']：%T | %#v\n", realtype_result["age"], realtype_result["age"])

            // 我们看出friends得出的结果是PhpValue，也就是interface{}，并且真实类型是php_serialize.PhpArray
            fmt.Printf("realtype_result['friends']：%T | %#v\n\n\n", realtype_result["friends"], realtype_result["friends"])

            realtype_friends_result, ok := realtype_result["friends"].(php_serialize.PhpArray)
            if ok {
                // 你可以遍历看看
                for k, v := range realtype_friends_result {
                    fmt.Printf("%T | %#v\n", k, k)
                    fmt.Printf("%T | %#v\n", v, v)

                    // 这里v也是一样了
                    vv, ok := v.(php_serialize.PhpArray)
                    if ok {
                        fmt.Printf("%T | %#v\n", vv["name"], vv["name"])
                    }
                }
            }

        } else {
            fmt.Println("类型错误，不是php_serialize.PhpArray")
        }

    }
}

输出是这样的：

php_serialize.PhpArray | php_serialize.PhpArray{"friends":php_serialize.PhpArray{0:php_serialize.PhpArray{"name":"jerry"}, 1:php_serialize.PhpArray{"name":"jack"}}, "name":"tom", "age":"23"}


realtype_result：php_serialize.PhpArray | php_serialize.PhpArray{"age":"23", "friends":php_serialize.PhpArray{0:php_serialize.PhpArray{"name":"jerry"}, 1:php_serialize.PhpArray{"name":"jack"}}, "name":"tom"}
realtype_result['name']：string | "tom"
realtype_result['age']：string | "23"
realtype_result['friends']：php_serialize.PhpArray | php_serialize.PhpArray{0:php_serialize.PhpArray{"name":"jerry"}, 1:php_serialize.PhpArray{"name":"jack"}}


int | 0
php_serialize.PhpArray | php_serialize.PhpArray{"name":"jerry"}
string | "jerry"
int | 1
php_serialize.PhpArray | php_serialize.PhpArray{"name":"jack"}
string | "jack"

Answer 2

golang不了解, 但不同语言之间交互, 不要用语言专用的数组结果吧.

用xml, json, 都是php serialize好.

我猜解出来的应该是一个map结果

Answer 3

根据json格式定义一个struct，例如 type Person struct{}， 然后进行类型断言：

    if persons, ok := result.([]Person); ok {
        for _, p := range persons {
            fmt.Println(p)
        }
    }

Answer 4

一般在确定不了类型的时候，都会用interface{}类型。

使用的时候就需要类型断言, 比如string就是 str, err := some.(string)。

因为使用者是知道具体字段类型的，所以你在使用的地方，需要自行类型断言到具体的类型进行相关的操作。

你用的这个包，还有一些辅助方法,
看这里 common_helper.go ，根本也就是类型断言，不过能让你用的舒服那么一点点，?