GoLang 简单易用的 json value 读取工具！还并发安全

"{\"simpleArray\":[1,2,3],\"labels\":\"{\\\"level_1\\\":{\\\"tag_id\\\":\\\"example-1\\\",\\\"tag_name\\\":\\\"school\\\",\\\"prob\\\":1,\\\"level\\\":1},\\\"level_2\\\":{\\\"tag_id\\\":\\\"example-2\\\",\\\"tag_name\\\":\\\"class\\\",\\\"prob\\\":1,\\\"level\\\":2}}\"}"

const (	simple = "{\"simpleArray\":[1,2,3],\"labels\":\"{\\\"level_1\\\":{\\\"tag_id\\\":\\\"example-1\\\",\\\"tag_name\\\":\\\"school\\\",\\\"prob\\\":1,\\\"level\\\":1},\\\"level_2\\\":{\\\"tag_id\\\":\\\"example-2\\\",\\\"tag_name\\\":\\\"class\\\",\\\"prob\\\":1,\\\"level\\\":2}}\"}")
func TestMap(t *testing.T) {	m := make(map[string]interface{})	json.Unmarshal([]byte(simple), &m)	m2 := make(map[string]interface{})	json.Unmarshal([]byte(m["labels"].(string)), &m2)	level1 := m2["level_1"].(map[string]interface{})	tag1 := level1["tag_name"]	level2 := m2["level_2"].(map[string]interface{})	tag2 := level2["tag_name"]}

package main
import (	"fmt"	"github.com/krystalics/jpath")
const (	simple = "{\"simpleArray\":[1,2,3],\"labels\":\"{\\\"level_1\\\":{\\\"tag_id\\\":\\\"example-1\\\",\\\"tag_name\\\":\\\"school\\\",\\\"prob\\\":1,\\\"level\\\":1},\\\"level_2\\\":{\\\"tag_id\\\":\\\"example-2\\\",\\\"tag_name\\\":\\\"class\\\",\\\"prob\\\":1,\\\"level\\\":2}}\"}")
func main() {	jPath, _ := jpath.New(simple)	tag1 := jPath.FindString("labels.level_1.tag_name")	tag2 := jPath.FindString("labels.level_2.tag_name")
	fmt.Println(tag1, tag2)}

safe, _ := jpath.NewConcurrencySafe(simple)for i := 0; i < 100; i++ {  go func() {    tag1 = safe.FindString("labels.level_1.tag_name")    tag2 = safe.FindString("labels.level_2.tag_name")  }()}

val := jPath.FindInt("simpleArray[1]")

const (	ARRAY_TYPE_PREFIX = "["	ARRAY_TYPE_SUFFIX = "]"	DEFAULT_SEPARATOR = ".")
var (	ARRAY_REGEX, _ = regexp.Compile(`\[-?\d+\]`))
type JPath struct {	data      map[string]interface{}	Separator string //路径分隔符默认是.}

func (jp *JPath) Find(path string) (interface{}, error) {	keys := strings.Split(path, jp.Separator)	index := len(keys) - 1 //路径的尽头
	m := jp.data	for i, v := range keys {		if m == nil {			return nil, errors.New(fmt.Sprintf("path %+v not found ", path))		}		//数组判断		if !strings.HasSuffix(v, ARRAY_TYPE_SUFFIX) {			data := m[v]      //到达了要寻找的路径末尾			if i == index {				if data == nil {					return nil, errors.New(fmt.Sprintf("path %+v not found ", path))				}				return data, nil			}      //path中这个节点并不是数组也不是路径的结尾、只需要处理字符串和map的情况			switch data.(type) {			case map[string]interface{}:				m = data.(map[string]interface{})			case string:				m_sub, _ := strToMap(m[v].(string), false)				m[v] = m_sub				m = m_sub			case []interface{}:				return nil, errors.New(fmt.Sprintf("key %+v error,array should be like this [index]", path))
			default:				return nil, errors.New(fmt.Sprintf("key %+v error,it is not string or map", v))			}		} else {			//匹配出[index]			flag := ARRAY_REGEX.FindString(v) 			value, err := strconv.Atoi(flag[1 : len(flag)-1])			if err != nil {				return nil, errors.New(fmt.Sprintf("illegal index args %+v", flag))			}			key := strings.Split(v, flag)[0] //获取数组路径的前缀、例如simple[1]中的simple			data := m[key]      //这段路径被用户作为数组传入、只需要处理数组的情况			switch data.(type) {			case []interface{}:				arr := data.([]interface{})				if value > len(arr)-1 {					return nil, errors.New(fmt.Sprintf("key %+v error,it is larger than array last index %+v", v, len(arr)-1))				}				tmp := arr[value]				if i == index {					if tmp == nil {						return nil, errors.New(fmt.Sprintf("path %+v not found ", path))					}					return tmp, nil				}        //对数组中取出的值、要进行再次判断、因为它并不是路径的最后、需要再生成一个map以便于获取下一层value				switch tmp.(type) {				case map[string]interface{}:					m = tmp.(map[string]interface{})				case string:					m_sub, _ := strToMap(tmp.(string), false)					m[v] = m_sub					m = m_sub				default:					return nil, errors.New(fmt.Sprintf("key %+v error,it is not string or map", v))				}				//在并发场景下、会需要将map完全递归生成。会有这种类型、统一处理了			case []map[string]interface{}:
				arr := data.([]map[string]interface{})				if value > len(arr)-1 {					return nil, errors.New(fmt.Sprintf("key %+v error,it is larger than array last index %+v", v, len(arr)-1))				}				tmp := arr[value]				if i == index {					if tmp == nil {						return nil, errors.New(fmt.Sprintf("path %+v not found ", path))					}					return tmp, nil				}
				m = tmp
			default:				return nil, errors.New(fmt.Sprintf("key %+v error,it is not a array", v))
			}		}	}
	return nil, errors.New(fmt.Sprintf("path %+v not found ", path))}

func NewConcurrencySafe(source string) (*JPath, error) {	jPath, err := New(source)	if err != nil {		return nil, err	}	deepRecursion(jPath.data)	return jPath, nil}
//递归构造func deepRecursion(m map[string]interface{}) {	for k, v := range m {		switch v.(type) {		case map[string]interface{}:			deepRecursion(v.(map[string]interface{}))		case string:			m_sub, err := strToMap(v.(string), true)			if err == nil {				m[k] = m_sub				deepRecursion(m_sub)			} else {				m[k] = v			}		case []interface{}:			arr := make([]map[string]interface{}, 0)			ori := make([]interface{}, 0)			for _, val := range v.([]interface{}) {				switch val.(type) {				case map[string]interface{}:					arr = append(arr, val.(map[string]interface{}))				case string:					m_sub, err := strToMap(val.(string), true)					if err != nil {						ori = append(ori, val.(string))					} else {						arr = append(arr, m_sub)					}				default:					ori = append(ori, val)				}			}			if len(arr) > 0 {				m[k] = arr				for _, v := range arr {					deepRecursion(v)				}			} else {				m[k] = ori			}		default:
		}	}}