我们在日常工作中经常会更新配置文件，相对来说配置文件比较简单，常见的有 “key = value”的模式，以下两个例子，均是实现key/value的更新。

第一个：更新简单的key/value配置文件。

针对类似如下的配置文件：

  1. # Sample Conf
  3. # default log file
  4. log = /var/log/sample.log
  6. # pid file
  7. pid-file = /var/run/sample.pid

函数：updateConfigFileA
参数:

  • filePath - 配置文件全路径
  • args - 允许同时更新多个 key/value pair，通过map的形式传入

这里使用了 io/ioutil 提供的封装函数读写文件，非常方便。
ioutil.ReadFile 将会一次性的读入所有数据，如果源文件不大的话，没有任何问题，反过来源文件太大的话，将占用很大的内存，特别是并发环境下读取的话，占用的内存就非常巨大了。这时候可以考虑用 io.Copy，它 copy 数据从一个 Reader接口，到Writer接口。io.Copy 使用固定的32KB buffer 来copy 数据，无论源文件多少，每次都是固定的32KB，不会大量的占用内存。我们可以定制专门的 Reader 和 Writer 来处理 copy 的数据。
大部分场景下，配置文件都不是很大，基本可以忽略 ioutil.ReadFile 的性能问题。

具体代码如下，

  1. func updateConfigFileA(filePath string, args map[string]string) error {
  2.         input, err := ioutil.ReadFile(filePath)
  3.         if err != nil {
  4.                 return err
  5.         }
  7.         lines := strings.Split(string(input), "\n")
  8.         for k, v := range args {
  9.                 if len(k) == 0 {
  10.                         continue
  11.                 }
  13.                 hit := false
  14.                 for i, line := range lines {
  15.                         if strings.HasPrefix(strings.TrimSpace(line), k) {
  16.                                 lines[i] = fmt.Sprintf("%s = %s", k, v)
  17.                                 hit = true
  18.                         }
  19.                 }
  21.                 if !hit {
  22.                         lines = append(lines, fmt.Sprintf("%s = %s", k, v))
  23.                 }
  24.         }
  26.         output := strings.Join(lines, "\n")
  27.         if err = ioutil.WriteFile(filePath, []byte(output), 0644); err != nil {
  28.                 return err
  29.         }
  31.         return nil
  32. }

ioutil.WriteFile() 接受三个参数

  • 待写入的文件
  • 待写入的数据
  • 待写入文件的 Permission mode
    如果待写入的文件不存在的话，才用到这个参数，用其生成新文件

第二个：更新带有分段的key/value配置文件。

针对类似如下的配置文件：

  1. # Sample Conf
  3. [System]
  4.   # default log file
  5.   log = /var/log/sample.log
  7.   # pid file
  8.   pid-file = /var/run/sample.pid
  10. [Home]
  11.   address = "City|Street|Home-Block"  # this is address
  13.   # this is phone number
  14.   phone = 1234567890
  16.   # this is email
  17.   email = sample1@sample.com
  18.   email = sample2@sample.com
  19.   email = sample3@sample.com

函数：updateConfigFileB
参数:

  • filePath - 配置文件全路径
  • section - 段标识，例如System/Home，不能为空
  • key/value - 键值对，不能为空
  • op - 操作码，有三个取值，
    • 0：更新键值对，针对key唯一的场景，更新其value，例如 Home中 addres 和 phone 字段。
    • 1：更新键值对，针对key不唯一的场景，增加键值对，例如 Home 中的 email 字段。
    • -1：删除键所对应的字段。（可以改代码变成删除键值对）

样例：

  1. 删除 System 中的 log 字段
    updateConfigFileB(“pathToFile”, “System”, “log”, “”, -1)

  2. 更新 Home 中的 phone 字段
    updateConfigFileB(“pathToFile”, “home”, “phone”, “0987654321”, 0)

  3. 更新 Home 中的 email 字段，添加一个新的键值对
    updateConfigFileB(“pathToFile”, “Home”, “email”, “sample4@sample.com”, 1)

  4. 增加新的分段 Office，及其字段 address
    updateConfigFileB(“pathToFile”, “Office”, “address”, “City|Street|Office-Block”, 0)

具体代码如下，

  1. func updateConfigFileC(filePath string, section, key, value string, op int) error {
  2.         if len(section) == 0 || len(key) == 0 {
  3.                 return errors.New("any of section and key cannot be none")
  4.         }
  6.         section = strings.TrimSpace(section)
  7.         key = strings.TrimSpace(key)
  9.         file, err := os.OpenFile(filePath, os.O_RDWR, 0644)
  10.         if err != nil {
  11.                 return err
  12.         }
  14.         defer file.Close()
  16.         var (
  17.                 buffer            bytes.Buffer
  18.                 writeBufferToFile = false
  19.                 hasSection        = false
  20.                 scanner           = bufio.NewScanner(file)
  21.                 preWhiteSpaces    = strings.Repeat(" ", 4) // how many white spaces left
  22.                 kvLine            = fmt.Sprintf("%s%s = %s", preWhiteSpaces, key, value)
  23.                 patSection        = fmt.Sprintf("^\\s*\\[\\s*(?i:%s)\\s*\\]\\s*#?", section)
  24.                 patKV             = fmt.Sprintf("(^\\s*%s\\s*=)\\s*(\\S[^#]*)", key)
  25.                 regKV             = regexp.MustCompile(patKV)
  26.                 regSection        = regexp.MustCompile(`^\s*\[\s*(\S.*)\s*\]\s*#?`)
  27.         )
  29.         handler := func(orgLine string) ([]string, bool) {
  30.                 var (
  31.                         opUpd         = false
  32.                         hasUpd        = false
  33.                         isNextSection = false
  34.                         lines         = []string{orgLine}
  35.                 )
  37.                 for scanner.Scan() {
  38.                         line := scanner.Text()
  40.                         smSection := regSection.FindStringSubmatch(line)
  41.                         if len(smSection) > 1 && !strings.EqualFold(smSection[1], section) {
  42.                                 isNextSection = true
  43.                                 break
  44.                         }
  46.                         switch op {
  47.                         case -1: // delete the pair of key and value
  48.                                 if regKV.FindString(line) != "" {
  49.                                         hasUpd = true
  50.                                         continue
  51.                                 }
  53.                         case 0: // update
  54.                                 smKV := regKV.FindStringSubmatch(line)
  55.                                 if len(smKV) > 2 {
  56.                                         opUpd = true
  58.                                         if strings.TrimSpace(smKV[2]) != strings.TrimSpace(value) {
  59.                                                 rLine := regKV.ReplaceAllString(line, "$1 "+value+" ")
  60.                                                 lines = append(lines, rLine)
  61.                                                 hasUpd = true
  62.                                                 continue
  63.                                         }
  64.                                 }
  66.                         case 1: // multiple keys
  67.                                 smKV := regKV.FindStringSubmatch(line)
  68.                                 if len(smKV) > 2 {
  69.                                         if strings.TrimSpace(smKV[2]) == strings.TrimSpace(value) {
  70.                                                 opUpd = true
  71.                                         }
  72.                                 }
  73.                         }
  75.                         lines = append(lines, line)
  76.                 }
  78.                 if !opUpd && op != -1 {
  79.                         lines = append(lines, kvLine)
  80.                         for i := len(lines) - 2; i > 0; i-- {
  81.                                 if isNull, _ := regexp.MatchString("^\\s*$", lines[i]); isNull {
  82.                                         lines[i], lines[i+1] = lines[i+1], lines[i]
  83.                                         continue
  84.                                 }
  86.                                 break
  87.                         }
  89.                         hasUpd = true
  90.                 }
  92.                 if isNextSection {
  93.                         lines = append(lines, scanner.Text())
  94.                 }
  96.                 return lines, hasUpd
  97.         }
  99.         for scanner.Scan() {
  100.                 orgLine := scanner.Text()
  102.                 matched, _ := regexp.MatchString(patSection, orgLine)
  103.                 if matched {
  104.                         var updLines []string
  105.                         updLines, writeBufferToFile = handler(orgLine)
  106.                         if updLines != nil && writeBufferToFile {
  107.                                 for i := range updLines {
  108.                                         buffer.WriteString(updLines[i] + "\n")
  109.                                 }
  110.                         }
  112.                         hasSection = true
  113.                         continue
  114.                 }
  116.                 buffer.WriteString(orgLine + "\n")
  117.         }
  119.         if !hasSection && op != -1 {
  120.                 buffer.WriteString("\n[" + section + "]\n")
  121.                 buffer.WriteString(kvLine + "\n")
  122.                 writeBufferToFile = true
  123.         }
  125.         if writeBufferToFile {
  126.                 if _, err := file.Seek(0, 0); err != nil {
  127.                         return err
  128.                 }
  130.                 if err := file.Truncate(0); err != nil {
  131.                         return err
  132.                 }
  134.                 if _, err := file.Write(buffer.Bytes()); err != nil {
  135.                         return err
  136.                 }
  137.         }
  139.         return nil
  140. }

参考链接：