如何在平行结构里处理树形结构的数据

var t xml.Token
var inItemGroup bool
for t, err = decoder.Token(); err == nil; t, err = decoder.Token(){
    switch token := t(type){
    case xml.StarElement:
        name := token.Name.Local
        if inItemGroup{
            if name == "Compile"{
            // 第二步，处理标记事件
                fmt.Println(name)
            }
        }else{
            if name == "ItemGroup"{
            // 第一步，找到就开启标记
                inItemGroup = true
            }
        }
    }
    case xml.EndElement:
    // 结束标签 </EndElement> 标记
        if inItemGroup{
            if token.Name.Local == "ItemGroup"{
            // 第三步, 关闭标记
                inItemGroup = false
            }
            
        }
}

经验和建议

• 字符串处理切勿造轮子

• 字符串转化注意错误处理

• flag.Parse 记得调

• 新需求尽量用 json

实战！

• 从 VS 工程文件获取文件列表

• 模拟命令行拷贝文件

基础知识

• 字符串基本操作，和其他类型的互相转化

• XML 编码处理

• 命令行解析

package main

import (
   "bufio"
   "flag"
   "fmt"
   "io"
   "os"
   "strings"
)

func fileExists(filename string) bool {
   _, err := os.Stat(filename)
   return err == nil || os.IsExist(err)
}

// 拷贝文件的行文
func copyFileAction(src, dst string, showProgress, force bool) {
   if !force {
      if fileExists(dst) {
         fmt.Printf("%s exists, override? y/n\n", dst)
         reader := bufio.NewReader(os.Stdin)
         data, _, _ := reader.ReadLine()

         if strings.TrimSpace(string(data)) != "y" {
            return
         }
      }
   }

   copyFile(src, dst)

   if showProgress {
      fmt.Printf("'%s' -> '%s'\n", src, dst)
   }
}

func copyFile(src string, dst string) (w int64, err error) {
   srcFile, err := os.Open(src)
   if err != nil {
      fmt.Println(err.Error())
      return
   }
   defer srcFile.Close()

   dstFile, err := os.Create(dst)
   if err != nil {
      fmt.Println(err.Error())
      return
   }
   defer dstFile.Close()

   return io.Copy(dstFile, srcFile)
}

func main() {
   var showProgress, force bool
   
   flag.BoolVar(&force, "f", false, "force copy when existing")
   flag.BoolVar(&showProgress, "v", false, "explain what is being done")
   
   flag.Parse()
   
   if flag.NArg() < 2 {
      flag.Usage()
      return
   }

   copyFileAction(flag.Arg(0), flag.Arg(1), showProgress, force)
}

-f：强制执行

-v：输出拷贝动作

命令行解析 GO

模拟 Linux 中的 CP 指令

模拟命令行拷贝

package main

import (
   "bytes"
   "encoding/xml"
   "fmt"
   "io/ioutil"
)

func main() {
   content, err := ioutil.ReadFile("vsproj.csproj")
   
   decoder := xml.NewDecoder(bytes.NewBuffer(content))

   var t xml.Token
   var inItemGroup bool
   for t, err = decoder.Token(); err == nil; t, err = decoder.Token() {
      switch token := t.(type) {
      case xml.StartElement:
         name := token.Name.Local

         if inItemGroup {
            if name == "Compile" {
               fmt.Println(getAttributeValue(token.Attr, "Include"))
            }
         } else {
            if name == "ItemGroup" {
               inItemGroup = true
            }
         }
      case xml.EndElement:
      }
   }
}

func getAttributeValue(attr []xml.Attr, name string) string {
   for _, a := range attr{
      if a.Name.Local == name {
         return a.Value
      }
   }

   return ""
}

package main

import (
   "flag"
   "fmt"
)

func style()  {
   // 格式化定义
   methodPtr := flag.String("method", "default", "method of sample")
   valuePtr := flag.Int("value", -1, "value of sample")

   // 解析
   flag.Parse()

   fmt.Println(*methodPtr, *valuePtr)
}

func style2()  {
   var method string
   var value int

   flag.StringVar(&method, "method", "default", "method of sample")
   flag.IntVar(&value, "value", -1, "value of sample")

   flag.Parse()

   fmt.Println(method, value)
}

func main() {
   style2()
}

package main

import (
   "fmt"
   "os"
)

func main() {
   fmt.Println(os.Args)
}

package main

import (
   "encoding/xml"
   "fmt"
)

// 人物档案
type person struct {
   Name string `xml:"name,attr"`
   Age int `xml:"年龄"`
}

func main() {
   p := person{
      Name: "Davy",
      Age:  18,
   }

   data, err := xml.MarshalIndent(p, "", "    ")
   if err != nil {
      fmt.Println(err)
      return
   }
   fmt.Println(string(data))

   var p2 person

   err = xml.Unmarshal(data, &p2)
   if err != nil {
      fmt.Println(err)
      return
   }
   fmt.Println(p2)
}

// 基本数值转换
fmt.Println(strconv.Itoa(10))
fmt.Println(strconv.Atoi("711"))

// 解析
fmt.Println(strconv.ParseBool("false"))
fmt.Println(strconv.ParseFloat("3.14", 64))

// 格式化
fmt.Println(strconv.FormatBool(true))
fmt.Println(strconv.FormatInt(123, 2))

s := "hello world"

// 是否包含
fmt.Println(strings.Contains(s, "hello"), strings.Contains(s, "?"))

// 索引，base 0
fmt.Println(strings.Index(s, "o"))

ss := "1#2#345"

// 切割字符串
splitedStr := strings.Split(ss, "#")
fmt.Println(splitedStr)

// 合并字符串
fmt.Println(strings.Join(splitedStr, "#"))

fmt.Println(strings.HasPrefix(s, "he"), strings.HasSuffix(s, "ld"))

字符串基本操作

实战

• 从 VS 工程文件获取文件列表

• 模拟命令行拷贝文件
  

字符串相关操作

• 字符串切割，合并，查找

• 字符串和其他类型的转化

• 整型布尔型浮点型

Galang 之文本编码处理

package main

import (
   "bufio"
   "flag"
   "fmt"
   "io"
   "os"
   "strings"
)

func fileExists(filename string) bool {
   _, err := os.Stat(filename)
   return err == nil || os.IsExist(err)
}

func copyFileAction(src, dst string, showProgress, force bool)  {
   if !force {
      if fileExists(dst) {
         fmt.Println("%s exists override ? y/n\n", dst)
         reader := bufio.NewReader(os.Stdin)
         data, _, _ := reader.ReadLine()

         if strings.TrimSpace(string(data)) != "y" {
            return
         }
      }
   }
   
   copyFile(src, dst)

   if showProgress {
      fmt.Println("'%s' -> '%s'\n", src, dst)
   }
   
}

func copyFile(src, dst string) (w int64, err error)  {
   srcFile, err := os.Open(src)
   if err != nil {
      fmt.Println(err.Error())
      return
   }

   defer srcFile.Close()

   dstFile, err := os.Create(dst)
   if err != nil {
      fmt.Println(err.Error())
      return
   }

   defer dstFile.Close()

   return io.Copy(dstFile, srcFile)
}

func main() {
   var showProgress, force bool

   // 定义命令行参数
   flag.BoolVar(&force, "f", false, "force copy when existing")
   flag.BoolVar(&showProgress, "v", false, "explain what is being done")

   flag.Parse()

   // 非法命令行数量检测
   if flag.NArg() < 2 {
      flag.Usage()
      return
   }

   copyFileAction(flag.Arg(0), flag.Arg(1), showProgress, force)
}

栗子吱吱吱吱

拷贝文件：从src读，写到dst

NArg 命令行参数数量的检查

获取节点属性

获取节点

字符串转换与格式化

整型和字符串转换

判断前缀和后缀是否存在