如何去除 XML 字符串中的 XML 注释？

从现在开始，努力学习吧！本文《如何去除 XML 字符串中的 XML 注释？》主要讲解了等等相关知识点，我会在golang学习网中持续更新相关的系列文章，欢迎大家关注并积极留言建议。下面就先一起来看一下本篇正文内容吧，希望能帮到你！

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

      
          john
          doe
      
      42
      false
      hanga roa
      easter island
      
  

如何从 golang 中的字符串中删除 xml 缩进空格？

我想要这个 xml 作为字符串，

JohnDoe42falseHanga RoaEaster Island

如何在 golang 中执行此操作？

解决方案

删除 xml 标记之间的仅空白序列

func unformatxml(xmlstring string) string {
    var unformatxmlregex = regexp.mustcompile(`>\s+<`)
    unformatbetweentags := unformatxmlregex.replaceallstring(xmlstring, "><") // remove whitespace between xml tags
    return strings.trimspace(unformatbetweentags) // remove whitespace before and after xml
}

正则表达式说明

\s - 匹配任何空白，包括制表符、换行符、换页符、回车符和空格

+ - 匹配一个或多个空白字符

正则表达式语法参考：https://golang.org/pkg/regexp/syntax/

示例

package main

import (
    "fmt"
    "regexp"
    "strings"
)

func main() {
    var s = `    

    
        john
        doe
    
    42
    false
    hanga roa
    easter island
    
   `

    s = unformatxml(s)
    fmt.println(fmt.sprintf("'%s'", s)) // single quotes used to confirm no leading or trailing whitespace
}

func unformatxml(xmlstring string) string {
    var unformatxmlregex = regexp.mustcompile(`>\s+<`)
    unformatbetweentags := unformatxmlregex.replaceallstring(xmlstring, "><") // remove whitespace between xml tags
    return strings.trimspace(unformatbetweentags) // remove whitespace before and after xml
}

go 演示中的可运行示例

https://play.golang.org/p/VS1LRNevicz

一些背景

不幸的是，xml 不是 regular language，因此您根本无法使用正则表达式可靠地处理它 — 无论您能够想出多么复杂的正则表达式。

我会从 this 对这个问题的精彩幽默的看法开始，然后阅读 this。

为了演示，对示例进行简单的更改可能会破坏您的处理，例如：

  
      
          john
          doe
      
      42
      false
      >]]>
      easter island
      
  

事实上，考虑一下

von
neumann

您认为为什么您可以自由地从该元素的内容中删除换行符？

当然，你会说一个人的姓氏中不能有一个换行符。
好的，但是这个怎么样？

    the lyf so short,
  the craft so long to lerne.

你不能明智地删除该句子的两个部分之间的空格 - 因为这是作者的意图。

好吧，完整的故事在 the section called "White Space Handling" of the XML spec 中定义。
外行人尝试描述 xml 中的空白处理如下：

• xml 规范本身并没有为空白指定任何特殊含义：xml 文档的特定位置中的空白意味着什么取决于该文档的处理者。

  通过扩展，规范并没有强制要求任何“标签”（那些 和 和 事物 - 出现在允许 xml 标记的点处）之间是否存在空格。 显着或不：只有你自己决定。
  为了更好地理解其原因，请考虑以下文档：

  ␣some text which contains an␣emphasized block
  which is followed by a linebreak and more text.
  

  这是一个完全有效的 xml，我已经替换了空格字符 紧接在

  标记之后和 标记之前，并带有用于显示目的的 unicode“打开框”字符。

  请注意，整个文本 ␣ 一些包含 an␣ 的文本出现在两个标签之间，并且包含前导和尾随空白，这显然是重要的 - 如果不是，则强调文本（标记为加上 … 将与前面的文本粘在一起）。

  相同的逻辑适用于 标记后的换行符和更多文本。

• xml 规范提示指出，定义“无关紧要”的空白来表示一对不定义单个元素的相邻标记之间的任何空白可能会很方便。

xml 还有两个使处理进一步复杂化的功能：

• 字符实体（& 和 < 事物）允许直接插入任何 unicode 代码点：例如， 将插入换行符。
• xml 支持特殊的 "CDATA sections"，您的解析器表面上对此一无所知。

解决方案的方法

在我们尝试提出解决方案之前，我们将定义哪些空白是我们打算视为无关紧要的，然后删除。

看起来像您的文档类型，定义应该是：任何两个标签之间的任何字符数据都应该被删除，除非：

• 它至少包含一个非空白字符，或者
• 它完整地定义了单个 xml 元素的内容。

考虑到这些因素，我们可以编写代码，将输入 xml 流解析为标记，并将它们写入输出 xml 流，同时应用以下逻辑来处理标记：

1. 如果它看到字符数据以外的任何 xml 元素，它会将它们编码到输出流中。

   此外，如果该元素是开始标签，它会通过设置一些标志来记住这一事实；否则标志被清除。

2. 如果它看到任何字符数据，它会检查该字符数据是否紧跟在开始元素（开始标记）之后，如果是，则保存该字符数据块。

   当已经存在这样的已保存块时，也会保存字符数据块 - 这是需要的，因为在 xml 中，文档中可能有多个相邻但仍然不同的字符数据块。

3. 如果它看到任何 xml 元素，并检测到它有一个或多个保存的字符块，那么它首先决定是否将它们放入输出流：

   • 如果元素是结束元素（结束标记），则所有字符数据块都必须“按原样”放入输出流中，因为它们完全定义了单个元素的内容。

   • 否则，如果至少一个保存的字符数据块包含至少一个非空白字符，则所有块都会按原样写入输出流。

   • 否则所有块都会被跳过。

这是实现所描述方法的工作代码：

package main

import (
    "encoding/xml"
    "errors"
    "fmt"
    "io"
    "os"
    "strings"
)

const xmlData = `
  
      weird text
      
          John
          > ]]>
      
 
	
      42
      
      false
      ]]>
      Easter Island
       what?
       more  text 
  
`

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
}

Playground。

我不确定它是否完全涵盖了所有可能的奇怪情况，但这应该是一个好的开始。

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《如何去除 XML 字符串中的 XML 注释？》文章吧，也可关注golang学习网公众号了解相关技术文章。