Go语言一知半解上手记（一）

一、缘起

  从团队里几个同事在自研的发布工具中开始用Go语言实现一些模块，到后来微服务的服务发现工具从Eureka换成了Go语言实现的Consul，虽然自己也一直想早点去了解Go语言，也在考虑将Go语言作为团队技术路线中的一部分，无奈杂事缠身，陆陆续续也就是看了些关于Go的文章。在这个过程中，Go语言的发展真快，心里的那股吸引也是越来越强烈。

  年前开始，首先在“极客时间”上观看了《Go语言从入门到实战 蔡超》的视频教程，有其他语言基础的筒子们可以拿来看看，55节课从浅到深的讲了Go语言的特性。看过之后，忘掉的比记住的要多，也有不少没有理解的地方，还远远不能将Go语言转换为生产工具。

  近日，随着年后工作步入正轨，也下定决心从使用Go语言来实现手边的小工具开始，逐步将Go语言用起来。毕竟，在实战中学习，效果会更好一些，同时也计划将学习与实战的过程记录下来，作为这段时间的总结，如果能为我一样的Go语言新手们带来一些帮助，那就再好不过了。

二、小工具（代码生成工具）的需求

  我们近期忙碌了一个小程序的项目，后台用的是 nodejs 的 koa 框架。在设计中，model层的代码是相似度很高，controller层的代码也是如此，如controller中的基础的方法（增、删、改、基于id查询对象、分页查询多个对象等），那就意味着，model层、controller层的代码可以抽象出模板来，通过“代码生成工具”对“数据字典文件”进行解读后进行批量的代码生成。如此，“代码生成工具”的任务有三个：

1. 解析“数据字典”文件
2. 加载“model模板”、“controller模板”
3. 根据解析结果，结合模板，生成对应的代码文件

三、任务1【“解析“数据字典”文件】的实现

1、基础准备

• 搭建Go语言编写环境

  目前，我常用的开发工具是vscode、idea，这两个都可以拿来作为编写Go程序，但是vscode要下载插件、要进行配置等等。对于我这么急迫的想上手的人来讲，时间是最宝贵的了，所以，我还是选择了idea体系下的goland，下载即用，省时省力。
  当然，要编写Go语言，除了IDE，更主要的前提是安装Go。https://golang.google.cn/ 上的首页就给出来显眼的按钮“Download Go”，下载安装即可。

• 了解Go语言的基本框架结构

  package main
  
  import "fmt"
  
  func main() {
      fmt.Println("你好, 世界!") // 不引入"fmt", 直接使用 println 也是可以的
  }
  

  同时也知晓了Go语言是如何打印信息的。推荐 https://tour.go-zh.org/ ，绝佳入门选择。

• 了解Go语言在编写之后的运行与编译方法

  运行

  go run ./xxx.go 
  

  编译

  go build ./xxx.go 
  

  编译后的文件，直接就可以运行了

• 了解Go语言中定义参数的方法

  var fileName string       // 声明变量
  var sheetIndex int = 1    // 声明变量并初始化，此时也可以忽略参数类型，编译器会自行推导出变量类型
  headers := make(map[int]string) // 短变量声明并初始化
  // 当然，还有批量变量的声明方式,
  // 但我们的初心是快速上手实现小工具，
  // 因此没必要现在就将所有的方式都掌握，先行掌握最规范、最易用的方式即可
  

  同时，也需要了解Go语言中的变量类型，基本类型都是比较好掌握的，更重要的是了解我们经常用的array\map等复杂数据类型，以及json等数据组织方式，当然，Go语言的类型有着自己的特点，也有特有的类型，这些不需要专门去记忆，在用的过程中，变查边用边记忆就好，慢慢地就会越来越熟练的。

• 了解Go语言中使用if的方法

  if sheetIndex < 0 {
    fmt.Println("invild value");
  } else if sheetIndex = 1 {
    fmt.Println(sheetIndex, "the sheet of list");
  } else {
    fmt.Println(sheetIndex, "the sheet of dataDict");
  }
  

  最重要的特点是，在 if 关键词之后，在条件语句之前，是可以先执行变量的初始化语句的。当然，这个特性不见得每次都用的上。

• 了解Go语言中使用循环结构的方法

  arr := [...]int{6, 2, 4, 9, 8, 3}
  //1.基本的循环方式
  for i := 0; i < len(arr); i++ {
    fmt.Print(arr[i], "\t")
  }
  fmt.Println()
  
  //2.range遍历方式
  for idx, value := range arr {
    fmt.Print(idx, "=", value, "\t")
  }
  fmt.Println()
  

  通过了解数组遍历的方式去了解循环的使用，最直接了当了。

• 了解Go语言中函数的定义与使用方法

  package main
  
  import (
    "fmt"
  )
  // 函数定义
  func sayHi(name string) string {
    str := "hello, " + name
    fmt.Println("inner print:", str)
    return str
  }
  // 函数调用
  func main() {
    result := sayHi("world")
    fmt.Println("outer print:", result)
  }
  

  函数的组成部分：修饰符，函数名，参数，函数体，返回值

---

  上述内容，已足够帮助我们开始小工具的编写了，当然，过程中肯定会遇到卡壳的现象，这时，充分利用好搜索大法，再加上一点点思考，问题总会迎刃而解的。

---

2、开始动手

step_01：安装Go以及Goland

step_02：创建项目及代码目录及代码文件

a_code_generator

┣━ main

┃ ┗━ main.go

┗━ resource

​ ┗━ datadict.xlsx

step_03：创建代码框架并初步运行查看结果

package main

func main(){
    println("程序运行 @ 开始")
    println("程序运行 @ 结束")
}

运行结果为（➜ a_code_generator 是当前目录）：

➜  a_code_generator go run main/main.go
程序运行 @ 开始
程序运行 @ 结束

---

后续步骤的目标是：实现小工具的第一个任务：“解析“数据字典”文件。

---

step_04：对 xlsx 文件进行逐行逐单元格分析

  数据字典是xlsx文件，需要使用Go语言实现对xlsx文件的读取。通过搜索，确定使用 excelize 这个组件，github 地址是 https://github.com/360EntSecGroup-Skylar/excelize。

  涉及到组件的使用，首先要考虑如何将第三方组件管理起来，于是，开始搜索Go语言包管理的相关知识。我使用的Go版本是1.13.5，因此可以使用 Go Modules 的方式。接着，就需要了解在Goland中是否有相应的使用方式，参考网址为 https://www.cnblogs.com/xiaobaiskill/p/11819071.html，基于文档中的步骤进行配置即可。

  障碍扫除，根据 README.md 的指导，很容易实现我们想要的功能。

组件安装（终端中执行，➜ a_code_generator 是当前目录）：

➜  a_code_generator go get github.com/360EntSecGroup-Skylar/excelize

功能代码（main.go中，读取./resource/datadict.xlsx文件中的“总纲”sheet页）：

package main

import "github.com/360EntSecGroup-Skylar/excelize"

func main() {
    println("程序运行 @ 开始")
  
  // 1.打开xlsx文件
    f, err := excelize.OpenFile("./resource/datadict.xlsx")
    if err != nil {
        println(err.Error())
        return
    }
  
    // 2.对xlsx文件中的"总纲"sheet页逐行逐单元格进行遍历
    rows := f.GetRows("总纲")
    for _, row := range rows {
        for _, colCell := range row {
            print(colCell, "\t")
        }
        println()
    }
  
    println("程序运行 @ 结束")
}

step_05：接收命令行参数

  前一步骤中，文件的地址以及sheet页的名称是我们写死在程序中的，不够灵活，那我们如何在程序运行的时候将参数传递到程序内部呢？通过搜索关键字“golang 获取命令行变量”，找到参考，请看 https://studygolang.com/articles/21438 。用到了第三方模块“flag”，能够实现-h，获取帮助，以及通过自定义的flag接收指定参数的功能。

package main

import (
    "flag"
    "github.com/360EntSecGroup-Skylar/excelize"
)

func main() {

    println("程序运行 @ 开始")

    // 1.接收控制台变量
    var fileName string  // xlsx文件路径
    var sheetName string // sheet页的名称
    flag.StringVar(&fileName, "f", "", "xlsx文件路径")
    flag.StringVar(&sheetName, "s", "", "sheet页名称")
    flag.Parse()
    if fileName == "" || sheetName == "" {
        println("请输入xlsx文件路径及sheet页名称，如需帮助，请在命令后输入 -h")
        return
    }

    // 2.打开xlsx文件
    f, err := excelize.OpenFile(fileName)
    if err != nil {
        println(err.Error())
        return
    }

    // 3.对xlsx文件中的指定名称的sheet页逐行逐单元格进行遍历
    rows := f.GetRows(sheetName)
    for _, row := range rows {
        for _, colCell := range row {
            print(colCell, "\t")
        }
        println()
    }

    println("程序运行 @ 结束")
}

代码中约定了 -f 后面跟着的是“ xlsx 文件路径”，-s 后跟着的是“sheet页名称”

不传递任何参数，运行程序（在终端中运行，➜ a_code_generator 是当前目录）：

➜  a_code_generator go run main/main.go
程序运行 @ 开始
请输入xlsx文件路径及sheet页名称，如需帮助，请在命令后输入 -h

命令后输入-h，运行程序（在终端中运行，➜ a_code_generator 是当前目录）：

➜  a_code_generator go run main/main.go -h
程序运行 @ 开始
Usage of /var/folders/hw/jyjf138s2vqg0_8sbdwctk000000gn/T/go-build941042187/b001/exe/main:
  -f string
        xlsx文件路径
  -s string
        sheet页名称
exit status 2

命令行后输入 -s -f 及相应的值，运行程序（在终端中运行，➜ a_code_generator 是当前目录）：

➜  a_code_generator go run main/main.go -f ./resource/datadict.xlsx -s 总纲
程序运行 @ 开始
# 介于篇幅，sheet中打印出来的内容就省略掉了
程序运行 @ 结束

step_06：获取 xlsx 文件中的sheet页信息

  前一步骤中，我们可以通过命令行接收参数来打开指定sheet页了，文件名是比较直观可以获得的，但是，sheet页的名称如果忘记了，还得打开文件才能知道，这样有些低效。那么，有没有方法能够让我们通过程序获得sheet页的信息呢？README.md中没有直接给出示例，但是在浏览了github上excelize中的文件后，发现了sheet_test.go，文件的最下面，有个TestGetSheetMap函数，里面正好有我们想要的代码。

package main

import (
    "flag"
    "github.com/360EntSecGroup-Skylar/excelize"
)

func main() {

    println("程序运行 @ 开始")

    // 1.接收控制台变量
    var fileName string  // xlsx文件路径
    var sheetName string // sheet页的名称
    flag.StringVar(&fileName, "f", "", "xlsx文件路径")
    flag.StringVar(&sheetName, "s", "", "sheet页名称")
    flag.Parse()
    if fileName == "" {
        println("请输入xlsx文件路径，如需帮助，请在命令后输入 -h")
        return
    }

    // 2.打开xlsx文件
    f, err := excelize.OpenFile(fileName)
    if err != nil {
        println(err.Error())
        return
    }

    // 3.如果 sheetName 为空，则打印出该文件的所有sheet页信息
    if sheetName == "" {
        println("该文件中有如下sheet页（没有基于索引排序）：")
        sheetMap := f.GetSheetMap()
        for idx, sheet := range sheetMap {
            println("\t", "索引 = ", idx, ", 名称 = ", sheet)
        }
        return
    }

    // 4.对xlsx文件中的指定名称的sheet页逐行逐单元格进行遍历，代码没有变化，此处便忽略掉了

    println("程序运行 @ 结束")
}

• 如果运行程序时，未使用 -s 输入sheet页名称，则将该文件中的所有 sheet 页信息打印出来
• Go语言中的map是无序的，所以遍历出来的结果并不是顺序的，如果需要顺序输出，则额外需要做一些处理，如将map中的key转存到数组中进行排序后再基于数组遍历map
• 在我们的场景中，一个数据字典的sheet页的数量不会太多，也就没有必要强求顺序输出了
• 通过该功能够获得sheet页索引了，支持通过索引来打开sheet页会更加便捷一些，程序做如下改变

package main

import (
    "flag"
    "github.com/360EntSecGroup-Skylar/excelize"
)

func main() {

    println("程序运行 @ 开始")

    // 1.接收控制台变量
    var fileName string  // xlsx文件路径
    var sheetName string // sheet页的名称
    var sheetIndex int   // sheet页的索引
    flag.StringVar(&fileName, "f", "", "xlsx文件路径")
    flag.StringVar(&sheetName, "s", "", "sheet页名称，索引和名称使用一个即可，都有值则以名称为准")
    flag.IntVar(&sheetIndex, "i", -1, "sheet页索引，索引和名称使用一个即可，都有值则以名称为准")
    flag.Parse()
    if fileName == "" {
        println("请输入xlsx文件路径，如需帮助，请在命令后输入 -h")
        return
    }

    // 2.打开xlsx文件
    f, err := excelize.OpenFile(fileName)
    if err != nil {
        println(err.Error())
        return
    }

    // 3.如果 sheetName 为空 或 sheetIndex 为默认值，则打印出该文件的所有sheet页信息
    if sheetName == "" && sheetIndex == -1 {
        println("该文件中有如下sheet页（没有基于索引排序）：")
        sheetMap := f.GetSheetMap()
        for idx, sheet := range sheetMap {
            println("\t", "索引 = ", idx, ", 名称 = ", sheet)
        }
        return
    }

    // 4.对xlsx文件中的指定名称的sheet页逐行逐单元格进行遍历
    var rows [][]string
    if sheetName != "" { // 4.1.当sheet页名称设置时，以 sheetName 为准
        rows = f.GetRows(sheetName)
    } else { // 4.2.当sheet页名称未设置时，以 sheetIndex 为准
        rows = f.GetRows(f.GetSheetName(sheetIndex))
    }

    for _, row := range rows {
        for _, colCell := range row {
            print(colCell, "\t")
        }
        println()
    }

    println("程序运行 @ 结束")
}

step_07：在重构中了解函数的定义及error的使用

  进行到现在，main方法中的代码已经比较长了，而且，明显的分成了一段段的代码块，本着实时重构的态度，我们接下来可以将这些代码快抽象成函数，以增加程序的可读性，这也是了解函数如何定义的一个很好的阶段。同时，我们从 f, err := excelize.OpenFile(fileName) 这种代码中，发现了函数是有多个返回值的，而且，最后会返回一个 err，以便我们针对错误做出响应。这就是我们模仿的对象。了解error类型，请参照 https://blog.csdn.net/fwhezfwhez/article/details/79175376 。重构后的代码如下

package main

import (
    "errors"
    "flag"
    "github.com/360EntSecGroup-Skylar/excelize"
)

// 接收控制台变量
func receiveConsoleParam() (string, string, int, error) {
    var fileName string  // xlsx文件路径
    var sheetName string // sheet页的名称
    var sheetIndex int   // sheet页的索引
    flag.StringVar(&fileName, "f", "", "xlsx文件路径")
    flag.StringVar(&sheetName, "s", "", "sheet页名称，索引和名称使用一个即可，都有值则以名称为准")
    flag.IntVar(&sheetIndex, "i", -1, "sheet页索引，索引和名称使用一个即可，都有值则以名称为准")
    flag.Parse()
    if fileName == "" {
        return "", "", -1, errors.New("请输入xlsx文件路径，如需帮助，请在命令后输入 -h")
    }
    return fileName, sheetName, sheetIndex, nil
}

// 输出xlsx文件中所有的sheet页信息
func listAllSheet(file *excelize.File) {
    println("该文件中有如下sheet页（没有基于索引排序）：")
    sheetMap := file.GetSheetMap()
    for idx, sheet := range sheetMap {
        println("\t", "索引 = ", idx, ", 名称 = ", sheet)
    }
}

// 对xlsx文件中的指定名称的sheet页逐行逐单元格进行遍历
func analyzeSheet(rows [][]string) error {
    // 1.合法性校验
    if len(rows) <= 0 {
        return errors.New("没有需要分析的行")
    }
    // 2.遍历需要分析的行
    for _, row := range rows {
        for _, colCell := range row {
            print(colCell, "\t")
        }
        println()
    }
    // 3.能够正常执行到此，说明没有错误，返回 nil
    return nil
}

// 入口函数
func main() {
    println("程序运行 @ 开始")

    // 1.接收控制台变量
    fileName, sheetName, sheetIndex, err := receiveConsoleParam()
    if err != nil {
        println(err.Error())
        return
    }

    // 2.打开xlsx文件
    f, err := excelize.OpenFile(fileName)
    if err != nil {
        println(err.Error())
        return
    }

    // 3.如果 sheetName 为空 或 sheetIndex 为默认值，则打印出该文件的所有sheet页信息
    if sheetName == "" && sheetIndex == -1 {
        listAllSheet(f)
        return
    }

    // 4.对xlsx文件中的指定名称的sheet页逐行逐单元格进行遍历
    var rows [][]string
    if sheetName != "" { // 4.1.当sheet页名称设置时，以 sheetName 为准
        rows = f.GetRows(sheetName)
    } else { // 4.2.当sheet页名称未设置时，以 sheetIndex 为准
        rows = f.GetRows(f.GetSheetName(sheetIndex))
    }
    err = analyzeSheet(rows)
    if err != nil {
        println(err.Error())
        return
    }

    println("程序运行 @ 结束")
}

---

通过以上步骤，我们已经构建好了分析 sheet 页内容的框架，接下来便是实现具体的分析逻辑了，也就是对函数analyzeSheet的扩充。

---

step_08：函数 analyzeSheet 中 处理空单元格及空行

// 对xlsx文件中的指定名称的sheet页逐行逐单元格进行遍历
func analyzeSheet(rows [][]string) error {
    // 1.合法性校验
    if len(rows) <= 0 {
        return errors.New("没有需要分析的行")
    }
    // 2.遍历需要分析的行
    for rIdx, row := range rows {
        notEmptyCellNum := 0 // 本行非空单元格的数量
        for cIdx, colCell := range row {
            // 去掉单元格内容的首尾空白字符
            cellValue := strings.TrimSpace(colCell)
            // 如果内容为空，则跳出本次循环
            if len(cellValue) <= 0 {
                continue
            }
            if notEmptyCellNum == 0 {
                print("行号[", rIdx, "]\t")

            }
            notEmptyCellNum++
            print("列号[", cIdx, "]=", cellValue, "\t")
        }

        // 遍历完成当前行上的所有单元格以后的操作
        if notEmptyCellNum > 0 {
            // 当前行存在非空单元格
            println()
        } else {
            // 当前行的所有单元格均无内容
        }
    }
    // 3.能够正常执行到此，说明没有错误，返回 nil
    return nil
}

• 通过查询，使用strings.TrimSpace可以将字符串首位的空格字符消除掉
• 遇到单元格内容为空，则跳出当前循环，其后使用notEmptyCellNum可以记录非空单元格的数量，然后在当前行单元格全部遍历完成之后，再对空行与非空行进行区别处理
• 经此修改后，再运行程序，便只会打印出非空行的非空单元格信息

step_09：函数 analyzeSheet 中 确定每一行的类型

  在我们的数据字典中，每个sheet页代表一个业务模块，每个业务模块里，包含多个数据模型，每个数据模型表格，都包含标题行、表头行、内容行，数据模型开始之前，均会有一个空行。
具体格式如下：

具体代码如下：

// 对xlsx文件中的指定名称的sheet页逐行逐单元格进行遍历
func analyzeSheet(rows [][]string) error {

    // 1.合法性校验
    if len(rows) <= 0 {
        return errors.New("没有需要分析的行")
    }

    // 2.逐行逐单元格遍历前的准备工作
    currentRowType := 0 // 当前行的类型，0 空行 1 标题行（当前行有一个非空单元格时） 2 表头行 或 内容行（当前行有一个以上非空单元格时）
    prevRowType := 0    // 上一行的类型，0 空行 1 标题行（当前行有一个非空单元格时） 2 表头行 或 内容行（当前行有一个以上非空单元格时）
    nextRowType := 0    // 下一行的类型，0 空行 或 标题行（当前行是空行时） 1 表头行（当前行为标题行时） 2 内容行（当前行为表头行或内容行时）

    // 3.逐行遍历
    for _, row := range rows {

        // 3.1.逐单元格遍历前的准备工作
        notEmptyCellNum := 0 // 当前行非空单元格的数量
        currentRowType = 0   // 初始化当前行类型为默认值 0 即 空行

        // 3.2.遍历当前行上的所有单元格
        for cIdx, colCell := range row {
            // 3.2.1.去掉单元格内容的首尾空白字符
            cellValue := strings.TrimSpace(colCell)
            // 3.2.2.如果内容为空，则跳出本次循环
            if len(cellValue) <= 0 {
                continue
            }

            // 3.2.3.如果内容不为空，则进行数据处理（prevRowType 是真正的上一行的类型，nextRowType是在最后计算的，在此处使用，实际上就代表当前行的类型，是推断值）
            if nextRowType == 1 && prevRowType == 1 {
                // 3.2.3.1.当前行是表头行，且，上一行是标题行
                print("[表头行]列号[", cIdx, "]=", cellValue, "\t")
            } else if nextRowType == 2 && prevRowType == 2 {
                // 3.2.3.2.当前行是内容行，且，上一行是表头行或内容行
                print("[内容行]列号[", cIdx, "]=", cellValue, "\t")
            } else if nextRowType == 0 && prevRowType == 0 {
                // 3.2.3.3.当前行是空行或标题行（此处不可能是空行，因为这里是内容不为空时才能执行到，则当前行只能是标题行）
                print("[标题行]列号[", cIdx, "]=", cellValue, "\t")
            }

            // 3.2.4.更新当前行不为空的单元格的数量，后面会用来判断当前行是标题行（单元格合并之后只会有一个非空单元格）还是 表头行或内容行（单元格最多8个非空内容，最少5个）
            notEmptyCellNum++

            // 3.2.5.判断当前行的类型
            if notEmptyCellNum == 1 {
                // 当前行非空单元格数量为1时，可能是 标题行
                //      如果是 标题行，则后续当前行循环时要么是没有单元格了，要么就是空的单元格，是不会执行else的，也就保证了该值停留在本次的赋值中
                //      如果是 表头行或内容行，则后续当前行循环时，还会有分控单元格，会执行 else 逻辑，将该值覆盖掉的
                currentRowType = 1
            } else {
                // 当前行非空单元格数量不为1时，不为1，肯定就是比1大了，说明 是 表头行或内容行
                currentRowType = 2
            }
        }

        // 3.3.遍历完成当前行上的所有单元格以后的操作
        if notEmptyCellNum > 0 {
            // 3.3.1.当前行存在非空单元格
            if currentRowType == 1 {
                // 当前行为标题行时，下一行预测为表头行
                nextRowType = 1
            } else if currentRowType == 2 {
                // 当前行为表头行或内容行时，下一行 预测为 内容行
                nextRowType = 2
            } else {
                // 当前行为空行时，下一行为空行或标题行，其实这里永远不会执行，因为空行会在父id对应的else中
                nextRowType = 0
            }
            // 3.3.2.打印空行
            println()
        } else {
            // 3.3.2.当前行的所有单元格均无内容，即空行
            if prevRowType == 2 {
                // 当前行为空行，但上一行为表头行或内容行时，表示此时是一个数据字典的结束，而且肯定不是最后一个数据字典
                // 多打印几个换行，将内容隔开
                print("\n\n\n")
            }
            // 重置 当前行的类型 及 下一行的类型
            currentRowType = 0
            nextRowType = 0
        }

        // 3.4.当前行的循环结束，将当前行类型赋值给到上一行类型，因为接下来就是下一行的分析了
        prevRowType = currentRowType
    }

    // 4.能够正常执行到此，说明没有错误，返回 nil
    return nil
}

• 经此修改后，再运行程序，便会打印出非空行的非空单元格信息，且标识了所在行的类型
• 处理逻辑与数据字典的格式是一一对应的，如果换一种数据字典格式，则需要进行逻辑调整
• 上述程序中，在某行单元格遍历之初便可知道当前行的类型，意味着我们能找出每一个数据字典的开始，即当前行是标题行时
• 上述程序中，我们也能找出数据字典（除最后一个）的结束，即当前行是空行且上一行是表头行或内容行时
• 最后一个数据字典的结束，即当前行是内容行且是最后一行时，在上述程序中没有体现出来。因为上述程序在某行单元格遍历之后，对于非空行（非标题行），暂时只能判断出它可能是标题行或内容行中的某一种，没办法精确定性

step_10：函数 analyzeSheet 中 在遍历时将表格数据整理成结构化数据

  我们可以将不同格式的表格数据，转换成约定的结构化数据，这样，就可以将变化限定在 函数 analyzeSheet 内，进而保证后续处理程序的一致性。 对于结构化数据，java中有类来表示，而Go语言则提供了结构体。我们的数据字典针是MongoDB的，因此，我们设计了如下的结构体：

// 数据字典
type DataDict struct {
    Collection Collection       `json:"collection"`
    Fields     map[string]Field `json:"Fields"`
}

// 数据集合
type Collection struct {
    Name string `json:"name"`
    Desc string `json:"desc"`
}

// 数据字段
type Field struct {
    No           string `json:"no"`
    Name         string `json:"name"`
    Desc         string `json:"desc"`
    Type         string `json:"type"`
    IsCanBeNul   bool   `json:"isCanBeNul"`
    DefaultValue string `json:"defaultValue"`
    VerifyRule   string `json:"verifyRule"`
    Memo         string `json:"memo"`
}

对于数据的表现形式，自然还是想到了json，上述程序中的”json“字样便是为其准备的，网上搜索一番之后，选定了 jsoniter 最为json处理工具，网址是：https://github.com/json-iterator/go。

  接下来便可以在遍历过程中，在不同的步骤，将不同的数据转换到不同的结构上了，主要任务如下：

1. 标题行时，创建新的 Collection
2. 表头行时，收集表头信息，表头名称和列号
3. 内容行时，收集内容信息，字段内容和列号
4. 内容行是在表头行之后，因此，通过相同的列号，便能够将表头名称字段内容关联起来了
5. 内容行在所有非空单元格都遍历之后，就可以将暂存的一行字段内容转换为 Field 结构体了

  变化的代码部分如下：

// 将对应表头的内容设置到Field对应的属性上
func setFieldInfo(field *Field, title string, value string) error {
    switch title {
    case "序号":
        field.No = value
    case "名称":
        field.Name = value
    case "描述":
        field.Desc = value
    case "类型":
        field.Type = value
    case "是否可空":
        if value == "是" {
            field.IsCanBeNul = true
        } else {
            field.IsCanBeNul = false
        }
    case "校验规则":
        field.VerifyRule = value
    case "默认值":
        field.DefaultValue = value
    case "备注":
        field.Memo = value
    default:
        return errors.New("字段不需要该信息：" + title)
    }
    return nil
}

// 为集合扩充字段
func setCollectionField(headers map[int]string, field map[int]string) Field {
    var returnField Field
    for idx, info := range field {
        err := setFieldInfo(&returnField, headers[idx], info)
        if err != nil {
            println("error: ", err)
        }
    }
    return returnField
}

// 将数据字典加入到集合中
func addDataDictIntoSlice(collection Collection, fields map[string]Field, dataDictSlice []DataDict) []DataDict {
    dataDict := DataDict{
        Collection: collection,
        Fields:     fields,
    }
    return append(dataDictSlice, dataDict)
}

var Json = jsoniter.ConfigCompatibleWithStandardLibrary

// 把json打印出来
func printJSON(content interface{}) {
    c, err := Json.MarshalIndent(content, "", "    ")
    if err != nil {
        println("error: ", err)
    }
    println(string(c))
}

// 对xlsx文件中的指定名称的sheet页逐行逐单元格进行遍历
func analyzeSheet(rows [][]string) error {

    // 1.合法性校验
    if len(rows) <= 0 {
        return errors.New("没有需要分析的行")
    }

    // 2.逐行逐单元格遍历前的准备工作
    currentRowType := 0 // 当前行的类型，0 空行 1 标题行（当前行有一个非空单元格时） 2 表头行 或 内容行（当前行有一个以上非空单元格时）
    prevRowType := 0    // 上一行的类型，0 空行 1 标题行（当前行有一个非空单元格时） 2 表头行 或 内容行（当前行有一个以上非空单元格时）
    nextRowType := 0    // 下一行的类型，0 空行 或 标题行（当前行是空行时） 1 表头行（当前行为标题行时） 2 内容行（当前行为表头行或内容行时）

    maxRowIndex := len(rows) - 1 // 最大的行索引，索引从 0 开始

    var dataDictSlice []DataDict    // 数据字典集合
    var collection Collection       // 数据集合
    var fields map[string]Field     // 字段集合
    headers := make(map[int]string) // 表头集合

    // 3.逐行遍历
    for rIdx, row := range rows {

        // 3.1.逐单元格遍历前的准备工作
        notEmptyCellNum := 0              // 当前行非空单元格的数量
        currentRowType = 0                // 初始化当前行类型为默认值 0 即 空行
        fieldInfo := make(map[int]string) // 存储字段的信息

        // 3.2.遍历当前行上的所有单元格
        for cIdx, colCell := range row {
            // 3.2.1.去掉单元格内容的首尾空白字符
            cellValue := strings.TrimSpace(colCell)
            // 3.2.2.如果内容为空，则跳出本次循环
            if len(cellValue) <= 0 {
                continue
            }

            // 3.2.3.如果内容不为空，则进行数据处理（prevRowType 是真正的上一行的类型，nextRowType是在最后计算的，在此处使用，实际上就代表当前行的类型，是推断值）
            if nextRowType == 1 && prevRowType == 1 {
                // 3.2.3.1.当前行是表头行，且，上一行是标题行，这时需要收集的是：字段名与列号信息
                print("[表头行]列号[", cIdx, "]=", cellValue, "\t")
                headers[cIdx] = colCell
            } else if nextRowType == 2 && prevRowType == 2 {
                // 3.2.3.2.当前行是内容行，且，上一行是表头行或内容行，这时需要收集的是：某个字段的某一个信息（如字段名）与列号信息
                print("[内容行]列号[", cIdx, "]=", cellValue, "\t")
                fieldInfo[cIdx] = colCell
            } else if nextRowType == 0 && prevRowType == 0 {
                // 3.2.3.3.当前行是空行或标题行（此处不可能是空行，因为这里是内容不为空时才能执行到，则当前行只能是标题行），这时需要收集的是：数据集合的信息
                print("[标题行]列号[", cIdx, "]=", cellValue, "\t")
                collectionInfo := strings.Split(cellValue, "|")
                collection = Collection{
                    Name: collectionInfo[0],
                    Desc: collectionInfo[1],
                }
            }

            // 3.2.4.更新当前行不为空的单元格的数量，后面会用来判断当前行是标题行（单元格合并之后只会有一个非空单元格）还是 表头行或内容行（单元格最多8个非空内容，最少5个）
            notEmptyCellNum++

            // 3.2.5.判断当前行的类型
            if notEmptyCellNum == 1 {
                // 当前行非空单元格数量为1时，可能是 标题行
                //      如果是 标题行，则后续当前行循环时要么是没有单元格了，要么就是空的单元格，是不会执行else的，也就保证了该值停留在本次的赋值中
                //      如果是 表头行或内容行，则后续当前行循环时，还会有分控单元格，会执行 else 逻辑，将该值覆盖掉的
                currentRowType = 1
            } else {
                // 当前行非空单元格数量不为1时，不为1，肯定就是比1大了，说明 是 表头行或内容行
                currentRowType = 2
            }
        }

        // 3.3.遍历完成当前行上的所有单元格以后的操作
        if notEmptyCellNum > 0 {
            // 3.3.1.当前行存在非空单元格
            if currentRowType == 1 {
                // 当前行为标题行时，下一行预测为表头行
                nextRowType = 1
                fields = make(map[string]Field)
            } else if currentRowType == 2 {
                // 当前行为表头行或内容行时，下一行 预测为 内容行
                nextRowType = 2
                // 如果 fieldInfo 中没有内容，表明当前行肯定是表头行；如果 fieldInfo 中有内容，表明本行肯定是内容行，需要将每个单元格收集到的信息转换成字段对象并加入到 fields 中
                if len(fieldInfo) > 0 {
                    field := setCollectionField(headers, fieldInfo)
                    fields[field.No] = field
                    // 如果，当前行是内容行 且 是最后一行时，表示此时是最后一个数据字典的结束，将数据字典组装好之后加入到 切片 中
                    if rIdx == maxRowIndex {
                        dataDictSlice = addDataDictIntoSlice(collection, fields, dataDictSlice)
                    }
                }
            } else {
                // 当前行为空行时，下一行为空行或标题行，其实这里永远不会执行，因为空行会在父id对应的else中
                nextRowType = 0
            }
            // 3.3.2.打印空行
            println()
        } else {
            // 3.3.2.当前行的所有单元格均无内容，即空行
            if prevRowType == 2 {
                // 当前行为空行，但上一行为表头行或内容行时，表示此时是一个数据字典的结束，而且肯定不是最后一个数据字典
                // 多打印几个换行，将内容隔开
                print("\n\n\n")
                // 组装好数据字典，将数据字典加入到 切片 中
                dataDictSlice = addDataDictIntoSlice(collection, fields, dataDictSlice)
            }
            // 重置 当前行的类型 及 下一行的类型
            currentRowType = 0
            nextRowType = 0
        }

        // 3.4.当前行的循环结束，将当前行类型赋值给到上一行类型，因为接下来就是下一行的分析了
        prevRowType = currentRowType
    }

    // 4.打印转换后的json数据
    printJSON(dataDictSlice)
    // 4.能够正常执行到此，说明没有错误，返回 nil
    return nil
}

在函数 analyzeSheet 中，还用到了其他几个函数，如 setFieldInfo、setCollectionField、addDataDictIntoSlice、printJSON。分别涉及到了switch的用法、map的遍历、slice的使用、slice转json等知识点

step_11：将转换后的json文本输出到文件中

  通过搜索，参考了 https://www.jianshu.com/p/30ac7eb57bce 上的文章，使用 ioutil 来实现文件输出，具体改动部分如下：

// 把json打印出来
func printJSON(content interface{}) {
    c, err := Json.MarshalIndent(content, "", "    ")
    if err != nil {
        println("error: ", err)
    }
    println(string(c))
    WriteWithIoutil("schema.json", string(c))
}
// 写入文件
func WriteWithIoutil(name, content string) {
    data := []byte(content)
    if ioutil.WriteFile(name, data, 0644) == nil {
        println("写入文件成功:")
    }
}

四、总结

  上述步骤，从环境配置开始，到读取excel并逐行逐单元格进行分析，到最后将转换后的json数据写入文件，记录了我学习Go语言的起始过程。代码比较粗糙，而且，Go语言的很多特性包括优势也远远没有在此体现出来。学路漫漫，在此与对Go语言感兴趣的初学者共勉，希望大家在学与用的过程中，能够逐步的掌握这门神兵利器。