Effacer les dossiers de l'arborescence qui contiennent uniquement des dossiers vides

L'éditeur php Xiaoxin est là pour vous présenter une petite astuce sur les opérations sur les dossiers - comment effacer les dossiers qui contiennent uniquement des dossiers vides de l'arborescence. Dans la gestion quotidienne des fichiers, nous pouvons rencontrer certains dossiers qui ne contiennent que des dossiers vides. Ces dossiers occupent de l'espace de stockage mais n'ont aucun contenu réel. Grâce aux opérations simples suivantes, nous pouvons facilement effacer ces dossiers vides, libérer un espace de stockage précieux et améliorer l'efficacité de la gestion des fichiers.

Contenu des questions

J'en ai un

type node struct {
   id       string
   children []node
}

J'ai une structure de répertoires calquée sur cette tranche. Il peut y avoir plusieurs niveaux de structures de dossiers dans ce répertoire, ce qui finit par ne contenir aucun fichier. Voir : ű

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

Je souhaite nettoyer les dossiers qui ne contiennent que des dossiers vides. Ainsi, dans cet exemple, un seul fichier restera dans le dossier 1 et tout ce qui se trouve en dessous sera supprimé. Mais je n'arrive pas à trouver une bonne idée pour faire ça. Je peux certainement créer un nouvel arbre sans changer l'arbre d'origine, mais je ne sais pas comment parcourir efficacement l'arbre et voir si le dernier enfant n'a pas d'enfants, puis revenir à la racine et supprimer cet enfant, ce qui donne juste un liste de dossiers vide. Toutes les idées seront les bienvenues !

Ma solution initiale pour supprimer uniquement les feuilles et non le dossier parent :

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

Bonne question d'abord, mais il sera difficile pour les autres de reproduire le cas d'utilisation que vous avez. La prochaine fois, essayez d'ajouter du code reproductible que les gens pourront utiliser, tester rapidement leurs méthodes et donner des résultats. Comme si vous aviez passé la racine mais comment l'initialiser ? Si quelqu’un a besoin de vous aider, il doit d’abord établir une relation. D'une manière générale, cela n'est pas pratique. Néanmoins, regardons les solutions.

Structure des répertoires

输入dir

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

预期结果

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

Définition du nœud

Tout d’abord, je ne sais pas comment créer l’arborescence des répertoires. Si vous l'avez codé en dur, c'est une autre question, mais n-ary 树通常填充的方式，那么您需要使用自引用指针定义 node . Pas une tranche exacte. Je définirais donc les nœuds comme suit

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

Méthodes d'aide

Il s'agit d'une méthode d'assistance pour vérifier si le chemin pointe vers un répertoire

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
}

Comment peupler un arbre

Cela utilise queue 输入 n-ary 树 的简单迭代方法。 golang不提供队列实现，但golang通道实际上只是队列。我将其保留为 500 car nous ne pouvons pas créer de canaux tampons dynamiques dans Golang. À mon humble avis, ce numéro devrait fonctionner pour presque tous les scénarios.

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
}

Une autre méthode auxiliaire

Cela imprime simplement l’arborescence des répertoires. À des fins de débogage uniquement.

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

}

Enfin votre solution.

Très simple. Si vous avez des questions, faites-le-moi savoir.

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)
}

Voici main()

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!