如何在Go语言中使用空白标识符进行循环迭代

package main

import (
    "flag"
    "fmt"
    "os"
    "path/filepath"
    "sync"
)

var walkend chan bool
var walkerrs chan error
var dupes map[string][]string
var mu sync.Mutex

func main() {
    flag.Parse()

    walkend = make(chan bool, len(flag.Args()))
    walkerrs = make(chan error, len(flag.Args()))
    dupes = make(map[string][]string)

    var wg sync.WaitGroup
    wg.Add(len(flag.Args()))

    for _, arg := range flag.Args() {
        go func(arg string) {
            defer wg.Done()
            err := filepath.Walk(arg, func(path string, info os.FileInfo, err error) error {
                if err != nil {
                    return err
                }
                if !info.Mode().IsRegular() {
                    return nil
                }

                content, err := os.ReadFile(path)
                if err != nil {
                    return err
                }
                hash := string(content) // In a real application, use a proper hash function.

                mu.Lock()
                dupes[hash] = append(dupes[hash], path)
                mu.Unlock()

                return nil
            })
            if err != nil {
                walkerrs <- err
            }
            walkend <- true
        }(arg)
    }

    go func() {
        wg.Wait()
        close(walkend)
        close(walkerrs)
    }()

    for _ = range flag.Args() { // Corrected line
        select {
        case <-walkend:
            // Walk completed successfully
        case err := <-walkerrs:
            fmt.Fprintf(os.Stderr, "Error during walk: %v\n", err)
            os.Exit(1)
        }
    }

    for hash, paths := range dupes {
        if len(paths) > 1 {
            fmt.Printf("Duplicate files with hash %s:\n", hash)
            for _, path := range paths {
                fmt.Printf("  - %s\n", path)
            }
        }
    }
}