Golang中检查全局可写文件的最有效方法

在Go中检查全局可写文件时，可以通过并发和优化文件模式检查来提高性能。以下是改进后的实现：

package main

import (
	"io/fs"
	"os"
	"path/filepath"
	"sync"
)

func findWorldWritableFiles(root string, skipDirs []string) ([]string, error) {
	var (
		files []string
		mu    sync.Mutex
		wg    sync.WaitGroup
	)

	skipSet := make(map[string]struct{})
	for _, dir := range skipDirs {
		skipSet[dir] = struct{}{}
	}

	err := filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error {
		if err != nil {
			return nil
		}

		if d.IsDir() {
			if _, skip := skipSet[path]; skip {
				return filepath.SkipDir
			}
			return nil
		}

		if !d.Type().IsRegular() {
			return nil
		}

		wg.Add(1)
		go func(p string, entry fs.DirEntry) {
			defer wg.Done()

			info, err := entry.Info()
			if err != nil {
				return
			}

			mode := info.Mode()
			if mode&0002 != 0 {
				mu.Lock()
				files = append(files, p)
				mu.Unlock()
			}
		}(path, d)

		return nil
	})

	wg.Wait()
	return files, err
}

func main() {
	skipDirs := []string{"/proc", "/run", "/sys/fs", "/selinux"}
	files, err := findWorldWritableFiles("/", skipDirs)
	if err != nil {
		panic(err)
	}
}

关键改进：

1. 使用位运算检查权限：直接使用mode&0002 != 0检查全局写权限，避免正则表达式和字符串操作的开销。

2. 并发处理：对每个文件启动goroutine进行权限检查，利用多核CPU。

3. 使用sync.Map优化并发写入（替代方案）：

func findWorldWritableFilesConcurrent(root string) ([]string, error) {
	var fileMap sync.Map
	var wg sync.WaitGroup

	err := filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error {
		if err != nil || !d.Type().IsRegular() {
			return nil
		}

		wg.Add(1)
		go func(p string, entry fs.DirEntry) {
			defer wg.Done()
			
			info, err := entry.Info()
			if err != nil {
				return
			}
			
			if info.Mode()&0002 != 0 {
				fileMap.Store(p, true)
			}
		}(path, d)
		
		return nil
	})

	wg.Wait()
	
	var files []string
	fileMap.Range(func(key, value interface{}) bool {
		files = append(files, key.(string))
		return true
	})
	
	return files, err
}

1. 使用工作池控制并发度：

func findWorldWritableFilesWithPool(root string, workers int) ([]string, error) {
	paths := make(chan string, 1000)
	results := make(chan string, 1000)
	var wg sync.WaitGroup

	for i := 0; i < workers; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for path := range paths {
				info, err := os.Stat(path)
				if err == nil && info.Mode()&0002 != 0 {
					results <- path
				}
			}
		}()
	}

	go func() {
		filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error {
			if err == nil && d.Type().IsRegular() {
				paths <- path
			}
			return nil
		})
		close(paths)
	}()

	go func() {
		wg.Wait()
		close(results)
	}()

	var files []string
	for file := range results {
		files = append(files, file)
	}
	
	return files, nil
}

这些改进通过并发处理和优化权限检查，可以显著减少在大文件系统上的扫描时间。