xml之如何从XML字符串中删除XML意向

我有一个XML字符串。我无法从XML字符串中删除缩进空间。我换行了。

  <person id="13"> 
      <name> 
          <first>John</first> 
          <last>Doe</last> 
      </name> 
      <age>42</age> 
      <Married>false</Married> 
      <City>Hanga Roa</City> 
      <State>Easter Island</State> 
      <!-- Need more details. --> 
  </person> 

<person id="13"><name><first>John</first><last>Doe</last></name><age>42</age><Married>false</Married><City>Hanga Roa</City><State>Easter Island</State><!-- Need more details. --></person> 

请您参考如下方法:

一些背景
不幸的是，XML不是regular language，因此，您将无法使用正则表达式可靠地对其进行处理-无论您将要开发的正则表达式多么复杂。
我将首先从this这个问题的幽默幽默开始，然后阅读this。
为了说明这一点，对示例进行的简单更改可能会破坏您的处理，例如:

  <person id="13"> 
      <name> 
          <first>John</first> 
          <last>Doe</last> 
      </name> 
      <age>42</age> 
      <Married>false</Married> 
      <City><![CDATA[Hanga <<Roa>>]]></City> 
      <State>Easter Island</State> 
      <!-- Need more details. --> 
  </person> 

<last>Von 
Neumann</last> 

<poem author="Chauser"> 
  <strophe number="1">  The lyf so short, 
  the craft so long to lerne.</strophe> 
</poem> 

<p>␣Some text which contains an␣<em>emphasized block</em> 
which is followed by a linebreak and more text.</p> 

package main 
 
import ( 
    "encoding/xml" 
    "errors" 
    "fmt" 
    "io" 
    "os" 
    "strings" 
) 
 
const xmlData = `<?xml version="1.0" encoding="utf-8"?> 
  <person id="13"> 
      weird text 
      <name> 
          <first>John</first> 
          <last><![CDATA[Johnson & ]]><![CDATA[ <<Johnson>> ]]><![CDATA[ & Doe ]]></last> 
      </name>&#x000d;&#x0020;&#x000a;&#x0009;<age> 
      42 
      </age> 
      <Married>false</Married> 
      <City><![CDATA[Hanga <Roa>]]></City> 
      <State>Easter Island</State> 
      <!-- Need more details. --> what? 
      <foo> more <bar/> text </foo> 
  </person> 
` 
 
func main() { 
    stripped, err := removeWS(xmlData) 
    if err != nil { 
        fmt.Fprintln(os.Stderr, err) 
        os.Exit(1) 
    } 
    fmt.Print(stripped) 
} 
 
func removeWS(s string) (string, error) { 
    dec := xml.NewDecoder(strings.NewReader(s)) 
 
    var sb strings.Builder 
    enc := NewSkipWSEncoder(&sb) 
 
    for { 
        tok, err := dec.Token() 
        if err != nil { 
            if err == io.EOF { 
                break 
            } 
            return "", fmt.Errorf("failed to decode token: %w", err) 
        } 
 
        err = enc.EncodeToken(tok) 
        if err != nil { 
            return "", fmt.Errorf("failed to encode token: %w", err) 
        } 
    } 
 
    err := enc.Flush() 
    if err != nil { 
        return "", fmt.Errorf("failed to flush encoder: %w", err) 
    } 
 
    return sb.String(), nil 
} 
 
type SkipWSEncoder struct { 
    *xml.Encoder 
 
    sawStartElement bool 
    charData        []xml.CharData 
} 
 
func NewSkipWSEncoder(w io.Writer) *SkipWSEncoder { 
    return &SkipWSEncoder{ 
        Encoder: xml.NewEncoder(w), 
    } 
} 
 
func (swe *SkipWSEncoder) EncodeToken(tok xml.Token) error { 
    if cd, isCData := tok.(xml.CharData); isCData { 
        if len(swe.charData) > 0 || swe.sawStartElement { 
            swe.charData = append(swe.charData, cd.Copy()) 
            return nil 
        } 
        if isWS(cd) { 
            return nil 
        } 
        return swe.Encoder.EncodeToken(tok) 
    } 
 
    if len(swe.charData) > 0 { 
        _, isEndElement := tok.(xml.EndElement) 
        err := swe.flushSavedCharData(isEndElement) 
        if err != nil { 
            return err 
        } 
    } 
 
    _, swe.sawStartElement = tok.(xml.StartElement) 
 
    return swe.Encoder.EncodeToken(tok) 
} 
 
func (swe *SkipWSEncoder) Flush() error { 
    if len(swe.charData) > 0 { 
        return errors.New("attempt to flush encoder while having pending cdata") 
    } 
    return swe.Encoder.Flush() 
} 
 
func (swe *SkipWSEncoder) flushSavedCharData(mustKeep bool) error { 
    if mustKeep || !allIsWS(swe.charData) { 
        err := encodeCDataList(swe.Encoder, swe.charData) 
        if err != nil { 
            return err 
        } 
    } 
 
    swe.charData = swe.charData[:0] 
 
    return nil 
} 
 
func encodeCDataList(enc *xml.Encoder, cdataList []xml.CharData) error { 
    for _, cd := range cdataList { 
        err := enc.EncodeToken(cd) 
        if err != nil { 
            return err 
        } 
    } 
    return nil 
} 
 
func isWS(b []byte) bool { 
    for _, c := range b { 
        switch c { 
        case 0x20, 0x09, 0x0d, 0x0a: 
            continue 
        } 
        return false 
    } 
    return true 
} 
 
func allIsWS(cdataList []xml.CharData) bool { 
    for _, cd := range cdataList { 
        if !isWS(cd) { 
            return false 
        } 
    } 
    return true 
}