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

殷含玉

在日常开发中，我们经常需要可视化项目的目录结构。无论是编写文档、分享项目结构，还是单纯了解代码布局，一个清晰的目录树展示都至关重要。今天我将介绍一款用Go语言开发的目录树打印工具，它不仅能生成美观的目录结构图，还提供多种实用功能！

功能亮点

多层级展示：支持自定义深度限制
隐藏文件处理：可选显示隐藏文件/文件夹
多种输出方式：控制台打印、保存文件、复制到剪贴板
美观可视化：使用emoji图标标识不同类型
灵活连接线：可选的树形连接线展示
智能排序：目录优先，按名称排序

技术实现解析


核心数据结构

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

复制代码

关键算法逻辑

1.文件排序策略：
目录优先于文件
相同类型按名称升序排列

1. sort.Slice(filteredEntries, func(i, j int) bool {
   
2.     if filteredEntries[i].IsDir() != filteredEntries[j].IsDir() {
   
3.         return filteredEntries[i].IsDir()
   
4.     }
   
5.     return filteredEntries[i].Name() < filteredEntries[j].Name()
   
6. })

复制代码

2.连接线生成逻辑：
非最后一项：├──
最后一项：└──

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

复制代码

3.递归深度控制：

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

复制代码

使用指南


命令行参数

参数说明示例--show-hidden显示隐藏文件--show-hidden--output-file保存到文件--output-file tree.txt--copy-ClipBoard复制到剪贴板--copy-ClipBoard--max-depth设置最大深度--max-depth 3--show-connector显示连接线--show-connector--help显示帮助--help
使用示例

基本用法（显示当前目录结构）：

1. directory_printer

复制代码

显示隐藏文件并限制深度：

1. directory_printer --show-hidden --max-depth 2

复制代码

保存到文件并显示连接线：

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

复制代码

输出示例

1. 📂 my-project    📁 src        📁 controllers        📁 models        📁 views    📁 config    📁 public        📁 css        📁 js        📁 images    📄 README.md    📄 .gitignore    📄 go.mod

复制代码

带连接线版本：

1. 📂 my-project├── 📁 src│   ├── 📁 controllers│   ├── 📁 models│   └── 📁 views├── 📁 config├── 📁 public│   ├── 📁 css│   ├── 📁 js│   └── 📁 images├── 📄 README.md├── 📄 .gitignore└── 📄 go.mod

复制代码

实现细节解析


根目录处理

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

复制代码

输出处理逻辑

1. // 保存到文件
   
2. if *outputFile != "" {
   
3.     err = saveToFile(*outputFile, printer.output)
   
4. }
   
5. 
   
6. // 复制到剪贴板
   
7. if *copyClipBoard {
   
8.     content := strings.Join(printer.output, "")
   
9.     err = clipboard.WriteAll(content)
   
10. }
    
11. 
    
12. ​​​​​​​// 控制台输出
    
13. fmt.Println("\n=== Directory Structure ===")
    
14. for _, line := range printer.output {
    
15.     fmt.Print(line)
    
16. }

复制代码

递归目录遍历

1. childPrinter := &DirectoryPrinter{
   
2.     rootDir:       filepath.Join(dp.rootDir, entry.Name()),
   
3.     showHidden:    dp.showHidden,
   
4.     currentDepth:  dp.currentDepth + 1,
   
5.     maxDepth:      dp.maxDepth,
   
6.     indentSymbol:  dp.indentSymbol,
   
7.     folderSymbol:  dp.folderSymbol,
   
8.     fileSymbol:    dp.fileSymbol,
   
9.     output:        dp.output,
   
10.     showConnector: dp.showConnector,
    
11. }
    
12. if err := childPrinter.printDirectory(); err != nil {
    
13.     return err
    
14. }
    
15. dp.output = childPrinter.output

复制代码

附录

完整代码

1. package main
   
2. 
   
3. import (
   
4.         "flag"
   
5.         "fmt"
   
6.         "os"
   
7.         "path/filepath"
   
8.         "sort"
   
9.         "strings"
   
10. 
    
11.         "github.com/atotto/clipboard"
    
12. )
    
13. 
    
14. type DirectoryPrinter struct {
    
15.         rootDir       string
    
16.         showHidden    bool
    
17.         currentDepth  int
    
18.         maxDepth      int
    
19.         indentSymbol  string
    
20.         folderSymbol  string
    
21.         fileSymbol    string
    
22.         output        []string
    
23.         showConnector bool // 新增字段控制是否显示连接线
    
24. }
    
25. 
    
26. func (dp *DirectoryPrinter) printDirectory() error {
    
27.         // 检查是否超过最大深度
    
28.         if dp.maxDepth > 0 && dp.currentDepth >= dp.maxDepth {
    
29.                 return nil
    
30.         }
    
31. 
    
32.         entries, err := os.ReadDir(dp.rootDir)
    
33.         if err != nil {
    
34.                 return err
    
35.         }
    
36. 
    
37.         // 过滤隐藏文件
    
38.         var filteredEntries []os.DirEntry
    
39.         for _, entry := range entries {
    
40.                 if dp.showHidden || !strings.HasPrefix(entry.Name(), ".") {
    
41.                         filteredEntries = append(filteredEntries, entry)
    
42.                 }
    
43.         }
    
44. 
    
45.         // 按类型（目录优先）和名称排序
    
46.         sort.Slice(filteredEntries, func(i, j int) bool {
    
47.                 // 首先按类型排序（目录在前）
    
48.                 if filteredEntries[i].IsDir() != filteredEntries[j].IsDir() {
    
49.                         return filteredEntries[i].IsDir()
    
50.                 }
    
51.                 // 同类型按名称排序
    
52.                 return filteredEntries[i].Name() < filteredEntries[j].Name()
    
53.         })
    
54. 
    
55.         total := len(filteredEntries)
    
56.         for i, entry := range filteredEntries {
    
57.                 prefix := strings.Repeat(dp.indentSymbol, dp.currentDepth)
    
58.                 var line string
    
59.                 if entry.IsDir() {
    
60.                         line = dp.buildFolderLine(prefix, i, total, entry)
    
61.                 } else {
    
62.                         line = dp.buildFileLine(prefix, i, total, entry)
    
63.                 }
    
64.                 dp.output = append(dp.output, line)
    
65. 
    
66.                 // 递归处理子文件夹
    
67.                 if entry.IsDir() {
    
68.                         childPrinter := &DirectoryPrinter{
    
69.                                 rootDir:       filepath.Join(dp.rootDir, entry.Name()),
    
70.                                 showHidden:    dp.showHidden,
    
71.                                 currentDepth:  dp.currentDepth + 1,
    
72.                                 maxDepth:      dp.maxDepth,
    
73.                                 indentSymbol:  dp.indentSymbol,
    
74.                                 folderSymbol:  dp.folderSymbol,
    
75.                                 fileSymbol:    dp.fileSymbol,
    
76.                                 output:        dp.output,
    
77.                                 showConnector: dp.showConnector,
    
78.                         }
    
79.                         if err := childPrinter.printDirectory(); err != nil {
    
80.                                 return err
    
81.                         }
    
82.                         dp.output = childPrinter.output
    
83.                 }
    
84.         }
    
85. 
    
86.         return nil
    
87. }
    
88. 
    
89. func (dp *DirectoryPrinter) buildFolderLine(prefix string, index, total int, entry os.DirEntry) string {
    
90.         if dp.showConnector {
    
91.                 isLast := index == total-1
    
92.                 connector := "├── "
    
93.                 if isLast {
    
94.                         connector = "└── "
    
95.                 }
    
96.                 return fmt.Sprintf("%s%s📁 %s\n", prefix, connector, entry.Name())
    
97.         }
    
98.         return fmt.Sprintf("%s📁 %s\n", prefix, entry.Name())
    
99. }
    
100. 
     
101. func (dp *DirectoryPrinter) buildFileLine(prefix string, index, total int, entry os.DirEntry) string {
     
102.         if dp.showConnector {
     
103.                 isLast := index == total-1
     
104.                 connector := "├── "
     
105.                 if isLast {
     
106.                         connector = "└── "
     
107.                 }
     
108.                 return fmt.Sprintf("%s%s📄 %s\n", prefix, connector, entry.Name())
     
109.         }
     
110.         return fmt.Sprintf("%s📄 %s\n", prefix, entry.Name())
     
111. }
     
112. 
     
113. func usage() {
     
114.         fmt.Println("Usage: directory_printer [OPTIONS] [PATH]")
     
115.         fmt.Println("\nOptions:")
     
116.         fmt.Println("  --show-hidden               Include hidden files and directories")
     
117.         fmt.Println("  --output-file <file_path>   Save the directory structure to a file")
     
118.         fmt.Println("  --copy-ClipBoard            Copy Directory structure to clipboard")
     
119.         fmt.Println("  --max-depth <number>        Maximum directory depth to display (0 for all levels, 1 for root only)")
     
120.         fmt.Println("  --show-connector            Show connector characters (├── and └──)")
     
121.         fmt.Println("  --help                      Display this help message")
     
122.         fmt.Println("\nExample:")
     
123.         fmt.Println("  directory_printer --show-hidden --max-depth 2 --output-file output.txt /path/to/directory")
     
124. }
     
125. 
     
126. func isDirectory(path string) bool {
     
127.         fileInfo, err := os.Stat(path)
     
128.         if err != nil {
     
129.                 return false
     
130.         }
     
131.         return fileInfo.IsDir()
     
132. }
     
133. 
     
134. func saveToFile(filePath string, content []string) error {
     
135.         file, err := os.Create(filePath)
     
136.         if err != nil {
     
137.                 return err
     
138.         }
     
139.         defer file.Close()
     
140. 
     
141.         for _, line := range content {
     
142.                 if _, err := file.WriteString(line); err != nil {
     
143.                         return err
     
144.                 }
     
145.         }
     
146. 
     
147.         return nil
     
148. }
     
149. 
     
150. func main() {
     
151.         showHidden := flag.Bool("show-hidden", false, "Include hidden files and directories")
     
152.         outputFile := flag.String("output-file", "", "Save the directory structure to a file")
     
153.         copyClipBoard := flag.Bool("copy-ClipBoard", true, "Copy Directory structure to clipboard")
     
154.         maxDepth := flag.Int("max-depth", 0, "Maximum directory depth to display (0 for all levels, 1 for root only)")
     
155.         showConnector := flag.Bool("show-connector", false, "Show connector characters (├── and └──)")
     
156.         help := flag.Bool("help", false, "Display this help message")
     
157.         flag.Parse()
     
158. 
     
159.         if *help {
     
160.                 usage()
     
161.                 os.Exit(0)
     
162.         }
     
163. 
     
164.         var rootDir string
     
165.         if len(flag.Args()) == 0 {
     
166.                 rootDir = "."
     
167.         } else {
     
168.                 rootDir = flag.Arg(0)
     
169.         }
     
170. 
     
171.         if !isDirectory(rootDir) {
     
172.                 fmt.Printf("Error: %s is not a valid directory\n", rootDir)
     
173.                 os.Exit(1)
     
174.         }
     
175. 
     
176.         printer := &DirectoryPrinter{
     
177.                 rootDir:       rootDir,
     
178.                 showHidden:    *showHidden,
     
179.                 currentDepth:  0,
     
180.                 maxDepth:      *maxDepth,
     
181.                 indentSymbol:  "    ", // 使用4个空格作为视觉缩进
     
182.                 folderSymbol:  "",
     
183.                 fileSymbol:    "",
     
184.                 output:        []string{},
     
185.                 showConnector: *showConnector,
     
186.         }
     
187. 
     
188.         rootName := filepath.Base(rootDir)
     
189.         if rootName == "." {
     
190.                 // 获取当前工作目录的绝对路径
     
191.                 absPath, err := filepath.Abs(rootDir)
     
192.                 if err != nil {
     
193.                         rootName = "current_directory"
     
194.                 } else {
     
195.                         rootName = filepath.Base(absPath)
     
196.                 }
     
197.         }
     
198.         printer.output = append(printer.output, fmt.Sprintf("📂 %s\n", rootName))
     
199.         // 增加根目录的缩进
     
200.         printer.currentDepth = 1
     
201. 
     
202.         err := printer.printDirectory()
     
203.         if err != nil {
     
204.                 fmt.Printf("Error: %v\n", err)
     
205.                 os.Exit(1)
     
206.         }
     
207. 
     
208.         if *outputFile != "" {
     
209.                 err = saveToFile(*outputFile, printer.output)
     
210.                 if err != nil {
     
211.                         fmt.Printf("Failed to save to file: %v\n", err)
     
212.                         os.Exit(1)
     
213.                 }
     
214.                 fmt.Printf("Directory structure saved to: %s\n", *outputFile)
     
215.         }
     
216.         if *copyClipBoard {
     
217.                 content := strings.Join(printer.output, "")
     
218.                 err = clipboard.WriteAll(content)
     
219.                 if err != nil {
     
220.                         fmt.Printf("Failed to copy to clipboard: %v\n", err)
     
221.                 } else {
     
222.                         fmt.Println("Directory structure copied to clipboard")
     
223.                 }
     
224.         }
     
225. 
     
226.         fmt.Println("\n=== Directory Structure ===")
     
227.         for _, line := range printer.output {
     
228.                 fmt.Print(line)
     
229.         }
     
230. }

复制代码

总结

这款Go语言实现的目录树打印工具通过简洁的代码实现了强大的功能，无论是开发者快速查看项目结构，还是编写技术文档时展示目录布局，它都是一个得力的助手。清晰的emoji标识、灵活的输出选项和可定制的显示深度，让它成为你开发工具箱中不可或缺的一员。
到此这篇关于基于Go语言实现一个目录树打印工具的文章就介绍到这了,更多相关Go目录树打印内容请搜索晓枫资讯以前的文章或继续浏览下面的相关文章希望大家以后多多支持晓枫资讯！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！