自定义 XML Marshal化具有中间字符串的数组

来到golang学习网的大家，相信都是编程学习爱好者，希望在这里学习Golang相关编程知识。下面本篇文章就来带大家聊聊《自定义 XML Marshal化具有中间字符串的数组》，介绍一下，希望对大家的知识积累有所帮助，助力实战开发！

我有一段需要读取和写入的 xml 片段。它是一个 数组，除了最后一个实体之外，每个数组之间都有一个 。

<conditions>                                                                                                                                                                                                                                                                              
    <condition>                                                                                                                                                                                                                                                                           
      <label>a</label>                                                                                                                                                                                                                                                                    
    </condition>                                                                                                                                                                                                                                                                          
    <operator>and</operator>                                                                                                                                                                                                                                                              
    <condition>                                                                                                                                                                                                                                                                           
      <label>b</label>                                                                                                                                                                                                                                                                    
    </condition>                                                                                                                                                                                                                                                                          
    <operator>and</operator>                                                                                                                                                                                                                                                              
    <condition>                                                                                                                                                                                                                                                                           
      <label>c</label>                                                                                                                                                                                                                                                                    
    </condition>                                                                                                                                                                                                                                                                          
<conditions>

我的 go 模型看起来像这样

type condition struct {                                                                                                                                                                                                                                                                   
    xmlname xml.name `xml:"condition" json:"-"`                                                                                                                                                                                                                                           
    label   string   `xml:"label"`                                                                                                                                                                                                                                                        
}                                                                                                                                                                                                                                                                                         

type conditions struct {                                                                                                                                                                                                                                                                  
    conditionlist []condition `xml:"condition,omitempty"`                                                                                                                                                                                                                                 
    operator      string      `xml:"operator"`                                                                                                                                                                                                                                            
}

如果我编组该结构，则运算符仅在底部出现一次。正如预期的那样

<conditions>
  <condition>
    <label>a</label>
  </condition>
  <condition>
    <label>b</label>
  </condition>
  <condition>
    <label>c</label>
  </condition>
  <operator>and</operator>
</conditions>

如何让运算符出现在除最后一个条件之外的每个条件之后？

我能得到的最接近的是使用包装器

func (c conditions) marshalxml(e *xml.encoder, start xml.startelement) error {                                                                                                                                                                                                            

    type tcondition struct {                                                                                                                                                                                                                                                              
        xmlname xml.name `xml:"condition" json:"-"`                                                                                                                                                                                                                                       
        label   string   `xml:"label"`                                                                                                                                                                                                                                                    
    }                                                                                                                                                                                                                                                                                     
    type tconditionwithop struct {                                                                                                                                                                                                                                                        
        xmlname   xml.name   `xml:"-" json:"-"`                                                                                                                                                                                                                                           
        condition tcondition `xml: "conditions"`                                                                                                                                                                                                                                          
        operator  string     `xml:",omitempty"`                                                                                                                                                                                                                                           
    }                                                                                                                                                                                                                                                                                     
    type twrapper struct {                                                                                                                                                                                                                                                                
        ops []tconditionwithop                                                                                                                                                                                                                                                            
    }                                                                                                                                                                                                                                                                                     

    lst := make([]tconditionwithop, 0, 10)                                                                                                                                                                                                                                                

    for idx, cond := range c.conditionlist {                                                                                                                                                                                                                                              
        tcond := tcondition{                                                                                                                                                                                                                                                              
            label: cond.label,                                                                                                                                                                                                                                                            
        }                                                                                                                                                                                                                                                                                 
        tcondop := tconditionwithop{                                                                                                                                                                                                                                                      
            condition: tcond,                                                                                                                                                                                                                                                             
        }                                                                                                                                                                                                                                                                                 

        if idx < len(c.conditionlist)-1 {                                                                                                                                                                                                                                                 
            tcondop.operator = c.operator                                                                                                                                                                                                                                                 
        }                                                                                                                                                                                                                                                                                 

        lst = append(lst, tcondop)                                                                                                                                                                                                                                                        

    }                                                                                                                                                                                                                                                                                     
    wrapper := twrapper{                                                                                                                                                                                                                                                                  
        ops: lst,                                                                                                                                                                                                                                                                         
    }                                                                                                                                                                                                                                                                                     

    return e.encodeelement(wrapper, start)                                                                                                                                                                                                                                                
}

但我现在有一个 标签

<Conditions>
  <OPS>
    <condition>
      <label>a</label>
    </condition>
    <Operator>AND</Operator>
  </OPS>
  <OPS>
    <condition>
      <label>b</label>
    </condition>
    <Operator>AND</Operator>
  </OPS>
  <OPS>
    <condition>
      <label>c</label>
    </condition>
  </OPS>
</Conditions>

我在这里创建了一个演示

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

解决方案

将条件和运算符元素交错到 []interface{} 数组中是可行的。谢谢

type Operator struct {                                                                                                                                       
    Name string                                                                                                                                              
}                                                                                                                                                            

func (op Operator) MarshalXML(e *xml.Encoder, start xml.StartElement) error {                                                                                
    start.Name.Local = "operator"                                                                                                                            
    return e.EncodeElement(op.Name, start)                                                                                                                   
}                                                                                                                                                            

func (c Conditions) MarshalXML(e *xml.Encoder, start xml.StartElement) error {                                                                               

    start.Name.Local = "conditions"                                                                                                                          
    var arr []interface{}                                                                                                                                    

    for idx, cond := range c.ConditionList {                                                                                                                 
        if idx > 0 {                                                                                                                                         
            arr = append(arr, Operator{Name: c.Operator})                                                                                                    
        }                                                                                                                                                    
        arr = append(arr, cond)                                                                                                                              
    }                                                                                                                                                        

    type root struct {                                                                                                                                       
        ARR []interface{}                                                                                                                                    
    }                                                                                                                                                        

    return e.EncodeElement(root{ARR: arr}, start)                                                                                                            
}

以上就是《自定义 XML Marshal化具有中间字符串的数组》的详细内容，更多关于的资料请关注golang学习网公众号！