基于Go语言实现一个目录树打印工具

type DirectoryPrinter struct {
    rootDir       string      // 根目录路径
    showHidden    bool        // 是否显示隐藏文件
    currentDepth  int         // 当前递归深度
    maxDepth      int         // 最大深度限制
    indentSymbol  string      // 缩进符号（4个空格）
    folderSymbol  string      // 文件夹图标
    fileSymbol    string      // 文件图标
    output        []string    // 输出内容收集
    showConnector bool        // 是否显示连接线
}

sort.Slice(filteredEntries, func(i, j int) bool {
    if filteredEntries[i].IsDir() != filteredEntries[j].IsDir() {
        return filteredEntries[i].IsDir()
    }
    return filteredEntries[i].Name() < filteredEntries[j].Name()
})

if dp.showConnector {
    isLast := index == total-1
    connector := "├── "
    if isLast {
        connector = "└── "
    }
    return fmt.Sprintf("%s%s📁 %s\n", prefix, connector, entry.Name())
}

if dp.maxDepth > 0 && dp.currentDepth >= dp.maxDepth {
    return nil
}

directory_printer

directory_printer --show-hidden --max-depth 2

directory_printer --output-file project_tree.txt --show-connector

rootName := filepath.Base(rootDir)
if rootName == "." {
    // 获取当前工作目录的绝对路径
    absPath, err := filepath.Abs(rootDir)
    if err != nil {
        rootName = "current_directory"
    } else {
        rootName = filepath.Base(absPath)
    }
}
printer.output = append(printer.output, fmt.Sprintf("📂 %s\n", rootName))

// 保存到文件
if *outputFile != "" {
    err = saveToFile(*outputFile, printer.output)
}

// 复制到剪贴板
if *copyClipBoard {
    content := strings.Join(printer.output, "")
    err = clipboard.WriteAll(content)
}

​​​​​​​// 控制台输出
fmt.Println("\n=== Directory Structure ===")
for _, line := range printer.output {
    fmt.Print(line)
}

childPrinter := &DirectoryPrinter{
    rootDir:       filepath.Join(dp.rootDir, entry.Name()),
    showHidden:    dp.showHidden,
    currentDepth:  dp.currentDepth + 1,
    maxDepth:      dp.maxDepth,
    indentSymbol:  dp.indentSymbol,
    folderSymbol:  dp.folderSymbol,
    fileSymbol:    dp.fileSymbol,
    output:        dp.output,
    showConnector: dp.showConnector,
}
if err := childPrinter.printDirectory(); err != nil {
    return err
}
dp.output = childPrinter.output

package main

import (
	"flag"
	"fmt"
	"os"
	"path/filepath"
	"sort"
	"strings"

	"github.com/atotto/clipboard"
)

type DirectoryPrinter struct {
	rootDir       string
	showHidden    bool
	currentDepth  int
	maxDepth      int
	indentSymbol  string
	folderSymbol  string
	fileSymbol    string
	output        []string
	showConnector bool // 新增字段控制是否显示连接线
}

func (dp *DirectoryPrinter) printDirectory() error {
	// 检查是否超过最大深度
	if dp.maxDepth > 0 && dp.currentDepth >= dp.maxDepth {
		return nil
	}

	entries, err := os.ReadDir(dp.rootDir)
	if err != nil {
		return err
	}

	// 过滤隐藏文件
	var filteredEntries []os.DirEntry
	for _, entry := range entries {
		if dp.showHidden || !strings.HasPrefix(entry.Name(), ".") {
			filteredEntries = append(filteredEntries, entry)
		}
	}

	// 按类型（目录优先）和名称排序
	sort.Slice(filteredEntries, func(i, j int) bool {
		// 首先按类型排序（目录在前）
		if filteredEntries[i].IsDir() != filteredEntries[j].IsDir() {
			return filteredEntries[i].IsDir()
		}
		// 同类型按名称排序
		return filteredEntries[i].Name() < filteredEntries[j].Name()
	})

	total := len(filteredEntries)
	for i, entry := range filteredEntries {
		prefix := strings.Repeat(dp.indentSymbol, dp.currentDepth)
		var line string
		if entry.IsDir() {
			line = dp.buildFolderLine(prefix, i, total, entry)
		} else {
			line = dp.buildFileLine(prefix, i, total, entry)
		}
		dp.output = append(dp.output, line)

		// 递归处理子文件夹
		if entry.IsDir() {
			childPrinter := &DirectoryPrinter{
				rootDir:       filepath.Join(dp.rootDir, entry.Name()),
				showHidden:    dp.showHidden,
				currentDepth:  dp.currentDepth + 1,
				maxDepth:      dp.maxDepth,
				indentSymbol:  dp.indentSymbol,
				folderSymbol:  dp.folderSymbol,
				fileSymbol:    dp.fileSymbol,
				output:        dp.output,
				showConnector: dp.showConnector,
			}
			if err := childPrinter.printDirectory(); err != nil {
				return err
			}
			dp.output = childPrinter.output
		}
	}

	return nil
}

func (dp *DirectoryPrinter) buildFolderLine(prefix string, index, total int, entry os.DirEntry) string {
	if dp.showConnector {
		isLast := index == total-1
		connector := "├── "
		if isLast {
			connector = "└── "
		}
		return fmt.Sprintf("%s%s📁 %s\n", prefix, connector, entry.Name())
	}
	return fmt.Sprintf("%s📁 %s\n", prefix, entry.Name())
}

func (dp *DirectoryPrinter) buildFileLine(prefix string, index, total int, entry os.DirEntry) string {
	if dp.showConnector {
		isLast := index == total-1
		connector := "├── "
		if isLast {
			connector = "└── "
		}
		return fmt.Sprintf("%s%s📄 %s\n", prefix, connector, entry.Name())
	}
	return fmt.Sprintf("%s📄 %s\n", prefix, entry.Name())
}

func usage() {
	fmt.Println("Usage: directory_printer [OPTIONS] [PATH]")
	fmt.Println("\nOptions:")
	fmt.Println("  --show-hidden               Include hidden files and directories")
	fmt.Println("  --output-file <file_path>   Save the directory structure to a file")
	fmt.Println("  --copy-ClipBoard            Copy Directory structure to clipboard")
	fmt.Println("  --max-depth <number>        Maximum directory depth to display (0 for all levels, 1 for root only)")
	fmt.Println("  --show-connector            Show connector characters (├── and └──)")
	fmt.Println("  --help                      Display this help message")
	fmt.Println("\nExample:")
	fmt.Println("  directory_printer --show-hidden --max-depth 2 --output-file output.txt /path/to/directory")
}

func isDirectory(path string) bool {
	fileInfo, err := os.Stat(path)
	if err != nil {
		return false
	}
	return fileInfo.IsDir()
}

func saveToFile(filePath string, content []string) error {
	file, err := os.Create(filePath)
	if err != nil {
		return err
	}
	defer file.Close()

	for _, line := range content {
		if _, err := file.WriteString(line); err != nil {
			return err
		}
	}

	return nil
}

func main() {
	showHidden := flag.Bool("show-hidden", false, "Include hidden files and directories")
	outputFile := flag.String("output-file", "", "Save the directory structure to a file")
	copyClipBoard := flag.Bool("copy-ClipBoard", true, "Copy Directory structure to clipboard")
	maxDepth := flag.Int("max-depth", 0, "Maximum directory depth to display (0 for all levels, 1 for root only)")
	showConnector := flag.Bool("show-connector", false, "Show connector characters (├── and └──)")
	help := flag.Bool("help", false, "Display this help message")
	flag.Parse()

	if *help {
		usage()
		os.Exit(0)
	}

	var rootDir string
	if len(flag.Args()) == 0 {
		rootDir = "."
	} else {
		rootDir = flag.Arg(0)
	}

	if !isDirectory(rootDir) {
		fmt.Printf("Error: %s is not a valid directory\n", rootDir)
		os.Exit(1)
	}

	printer := &DirectoryPrinter{
		rootDir:       rootDir,
		showHidden:    *showHidden,
		currentDepth:  0,
		maxDepth:      *maxDepth,
		indentSymbol:  "    ", // 使用4个空格作为视觉缩进
		folderSymbol:  "",
		fileSymbol:    "",
		output:        []string{},
		showConnector: *showConnector,
	}

	rootName := filepath.Base(rootDir)
	if rootName == "." {
		// 获取当前工作目录的绝对路径
		absPath, err := filepath.Abs(rootDir)
		if err != nil {
			rootName = "current_directory"
		} else {
			rootName = filepath.Base(absPath)
		}
	}
	printer.output = append(printer.output, fmt.Sprintf("📂 %s\n", rootName))
	// 增加根目录的缩进
	printer.currentDepth = 1

	err := printer.printDirectory()
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		os.Exit(1)
	}

	if *outputFile != "" {
		err = saveToFile(*outputFile, printer.output)
		if err != nil {
			fmt.Printf("Failed to save to file: %v\n", err)
			os.Exit(1)
		}
		fmt.Printf("Directory structure saved to: %s\n", *outputFile)
	}
	if *copyClipBoard {
		content := strings.Join(printer.output, "")
		err = clipboard.WriteAll(content)
		if err != nil {
			fmt.Printf("Failed to copy to clipboard: %v\n", err)
		} else {
			fmt.Println("Directory structure copied to clipboard")
		}
	}

	fmt.Println("\n=== Directory Structure ===")
	for _, line := range printer.output {
		fmt.Print(line)
	}
}