Golang parses JSON and its solution

type Person struct {
	Name string
	Age  int
}

func main() {
	var p *Person
	bytes, err := (p)
	checkError(err)
	("len:%d, result:%s\n", len(bytes), string(bytes))  // len:4, result:null
}

func checkError(err error) {
	if err != nil {
		("err:%+v\n", err)
	}
}

type Person struct {
	Name string
	Age  int
}

func main() {
	var p *Person
	s := `null`
	err := ([]byte(s), &p)
	checkError(err)
	("p:%+v\n", p) // p:<nil>
}

func checkValid(data []byte, scan *scanner) error {
	()
	for _, c := range data {
		++
		if (scan, c) == scanError {
			return 
		}
	}
	if () == scanError {
		return 
	}
	return nil
}

// stateBeginValue is the state at the beginning of the input.
func stateBeginValue(s *scanner, c byte) int {
	if isSpace(c) {
		return scanSkipSpace
	}
	switch c {
	case '{':
		 = stateBeginStringOrEmpty
		return (c, parseObjectKey, scanBeginObject)
	case '[':
		 = stateBeginValueOrEmpty
		return (c, parseArrayValue, scanBeginArray)
	case '"':
		 = stateInString
		return scanBeginLiteral
	case '-':
		 = stateNeg
		return scanBeginLiteral
	case '0': // beginning of 0.123
		 = state0
		return scanBeginLiteral
	case 't': // beginning of true
		 = stateT
		return scanBeginLiteral
	case 'f': // beginning of false
		 = stateF
		return scanBeginLiteral
	case 'n': // beginning of null
		 = stateN
		return scanBeginLiteral
	}
	if '1' <= c && c <= '9' { // beginning of 1234.5
		 = state1
		return scanBeginLiteral
	}
	return (c, "looking for beginning of value")
}

// stateN is the state after reading `n`.
func stateN(s *scanner, c byte) int {
	if c == 'u' {
		 = stateNu
		return scanContinue
	}
	return (c, "in literal null (expecting 'u')")
}

// stateNu is the state after reading `nu`.
func stateNu(s *scanner, c byte) int {
	if c == 'l' {
		 = stateNul
		return scanContinue
	}
	return (c, "in literal null (expecting 'l')")
}

// stateNul is the state after reading `nul`.
func stateNul(s *scanner, c byte) int {
	if c == 'l' {
		 = stateEndValue
		return scanContinue
	}
	return (c, "in literal null (expecting 'l')")
}

type ptrEncoder struct {
	elemEnc encoderFunc
}

func (pe ptrEncoder) encode(e *encodeState, v , opts encOpts) {
	if () {
		("null")
		return
	}
	if ++;  > startDetectingCyclesAfter {
		// We're a large number of nested  calls deep;
		// start checking if we've run into a pointer cycle.
		ptr := ()
		if _, ok := [ptr]; ok {
			(&UnsupportedValueError{v, ("encountered a cycle via %s", ())})
		}
		[ptr] = struct{}{}
		defer delete(, ptr)
	}
	(e, (), opts)
	--
}

type Person struct {
	Name string
	Age  int
}

func main() {
	p := &Person{
		Name: "text",
		Age:  18,
	}

	bytes, err := (p)
	checkError(err)

	pMap := make(map[string]interface{})
	err = (bytes, &pMap)
	checkError(err)
	for k, v := range pMap {
		("k:%s,v:%+v, vtype:%v\n", k, v, (v))
	}
}

func checkError(err error) {
	if err != nil {
		("err:%+v\n", err)
	}
}