1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

package main

import (
	"fmt"
	"os"
)

const BasePath = "./"

// 文件树节点接口
type fileNode interface {
	getPath() string
	getNum() int
	getSize() int64
}

// 叶子节点结构，它实现 fileNode
type file struct {
	path string
}

func newFile(path string) *file {
	return &file{path: path}
}

func (f *file) getPath() string {
	return f.path
}

func (f *file) getNum() int {
	return 1
}

func (f *file) getSize() int64 {
	fi, err := os.Stat(f.getPath())
	if err != nil {
		return 0
	}
	return fi.Size()
}

// 目录节点结构，它内嵌一组 fileNode 同时实现 fileNode
type Directory struct {
	components []fileNode
	path       string
}

func newDirectory(path string) *Directory {
	return &Directory{path: path}
}

func (f *Directory) getPath() string {
	return f.path
}

// 将原本的递归求解，转换成循环求解
func (f *Directory) getNum() int {
	var sum int
	for _, v := range f.components {
		sum += v.getNum()
	}
	return sum
}

// 将原本的递归求解，转换成循环求解
func (f *Directory) getSize() int64 {
	var size int64
	for _, v := range f.components {
		size += v.getSize()
	}
	return size
}

// 目录节点需提供对子节点的管理
// 缺少检查机制
func (f *Directory) addSubNode(node ...fileNode) {
	f.components = append(f.components, node...)
}

func main() {
	fileSystemTree := newDirectory(BasePath)
	dirMusic := newDirectory(BasePath + "music/")
	dirPost := newDirectory(BasePath + "post/")
	fileSystemTree.addSubNode(dirMusic)
	fileSystemTree.addSubNode(dirPost)

	fileMusic1 := newFile(BasePath + "music/1.txt")
	fileMusic2 := newFile(BasePath + "music/2.txt")
	dirMusic.addSubNode(fileMusic1, fileMusic2)

	filePost1 := newFile(BasePath + "post/1.txt")
	dirPost.addSubNode(filePost1)

	fmt.Println("/ file num:", fileSystemTree.getNum())
	fmt.Println("/ file size:", fileSystemTree.getSize())
}