Share a Go json trap record

The following is a Go json trap record from the golang tutorial column. I hope it will be helpful to friends in need!

                                                                                                                                                                                                                                                                    

JSON, a lightweight data exchange language, is based on easy-to-read text and is used to transmit data objects composed of attribute values ​​or serial values. It has been widely used. Of course, Go also provides complete support. You can easily serialize and deserialize JSON data through encoding/json. But there are some key points that require extra attention.

Go can use json.Marshal() to easily obtain JSON data. View the godoc document corresponding to this function. There is such a passage in it:

String values encode as JSON strings coerced to valid UTF-8, replacing invalid bytes with the Unicode replacement rune. So that the JSON will be safe to embed inside HTML 3f1c4e4b6b16bbbd69b2ee476dc4f83a tags, the string is encoded using HTMLEscape, which replaces "0c43feb88fe3846c3aee3dd8022b72eb", "&", U+2028, and U+2029 are escaped to "\u003c","\u003e", "\u0026", "\u2028", and "\u2029". This replacement can be disabled when using an Encoder, by calling SetEscapeHTML(false).

json.Marshal() When serializing, HTMLEscape encoding will be performed, and "6745434bf92a2979d589ede8e8e7bea9", "&", U 2028, and U 2029 will be transcoded into "\u003c"," \u003e", "\u0026", "\u2028", and "\u2029". This is not a problem in normal use, but if a third party needs to extract and compare JSON strings, if one party does not perform HTMLEscape encoding, the extracted extracts will be completely different. The solution is also given in the above document, which can be disabled by SetEscapeHTML(false). The method is as follows:

bf := bytes.NewBuffer([]byte{})jsonEncoder := json.NewEncoder(bf)jsonEncoder.SetEscapeHTML(false)_ = jsonEncoder.Encode(body)jsonStr := bf.String()

However, there are still some problems when using it this way. json.Encoder.Encode() will add a line break character after the JSON string. This function The source code is as follows:

// Encode writes the JSON encoding of v to the stream,
// followed by a newline character.
//
// See the documentation for Marshal for details about the
// conversion of Go values to JSON.
func (enc *Encoder) Encode(v interface{}) error {
    if enc.err != nil {
        return enc.err
    }
    e := newEncodeState()
    err := e.marshal(v, encOpts{escapeHTML: enc.escapeHTML})
    if err != nil {
        return err
    }

    // Terminate each value with a newline.
    // This makes the output look a little nicer
    // when debugging, and some kind of space
    // is required if the encoded value was a number,
    // so that the reader knows there aren't more
    // digits coming.
    e.WriteByte('\n')

    b := e.Bytes()
    if enc.indentPrefix != "" || enc.indentValue != "" {
        if enc.indentBuf == nil {
            enc.indentBuf = new(bytes.Buffer)
        }
        enc.indentBuf.Reset()
        err = Indent(enc.indentBuf, b, enc.indentPrefix, enc.indentValue)
        if err != nil {
            return err
        }
        b = enc.indentBuf.Bytes()
    }
    if _, err = enc.w.Write(b); err != nil {
        enc.err = err
    }
    encodeStatePool.Put(e)
    return err
}

It can be seen that the function writes another \n character after serialization. If the character is not needed, additional stripping is required:

jsonStr := string(bf.Bytes()[:bf.bf.Len()])

The above is the detailed content of Share a Go json trap record. For more information, please follow other related articles on the PHP Chinese website!