Clear folders from tree that contain only empty folders

php editor Xiaoxin is here to introduce you to a little trick about folder operations - how to clear folders that only contain empty folders from the tree. In daily file management, we may encounter some folders that only contain empty folders. These folders occupy storage space but have no actual content. Through the following simple operations, we can easily clear these empty folders, free up valuable storage space, and improve the efficiency of file management.

Question content

I have one

type node struct {
   id       string
   children []node
}

I have a directory structure modeled after this slice. There may be multiple levels of folder structures in this directory, ending up with no files in it. See:ű

folder1/folder2/folder3/folder4
folder1/file1.txt

I want to clean those folders that only have empty folders. So, in this example, only one file will remain in folder1 and everything below will be deleted. But I can't seem to come up with a good idea for doing this. I could totally create a new tree without changing the original tree, but I don't know how to efficiently iterate through the tree and see if the last child has no children, then go back to the root and remove that child resulting in just an empty folder list. Any ideas will be welcome!

My initial solution only deletes the leaves and not the parent folder:

func removeChildlessFolders(original, tree []Node) []Node {
    for i, node := range original {
        if len(node.Children) == 0 {
            continue
        }

        dir := Node{}
        dir.Id = node.Id
        dir.Children = append(dir.Children, node.Children...)
        tree = append(tree, dir)
        removeChildlessFolders(original[i].Children, node.Children)
    }

    return tree
}

Workaround

Good question first, but it will be difficult for others to reproduce the use case you have. From next time try to add reproducible code that people can use and quickly test their methods and give results. Like you've passed the root but how do you initialize it? If someone needs to help you, they need to build a relationship first. Generally speaking, this is inconvenient. Nonetheless, let's look at the solutions.

Directory Structure

Enter dir

test-folder
├── folder1
│   └── folder2
│       └── folder3
├── folder4
│   ├── folder5
│   └── joker
└── folder6
    └── file.txt

expected outcome

test-folder
└── folder6
    └── file.txt

Node definition

First of all, I don't know how you create the directory tree. If you have it hardcoded then that's a different question, but the way n-ary trees are usually populated, then you need to define node with a self-referential pointer. Not an exact slice. So I would define nodes as follows

type node struct {
    id       string
    children []*node
}

Auxiliary methods

This is a helper method to check whether the path points to a directory

func ifdir(path string) bool {
    file, err := os.open(path)
    if err != nil {
        panic(err)
    }
    defer file.close()
    info, err := file.stat()
    if err != nil {
        panic(err)
    }
    if info.isdir() {
        return true
    }
    return false
}

How to populate the tree

This is a simple iteration method using a queue input n-ary tree . Golang does not provide a queue implementation, but golang channels are actually just queues. I left it as 500 because we cannot create dynamic buffered channels in golang. IMHO, this number should work for almost all scenarios.

func buildtreefromdir(basedir string) *node {
    _, err := ioutil.readdir(basedir)
    if err != nil {
        return nil
    }
    root := &node{
        id: basedir,
    }
    //////////
    queue := make(chan *node, 500) // consider that there can not be any dir with > 500 depth
    queue <- root
    for {
        if len(queue) == 0 {
            break
        }
        data, ok := <-queue
        if ok {
            // iterate all the contents in the dir
            curdir := (*data).id
            if ifdir(curdir) {
                contents, _ := ioutil.readdir(curdir)

                data.children = make([]*node, len(contents))
                for i, content := range contents {
                    node := new(node)
                    node.id = filepath.join(curdir, content.name())
                    data.children[i] = node
                    if content.isdir() {
                        queue <- node
                    }
                }
            }
        }
    }
    return root
}

Another auxiliary method

This just prints the directory tree. For debugging purposes only.

func printdirtree(root *node) {
    fmt.println(root.id)
    for _, each := range root.children {
        printdirtree(each)
    }
    if len(root.children) == 0 {
        fmt.println("===")
    }

}

Finally your solution.

very simple. If you have any questions please let me know.

func recursiveemptydelete(root *node) {
    // if the current root is not pointing to any dir
    if root == nil {
        return
    }
    for _, each := range root.children {
        recursiveemptydelete(each)
    }
    if !ifdir(root.id) {
        return
    } else if content, _ := ioutil.readdir(root.id); len(content) != 0 {
        return
    }
    os.remove(root.id)
}

Here is main()

func main() {
    root := buildTreeFromDir("test-folder")
    printDirTree(root)
    recursiveEmptyDelete(root)
}

The above is the detailed content of Clear folders from tree that contain only empty folders. For more information, please follow other related articles on the PHP Chinese website!