XML file parsing in Go

Question

Below is a piece of code that is responsible for serializing files. ZL_LIST and PERS_LIST are XML file structs, I have not shown them here to save space.

Please check my code.

package parser
import (
 "encoding/xml"
 "fmt"
 "golang.org/x/text/encoding/charmap"
 "io"
 "io/ioutil"
 "os"
 "path/filepath"
 "sync"
)
type Files struct {
 Name string
 PathZipFile string
 PathUnzipFile string
}
type nameMap map[string]bool
func (ZL_LIST) Parse(FilesName []*Files) {
 unzipPath, err := filepath.Abs("tmp")
 files, err := ioutil.ReadDir(unzipPath)
 f := make([]*Files, 0)
 for _, file := range files {
 fileZip := new(Files)
 if !file.IsDir() && file.Name()[:1] != "." {
 fileZip.Name = file.Name()
 fileZip.PathUnzipFile = filepath.Join(unzipPath, file.Name())
 f = append(f, fileZip)
 }
 }
 if err != nil {
 fmt.Printf("[ERROR] Error retrieving files %v", err)
 }
 names := make(nameMap, 1)
 var wg sync.WaitGroup
 var countHmLmFiles int = -1
 var countHmFiles int = 0
 var countLmFiles int = 0
 var file *Files
 for countHmLmFiles, file = range f {
 wg.Add(1)
 go func(filename *Files) {
 parseHmLm(filename, &countHmFiles, &countLmFiles, &names)
 wg.Done()
 }(file)
 }
 wg.Wait()
 fmt.Printf("[INFO] Read %d files from them HM files %d and LM files %d ", countHmLmFiles+1, countHmFiles, countLmFiles)
}
func parseHmLm(filename *Files, countHmFiles *int, countLmFiles *int, names *nameMap) {
 fmt.Println("[INFO] считывается файл ", filename.Name, " с заголовком ", filename.Name[:2])
 xmlFile, err := os.Open(filepath.Join(filename.PathUnzipFile))
 if err != nil {
 fmt.Printf("[ERROR] Cannot open file %e \n", err)
 }
 defer xmlFile.Close()
 switch filename.Name[:2] {
 case "HM":
 (*names)[filename.Name] = true
 (*countHmFiles) += 1
 var hFile ZL_LIST
 decoder := xml.NewDecoder(xmlFile)
 decoder.CharsetReader = charset
 err := decoder.Decode(&hFile)
 if err != nil {
 fmt.Errorf("[ERROR] Cannot decode file %e", err)
 }
 case "LM":
 (*countLmFiles) += 1
 var lFile PERS_LIST
 decoder := xml.NewDecoder(xmlFile)
 decoder.CharsetReader = charset
 err := decoder.Decode(&lFile)
 if err != nil {
 fmt.Errorf("[ERROR] Cannot decode file %e", err)
 }
 }
}
func charset(charset string, input io.Reader) (io.Reader, error) {
 switch charset {
 case "windows-1251":
 return charmap.Windows1251.NewDecoder().Reader(input), nil
 default:
 return nil, fmt.Errorf("unknown charset: %s", charset)
 }
}

Calling function

package api
 import (
 "net/http"
 "github.com/go-chi/render"
 "../../store/parser"
 "fmt"
 "path/filepath"
)
 func (s *Rest) parse(w http.ResponseWriter, r *http.Request) {
 uploadPath, err := filepath.Abs("./upload/")
 if err != nil {
 fmt.Printf("[ERROR] can not find the specified path %e", err)
 }
 unzipPath, err := filepath.Abs("./tmp")
 if err != nil {
 fmt.Printf("[ERROR] can not find the specified path %e", err)
 }
 p := parser.Files{}
 filesName := p.GetFileName(uploadPath, unzipPath)
 p.UnzipFiles(filesName, unzipPath)
 ...
 ...

Answer 1

Variables

Go has two ways of declaring new variables: a var notation and a short one. It's preferable to use the short one:

wg := sync.WaitGroup{}
countHmLmFiles := -1
countHmFiles := 0
countLmFiles := 0

Also when declaring lots of global variables in the package block you may use block notation:

var (
 a int = 1
 b string = "foo"
)

You can declare variables directly in the for loop:

for countHmLmFiles, file := range f {
 // countHmLmFiles and file will be visible only here
}

This way their scope will be limited to for body.

Maps in Go

You've created a map with make:

names := make(nameMap, 1)

I don't see a point in creating a map for a single element. Also when you don't need the size argument in make you may simply write names := nameMap{}.

No need pass maps with pointer. Maps and slices are already a reference type and may be passed directly by value. It won't issue a full copy.

Error handling

You've missed lots of error checks. Ideally every error must be handled in place. Otherwise use _ to ignore it and make a comment to be specific on this as it looks like a broken code.

The switch lacks the default case. It worth adding it to catch other possible values of filename.Name[:2].

Also don't forget to add terminating \n to fmt.Printf to separate log messages.