Organisieren Sie Ihren Desktop: Erstellen Sie einen Datei-Organizer in Go.

Ist Ihr Desktop chaotisch? Haben Sie Dateien aller Art, die Ihren Desktop oder Ihr Download-Verzeichnis überladen? Lassen Sie uns das mit einem einfachen Skript beheben.

Wie zu Beginn jedes Go-Projekts generieren wir unsere go.mod-Datei mit der Direktive „go mod init“. Der Einfachheit halber schreiben wir unsere gesamte Logik in unsere main.go-Datei.

Lassen Sie uns ein wenig darüber sprechen, wie sich das Skript verhalten soll, bevor wir Code schreiben. Wir möchten unsere Dateien in Verzeichnissen organisieren können, die den Dateityp oder das Erstellungsdatum angeben. Kurz gesagt, wir möchten, dass unser Skript Videodateien in ein Videoverzeichnis, Musikdateien in ein Musikverzeichnis usw. sortiert. oder sortieren Sie alle an einem bestimmten Datum erstellten Dateien in dasselbe Verzeichnis.

Jetzt programmieren wir:

Erstellen Sie eine main.go-Datei und schreiben Sie Folgendes:

package main

type fileAnalyzer interface {
    analyzeAndSort() error
}

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

Da wir möchten, dass unser Programm Dateien nach verschiedenen Kriterien sortiert, erstellen wir eine fileAnalyzer-Schnittstelle, die eine Methode definiert:analysAndSort.
Dann schreiben wir eine Funktion: „analysieren“ – die jede Struktur, die die fileAnalyzer-Schnittstelle implementiert, als Argument akzeptiert und ihre Methode „analysierenAndSort“ ausführt.

In einigen Fällen, wie wir sie in diesem Programm sehen werden, gibt es möglicherweise bestimmte Dateien, die Sie nicht verschieben möchten. Beim Testen des Skripts möchten wir beispielsweise nicht, dass das Programm unsere Go-Dateien oder ausführbaren Dateien/Binärdateien in ein anderes Verzeichnis verschiebt. Um dies zu verhindern, müssen wir eine Blacklist erstellen, die alle Dateien enthält, die wir unberührt lassen möchten.

Schreiben Sie Folgendes in unsere main.go-Datei:

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

Hier habe ich die Dateierweiterung für Dateien hinzugefügt, die unsortiert bleiben sollen. „.go“ und „.mod“ sind Erweiterungen für Go-Dateien. Da ich einen Windows-Rechner verwende, hat meine Binärdatei die Erweiterung „.exe“. Ich habe auch „.ps1“ eingefügt, weil ich in der Entwicklung gerne mit Powershell-Skripten arbeite – wie Sie sehen werden.

Als nächstes schreiben wir einige Hilfsfunktionen.

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
}

Die meisten davon sind selbsterklärend, aber ich möchte gerne über die Funktion „mkdir“ sprechen. Die Funktion „mkdir“ erstellt ein Verzeichnis mit dem als Argument übergebenen Namen – die Funktion gibt jedoch keinen Fehler zurück, wenn das Verzeichnis bereits existiert oder ein „os.PathError“ vorliegt.

Jetzt erstellen wir eine Struktur, die die fileAnalyzer-Schnittstelle implementiert:

package main

type fileAnalyzer interface {
    analyzeAndSort() error
}

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

Die fileTypeAnalyzer-Struktur verfügt über zwei Eigenschaften: wd, das den Namen des aktuellen Arbeitsverzeichnisses und einen Mapper enthält. Die Schlüssel des Mappers sind der Typ der erkannten Datei, während seine Werte eine Liste der mit dem Schlüssel verknüpften Dateierweiterungen sind. Anschließend erstellen wir eine Konstruktorfunktion und stellen dem Mapper die Dateitypen sowie deren assoziative Dateierweiterungen zur Verfügung. Sie können der Liste gerne weitere Dateitypen und Erweiterungen hinzufügen. Die Methode „anaylyzeAndSort“ ruft einige Hilfsfunktionen und -methoden auf, die die Dateierweiterung einem Dateityp zuordnen, das Dateitypverzeichnis erstellen und die Datei in dieses Verzeichnis verschieben. Ich habe auch einen „Misc“-Ordner hinzugefügt, um Dateien zu speichern, die nicht vom Mapper erfasst wurden – mit Ausnahme der Dateien auf der schwarzen Liste natürlich.

Wir möchten Dateien auch nach Erstellungsdatum organisieren können. Erstellen wir eine weitere Struktur, die die fileAnalyzer-Schnittstelle implementiert, Dateien aber nach Datum organisiert.

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

Ein Großteil der Logik ist mit der des fileTypeAnalyzer identisch. Der Hauptunterschied besteht darin, dass wir keinen Mapper bereitstellen – stattdessen beziehen wir das Erstellungsdatum aus den Dateiinformationen und erstellen entsprechend Verzeichnisse.

Jetzt fassen wir alles in unserer Hauptfunktion zusammen:

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
}

Wir konfigurieren einen Logger; Rufen Sie das aktuelle Arbeitsverzeichnis ab, um es als Argument an unsere FileAnalyzer-Implementierung zu übergeben. Erstellen Sie eine Modusvariable, um Werte zu speichern, die als Flags an die Anwendung übergeben werden, und eine Switch-Anweisung, um zu steuern, wie wir sortieren möchten. Schließlich rufen wir die Analysefunktion auf und übergeben unsere fileAnalyzer-Implementierung als Argument.

Das ist alles. Lassen Sie uns unsere Binärdatei erstellen und testen. Ich habe meinen Sortierer angerufen. Mit „go build -o [name]“

können Sie Ihres so nennen, wie Sie es möchten

Hier ist ein Ordner voller Dateien unterschiedlicher Art:

Lassen Sie uns nach Dateityp organisieren:

Lassen Sie uns nach Dateierstellungsdatum organisieren:

Als Bonus, wenn Sie einen Windows-Rechner verwenden und Powershell verwenden, finden Sie hier ein Skript, das Ihnen dabei hilft, das Testen Ihres Programms zu vereinfachen.

Erstellen Sie eine task.ps1-Datei und geben Sie Folgendes ein:

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
}

So erstellen Sie Ihre Binärdatei mit dem Skript:

So desorganisieren Sie Dateien mit dem Skript:

Um Verzeichnisse mit einem Skript zu löschen:

Das obige ist der detaillierte Inhalt vonOrganisieren Sie Ihren Desktop: Erstellen Sie einen Datei-Organizer in Go.. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!