Go-模拟PHP序列化和反序列化【解决数字精度问题】

绝地灬酷狼 2022-09-09 02:17 158阅读 0赞

本代码片段根源是网上的序列化包，是保存到本地之后，进行的更改，其中引入了【decimal】包来解决反序列化数字精度问题，代码如下：

package utils
    
    import (
    	"bytes"
    	"fmt"
    	"reflect"
    	"sort"
    	"strconv"
    	"strings"
    
    	"github.com/shopspring/decimal"
    )
    
    const UNSERIALIZABLE_OBJECT_MAX_LEN = int64(10 * 1024 * 1024 * 1024)
    
    func Marshal(value interface{}) ([]byte, error) {
    
    	if value == nil {
    		return MarshalNil(), nil
    	}
    
    	t := reflect.TypeOf(value)
    	switch t.Kind() {
    	case reflect.Bool:
    		return MarshalBool(value.(bool)), nil
    	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
    		reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64,
    		reflect.Float32, reflect.Float64:
    		return MarshalNumber(value), nil
    	case reflect.String:
    		return MarshalString(value.(string)), nil
    	case reflect.Map:
    		return MarshalMap(value)
    	case reflect.Slice:
    		return MarshalSlice(value)
    	case reflect.Struct:
    		return []byte("d:" + value.(decimal.Decimal).String() + ";"), nil
    	default:
    		return nil, fmt.Errorf("Marshal: Unknown type %T with value %#v", t, value)
    	}
    }
    
    func MarshalNil() []byte {
    	return []byte("N;")
    }
    
    func MarshalBool(value bool) []byte {
    	if value {
    		return []byte("b:1;")
    	}
    
    	return []byte("b:0;")
    }
    
    func MarshalNumber(value interface{}) []byte {
    	var val string
    
    	isFloat := false
    
    	switch value.(type) {
    	default:
    		val = "0"
    	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
    		val, _ = NumericalToString(value)
    	case float32, float64:
    		val, _ = NumericalToString(value)
    		isFloat = true
    	}
    
    	if isFloat {
    		return []byte("d:" + val + ";")
    
    	} else {
    		return []byte("i:" + val + ";")
    	}
    }
    
    func MarshalString(value string) []byte {
    	return []byte(fmt.Sprintf("s:%d:\"%s\";", len(value), value))
    }
    
    func MarshalMap(value interface{}) ([]byte, error) {
    
    	s := reflect.ValueOf(value)
    
    	mapKeys := s.MapKeys()
    	sort.Slice(mapKeys, func(i, j int) bool {
    		return LessValue(mapKeys[i], mapKeys[j])
    	})
    
    	var buffer bytes.Buffer
    	for _, mapKey := range mapKeys {
    		m, err := Marshal(mapKey.Interface())
    		if err != nil {
    			return nil, err
    		}
    
    		buffer.Write(m)
    
    		m, err = Marshal(s.MapIndex(mapKey).Interface())
    		if err != nil {
    			return nil, err
    		}
    
    		buffer.Write(m)
    	}
    
    	return []byte(fmt.Sprintf("a:%d:{%s}", s.Len(), buffer.String())), nil
    }
    
    func MarshalSlice(value interface{}) ([]byte, error) {
    	s := reflect.ValueOf(value)
    
    	var buffer bytes.Buffer
    	for i := 0; i < s.Len(); i++ {
    		m, err := Marshal(i)
    		if err != nil {
    			return nil, err
    		}
    
    		buffer.Write(m)
    
    		m, err = Marshal(s.Index(i).Interface())
    		if err != nil {
    			return nil, err
    		}
    
    		buffer.Write(m)
    	}
    
    	return []byte(fmt.Sprintf("a:%d:{%s}", s.Len(), buffer.String())), nil
    }
    
    // numericalValue returns the float64 representation of a value if it is a
    // numerical type - integer, unsigned integer or float. If the value is not a
    // numerical type then the second argument is false and the value returned
    // should be disregarded.
    func NumericalValue(value reflect.Value) (float64, bool) {
    	switch value.Type().Kind() {
    	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
    		return float64(value.Int()), true
    
    	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
    		return float64(value.Uint()), true
    
    	case reflect.Float32, reflect.Float64:
    		return value.Float(), true
    
    	default:
    		return 0, false
    	}
    }
    
    // lessValue compares two reflect.Value instances and returns true if a is
    // considered to be less than b.
    //
    // This function is used to sort keys for what amounts to associate arrays and
    // objects in PHP. These are represented as slices and maps in Go. Since Go
    // randomised map iterators we need to make sure we always return the keys of an
    // associative array or object in a predicable order.
    //
    // The keys can be numerical, strings or a combination of both. We treat numbers
    // (integers, unsigned integers and floats) as always less than strings. Numbers
    // are ordered by magnitude (ignoring types) and strings are orders
    // lexicographically.
    //
    // If keys are of any other type the behavior of the comparison is undefined. If
    // there is a legitimate reason why keys could be other types then this function
    // should be updated accordingly.
    func LessValue(a, b reflect.Value) bool {
    	aValue, aNumerical := NumericalValue(a)
    	bValue, bNumerical := NumericalValue(b)
    
    	if aNumerical && bNumerical {
    		return aValue < bValue
    	}
    
    	if !aNumerical && !bNumerical {
    		// In theory this should mean they are both strings. In reality
    		// they could be any other type and the String() representation
    		// will be something like "<bool>" if it is not a string. Since
    		// distinct values of non-strings still return the same value
    		// here that's what makes the ordering undefined.
    		return strings.Compare(a.String(), b.String()) < 0
    	}
    
    	// Numerical values are always treated as less than other types
    	// (including strings that might represent numbers themselves). The
    	// inverse is also true.
    	return aNumerical && !bNumerical
    }
    
    func LowerCaseFirstLetter(s string) string {
    	return strings.ToLower(s[0:1]) + s[1:]
    }
    
    func NumericalToString(value interface{}) (string, bool) {
    	var val string
    
    	switch value.(type) {
    	default:
    		return "0", false
    	case int:
    		intVal, _ := value.(int)
    		val = strconv.FormatInt(int64(intVal), 10)
    	case int8:
    		intVal, _ := value.(int8)
    		val = strconv.FormatInt(int64(intVal), 10)
    	case int16:
    		intVal, _ := value.(int16)
    		val = strconv.FormatInt(int64(intVal), 10)
    	case int32:
    		intVal, _ := value.(int32)
    		val = strconv.FormatInt(int64(intVal), 10)
    	case int64:
    		intVal, _ := value.(int64)
    		val = strconv.FormatInt(int64(intVal), 10)
    	case uint:
    		intVal, _ := value.(uint)
    		val = strconv.FormatUint(uint64(intVal), 10)
    	case uint8:
    		intVal, _ := value.(uint8)
    		val = strconv.FormatUint(uint64(intVal), 10)
    	case uint16:
    		intVal, _ := value.(uint16)
    		val = strconv.FormatUint(uint64(intVal), 10)
    	case uint32:
    		intVal, _ := value.(uint32)
    		val = strconv.FormatUint(uint64(intVal), 10)
    	case uint64:
    		intVal, _ := value.(uint64)
    		val = strconv.FormatUint(uint64(intVal), 10)
    	case float32:
    		floatVal, _ := value.(float32)
    		val = strconv.FormatFloat(float64(floatVal), 'f', -1, 32)
    	case float64:
    		floatVal, _ := value.(float64)
    		val = strconv.FormatFloat(float64(floatVal), 'f', -1, 64)
    	}
    	return val, true
    }
    
    func UnMarshal(data []byte) (interface{}, error) {
    	reader := bytes.NewReader(data)
    	return unMarshalByReader(reader)
    }
    
    func unMarshalByReader(reader *bytes.Reader) (interface{}, error) {
    
    	for {
    
    		if token, _, err := reader.ReadRune(); err == nil {
    			switch token {
    			default:
    				return nil, fmt.Errorf("UnMarshal: Unknown token %#U", token)
    			case 'N':
    				return unMarshalNil(reader)
    			case 'b':
    				return unMarshalBool(reader)
    			case 'i':
    				return unMarshalNumber(reader, false)
    			case 'd':
    				return unMarshalNumber(reader, true)
    			case 's':
    				return unMarshalString(reader, true)
    			case 'a':
    				return unMarshalArray(reader)
    				// case 'O':
    
    				// case 'C':
    
    				// case 'R', 'r':
    
    				// case 'x':
    
    			}
    		}
    		return nil, nil
    	}
    
    }
    
    func unMarshalNil(reader *bytes.Reader) (interface{}, error) {
    	expect(reader, ';')
    
    	return nil, nil
    }
    
    func unMarshalBool(reader *bytes.Reader) (interface{}, error) {
    	var (
    		raw rune
    		err error
    	)
    	err = expect(reader, ':')
    	if err != nil {
    		return nil, err
    	}
    
    	if raw, _, err = reader.ReadRune(); err != nil {
    		return nil, fmt.Errorf("UnMarshal: Error while reading bool value: %v", err)
    	}
    
    	err = expect(reader, ';')
    	if err != nil {
    		return nil, err
    	}
    	return raw == '1', nil
    }
    
    func unMarshalNumber(reader *bytes.Reader, isFloat bool) (interface{}, error) {
    	var (
    		raw string
    		err error
    		val interface{}
    	)
    	err = expect(reader, ':')
    	if err != nil {
    		return nil, err
    	}
    
    	if raw, err = readUntil(reader, ';'); err != nil {
    		return nil, fmt.Errorf("UnMarshal: Error while reading number value: %v", err)
    	} else {
    		if isFloat {
    			if s, err := decimal.NewFromString(raw); err != nil {
    				return nil, fmt.Errorf("UnMarshal: Unable to convert %s to float: %v", raw, err)
    			} else {
    				val = s.Round(100)
    			}
    		} else {
    			if val, err = strconv.Atoi(raw); err != nil {
    				return nil, fmt.Errorf("UnMarshal: Unable to convert %s to int: %v", raw, err)
    			}
    		}
    	}
    
    	return val, nil
    }
    
    func unMarshalString(reader *bytes.Reader, isFinal bool) (string, error) {
    	var (
    		err     error
    		val     string
    		strLen  int
    		readLen int
    	)
    
    	strLen, err = readLength(reader)
    
    	err = expect(reader, '"')
    	if err != nil {
    		return val, err
    	}
    
    	if strLen > 0 {
    		buf := make([]byte, strLen, strLen)
    		if readLen, err = reader.Read(buf); err != nil {
    			return val, fmt.Errorf("UnMarshal: Error while reading string value: %v", err)
    		} else {
    			if readLen != strLen {
    				return val, fmt.Errorf("UnMarshal: Unable to read string. Expected %d but have got %d bytes", strLen, readLen)
    			} else {
    				val = string(buf)
    			}
    		}
    	}
    
    	err = expect(reader, '"')
    	if err != nil {
    		return val, err
    	}
    	if isFinal {
    		err = expect(reader, ';')
    		if err != nil {
    			return val, err
    		}
    	}
    	return val, nil
    }
    
    func unMarshalArray(reader *bytes.Reader) (interface{}, error) {
    	var arrLen int
    	var err error
    	val := make(map[string]interface{})
    
    	arrLen, err = readLength(reader)
    
    	if err != nil {
    		return nil, err
    	}
    	err = expect(reader, '{')
    	if err != nil {
    		return nil, err
    	}
    	indexLen := 0
    	for i := 0; i < arrLen; i++ {
    		k, err := unMarshalByReader(reader)
    		if err != nil {
    			return nil, err
    		}
    		v, err := unMarshalByReader(reader)
    		if err != nil {
    			return nil, err
    		}
    
    		// if errKey == nil && errVal == nil {
    		// val[k] = v
    		switch t := k.(type) {
    		default:
    			return nil, fmt.Errorf("UnMarshal: Unexpected key type %T", t)
    		case string:
    			stringKey, _ := k.(string)
    			val[stringKey] = v
    		case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64:
    			// intKey, _ := k.(int)
    			// val[strconv.Itoa(intKey)] = v
    			stringKey, _ := NumericalToString(k)
    			val[stringKey] = v
    
    			if i == k {
    				indexLen++
    			}
    
    		}
    		// } else {
    		// 	return nil, fmt.Errorf("UnMarshal: Error while reading key or(and) value of array")
    		// }
    	}
    
    	err = expect(reader, '}')
    	if err != nil {
    		return nil, err
    	}
    
    	if indexLen == arrLen {
    		var slice []interface{}
    		for _, row := range val {
    			slice = append(slice, row)
    		}
    		return slice, nil
    	}
    
    	return val, nil
    }
    
    func expect(reader *bytes.Reader, expected rune) error {
    	if token, _, err := reader.ReadRune(); err != nil {
    		return fmt.Errorf("UnMarshal: Error while reading expected rune %#U: %v", expected, err)
    	} else if token != expected {
    		return fmt.Errorf("UnMarshal: Expected %#U but have got %#U", expected, token)
    	}
    	return nil
    }
    
    func readUntil(reader *bytes.Reader, stop rune) (string, error) {
    	var (
    		token rune
    		err   error
    	)
    	buf := bytes.NewBuffer([]byte{})
    
    	for {
    		if token, _, err = reader.ReadRune(); err != nil || token == stop {
    			break
    		} else {
    			buf.WriteRune(token)
    		}
    	}
    
    	return buf.String(), err
    }
    
    func readLength(reader *bytes.Reader) (int, error) {
    	var (
    		raw string
    		err error
    		val int
    	)
    	err = expect(reader, ':')
    	if err != nil {
    		return 0, err
    	}
    
    	if raw, err = readUntil(reader, ':'); err != nil {
    		return 0, fmt.Errorf("UnMarshal: Error while reading lenght of value: %v", err)
    	} else {
    		if val, err = strconv.Atoi(raw); err != nil {
    			return 0, fmt.Errorf("UnMarshal: Unable to convert %s to int: %v", raw, err)
    		} else if int64(val) > UNSERIALIZABLE_OBJECT_MAX_LEN {
    			return 0, fmt.Errorf("UnMarshal: Unserializable object length looks too big(%d). If you are sure you wanna unserialise it, please increase UNSERIALIZABLE_OBJECT_MAX_LEN const", val)
    			val = 0
    		}
    	}
    	return val, nil
    }

工程目录结构如下：

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAbHV5YXJhbg_size_20_color_FFFFFF_t_70_g_se_x_16][]

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAbHV5YXJhbg_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/df491511ee9e447884e8ea14e0fd088d.png