Organisez votre bureau : créez un organisateur de fichiers dans Go.

Votre bureau est-il chaotique ? Avez-vous des fichiers de toutes sortes qui encombrent votre bureau ou votre répertoire de téléchargements ? Réparons cela avec un simple script.

Comme nous le faisons au début de tout projet go, nous générons notre fichier go.mod avec la directive "go mod init". Pour garder les choses simples, nous écrirons toute notre logique dans notre fichier main.go.

Parlons un peu de la façon dont nous aimerions que le script se comporte avant d'écrire du code. Nous voulons pouvoir organiser nos fichiers dans des répertoires indiquant le type de fichier ou la date de création. En bref, nous voulons que notre script trie les fichiers vidéo dans un répertoire de vidéos, les fichiers de musique dans un répertoire de musique, etc. ou trier tous les fichiers créés à une date particulière dans le même répertoire.

Maintenant, codons :

Créez un fichier main.go et écrivez ce qui suit :

package main

type fileAnalyzer interface {
    analyzeAndSort() error
}

func analyze(fa fileAnalyzer) error {
    return fa.analyzeAndSort()
}

Parce que nous voulons que notre programme trie les fichiers selon différents critères, nous créons une interface fileAnalyzer qui définit une méthode : analyseAndSort.
Ensuite, nous écrivons une fonction : analyser - qui prend n'importe quelle structure qui implémente l'interface fileAnalyzer comme argument et exécute sa méthode analyseAndSort.

Dans certains cas, comme nous le verrons dans ce programme, il se peut que vous ne souhaitiez pas déplacer certains fichiers. Par exemple, lors du test du script, nous ne voulons pas que le programme déplace nos fichiers go ou notre exécutable/binaire dans un autre répertoire. Pour éviter que cela ne se produise, nous devons créer une liste noire qui comprend tous les fichiers que nous aimerions garder intacts.

Dans notre fichier main.go, écrivez ce qui suit :

var blacklist = []string{
    "go",
    "mod",
    "exe",
    "ps1",
}

Ici, j'ai ajouté l'extension de fichier pour les fichiers que je souhaite ne pas trier. ".go" et ".mod" sont des extensions pour les fichiers go. Parce que j'utilise une machine Windows, mon binaire aura ".exe" comme extension. J'ai également inclus ".ps1" parce que j'aime travailler avec des scripts PowerShell en développement - comme vous le verrez.

Ensuite, nous écrivons quelques fonctions d'assistance.

func getFileExtension(name string) string {
    return strings.TrimPrefix(filepath.Ext(name), ".")
}

func listFiles(dirname string) ([]string, error) {
    var files []string

    list, err := os.ReadDir(dirname)
    if err != nil {
        return nil, err
    }

    for _, file := range list {
        if !file.IsDir() {
            files = append(files, file.Name())
        }
    }

    return files, nil
}

func listDirs(dirname string) ([]string, error) {
    var dirs []string

    list, err := os.ReadDir(dirname)
    if err != nil {
        return nil, err
    }

    for _, file := range list {
        if file.IsDir() {
            dirs = append(dirs, file.Name())
        }
    }

    return dirs, nil
}

func mkdir(dirname string) error {
    err := os.Mkdir(dirname, 0644)

    if err != nil && os.IsExist(err) {
        return nil
    }

    var e *os.PathError

    if err != nil && errors.As(err, &e) {
        return nil
    }

    return err
}

func moveFile(name string, dst string) error {
    return os.Rename(name, filepath.Join(dst, name))
}

func getCurrentDate(t time.Time) string {
    return t.Format("2006-01-02")
}

func filter[T any](ts []T, fn func(T) bool) []T {
    filtered := make([]T, 0)

    for i := range ts {
        if fn(ts[i]) {
            filtered = append(filtered, ts[i])
        }
    }

    return filtered
}

La plupart d'entre eux sont explicites mais j'aimerais parler de la fonction "mkdir". La fonction "mkdir" crée un répertoire avec le nom qui lui est passé en argument - mais la fonction ne renvoie pas d'erreur si le répertoire existe déjà ou s'il y a un "os.PathError".

Créons maintenant une structure qui implémente l'interface fileAnalyzer :

package main

type fileAnalyzer interface {
    analyzeAndSort() error
}

func analyze(fa fileAnalyzer) error {
    return fa.analyzeAndSort()
}

La structure fileTypeAnalyzer a deux propriétés : wd qui contient le nom du répertoire de travail actuel et un mappeur. Les clés du mappeur seront le type de fichier détecté tandis que ses valeurs sont une liste d'extensions de fichiers associées à la clé. Nous créons ensuite une fonction constructeur et fournissons les types de fichiers ainsi que leurs extensions de fichiers associatives au mappeur. N'hésitez pas à ajouter d'autres types de fichiers et extensions à la liste. La méthode anaylyzeAndSort appelle quelques fonctions et méthodes d'assistance qui mappent l'extension de fichier à un type de fichier, crée le répertoire du type de fichier et déplace le fichier dans ledit répertoire. J'ai également ajouté un dossier "misc" pour contenir les fichiers qui n'ont pas été capturés par le mappeur - à l'exclusion bien sûr des fichiers sur liste noire.

Nous souhaitons également pouvoir organiser les fichiers par date de création. Créons une autre structure qui implémente l'interface fileAnalyzer mais organise les fichiers par date.

var blacklist = []string{
    "go",
    "mod",
    "exe",
    "ps1",
}

Une grande partie de la logique est la même que celle du fileTypeAnalyzer. La principale différence est que nous ne fournissons pas de mappeur. Au lieu de cela, nous obtenons la date de création à partir des informations sur le fichier et créons des répertoires en conséquence.

Maintenant, rassemblons tout dans notre fonction principale :

func getFileExtension(name string) string {
    return strings.TrimPrefix(filepath.Ext(name), ".")
}

func listFiles(dirname string) ([]string, error) {
    var files []string

    list, err := os.ReadDir(dirname)
    if err != nil {
        return nil, err
    }

    for _, file := range list {
        if !file.IsDir() {
            files = append(files, file.Name())
        }
    }

    return files, nil
}

func listDirs(dirname string) ([]string, error) {
    var dirs []string

    list, err := os.ReadDir(dirname)
    if err != nil {
        return nil, err
    }

    for _, file := range list {
        if file.IsDir() {
            dirs = append(dirs, file.Name())
        }
    }

    return dirs, nil
}

func mkdir(dirname string) error {
    err := os.Mkdir(dirname, 0644)

    if err != nil && os.IsExist(err) {
        return nil
    }

    var e *os.PathError

    if err != nil && errors.As(err, &e) {
        return nil
    }

    return err
}

func moveFile(name string, dst string) error {
    return os.Rename(name, filepath.Join(dst, name))
}

func getCurrentDate(t time.Time) string {
    return t.Format("2006-01-02")
}

func filter[T any](ts []T, fn func(T) bool) []T {
    filtered := make([]T, 0)

    for i := range ts {
        if fn(ts[i]) {
            filtered = append(filtered, ts[i])
        }
    }

    return filtered
}

Nous configurons un enregistreur ; obtenir le répertoire de travail actuel à transmettre comme argument à notre implémentation fileAnalyzer ; créez une variable de mode pour contenir les valeurs transmises sous forme d'indicateurs à l'application et une instruction switch pour contrôler la façon dont nous voulons trier. Enfin, nous appelons la fonction d'analyse et passons notre implémentation fileAnalyzer comme argument.

C'est tout. Construisons notre binaire et testons. J'ai appelé mon trieur. Vous pouvez appeler le vôtre comme vous voulez avec "go build -o [name]"

Voici un dossier jonché de fichiers de différents types :

Organisons par type de fichier :

Organisons par date de création de fichier :

En bonus, si vous utilisez une machine Windows et PowerShell, voici un script pour vous aider à tester votre programme sans problème.

Créez un fichier task.ps1 et tapez ce qui suit :

type fileTypeAnalyzer struct {
    wd     string
    mapper map[string][]string
}

func newFileTypeAnalyzer(wd string) *fileTypeAnalyzer {
    return &fileTypeAnalyzer{
        wd: wd,
        mapper: map[string][]string{
            "video":  {"mp4", "mkv", "3gp", "wmv", "flv", "avi", "mpeg", "webm"},
            "music":  {"mp3", "aac", "wav", "flac"},
            "images": {"jpg", "jpeg", "png", "gif", "svg", "tiff"},
            "docs":   {"docx", "csv", "txt", "xlsx"},
            "books":  {"pdf", "epub"},
        },
    }
}

func (f fileTypeAnalyzer) analyzeAndSort() error {
    files, err := listFiles(f.wd)
    if err != nil {
        return fmt.Errorf("could not list files: %w", err)
    }

    if err := f.createFileTypeDirs(files...); err != nil {
        return err
    }

    return f.moveFileToTypeDir(files...)
}

func (f fileTypeAnalyzer) moveFileToTypeDir(files ...string) error {
    dirs, err := listDirs(f.wd)
    if err != nil {
        return fmt.Errorf("could not list directories: %w", err)
    }

    for _, dir := range dirs {
        for _, file := range files {
            if slices.Contains(f.mapper[dir], strings.ToLower(getFileExtension(file))) {
                if err := moveFile(file, dir); err != nil {
                    return err
                }
            }
        }
    }

    files, err = listFiles(f.wd)
    if err != nil {
        return err
    }

    if len(files) == 0 {
        return nil
    }

    files = filter(files, func(f string) bool {
        return !slices.Contains(blacklist, getFileExtension(f))
    })

    for i := range files {
        if err := f.moveToMisc(files[i]); err != nil {
            return err
        }
    }

    return nil
}

func (f fileTypeAnalyzer) moveToMisc(file string) error {
    if err := mkdir("misc"); err != nil {
        return err
    }

    return moveFile(file, "misc")
}

func (f fileTypeAnalyzer) createFileTypeDirs(files ...string) error {
    for ftype, fvalues := range f.mapper {
        for _, file := range files {
            if slices.Contains(fvalues, getFileExtension(file)) {
                if err := mkdir(ftype); err != nil {
                    return fmt.Errorf("could not create folder: %w", err)
                }
            }
        }
    }

    return nil
}

Pour construire votre binaire avec le script :

Pour désorganiser les fichiers avec le script :

Pour supprimer des répertoires avec un script :

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!