Golang force delete directory

In Golang, deleting a directory usually uses the os.RemoveAll() function. But sometimes, we need to forcefully delete a directory, even if there are still files in the directory. How to achieve this? Next, we will share two methods to forcefully delete a directory.

Method 1: Use system commands

The first method is to use system commands to delete the directory. The code is as follows:

package main

import (
    "fmt"
    "os"
    "os/exec"
)

func ForceRemoveDir(dir string) error {
    cmd := exec.Command("rm", "-rf", dir)
    return cmd.Run()
}

func main() {
    err := ForceRemoveDir("./testdir")
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
    fmt.Println("Remove success")
}

In this example, we use the Command() function in the os/exec package to create a cmd object and pass in the parameter information that needs to be executed, that is, "rm -rf dir ", where rm is the delete command under Linux, -rf means to forcefully delete the folder without asking, and dir is the path of the folder that needs to be deleted. The deletion operation is performed through the cmd.Run() function. This function will return the execution result. If the deletion is successful, it will return nil.

It should also be noted that this method is only applicable to Linux systems. If you are under Windows system, you need to modify the command to "rd /s /q dir".

Method 2: Recursively delete files

The second method is to recursively delete all files and directories in the directory, and finally delete the directory. The code is as follows:

package main

import (
    "fmt"
    "os"
)

func ForceRemoveDir(dir string) error {
    err := os.RemoveAll(dir)
    if err != nil {
        if os.IsNotExist(err) {
            return nil
        }
        return err
    }
    return nil
}

func RemoveFiles(dir string) error {
    files, err := os.ReadDir(dir)
    if err != nil {
        return err
    }
    for _, file := range files {
        path := dir + "/" + file.Name()
        if file.IsDir() {
            err := RemoveFiles(path)
            if err != nil {
                return err
            }
            err = os.Remove(path)
            if err != nil {
                return err
            }
        } else {
            err := os.Remove(path)
            if err != nil {
                return err
            }
        }
    }
    return nil
}

func main() {
    dir := "./testdir"
    err := RemoveFiles(dir)
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
    err = ForceRemoveDir(dir)
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
    fmt.Println("Remove success")
}

Using this method requires recursively deleting all files and directories in the directory and then deleting the directory. First, we define a RemoveFiles() function that recursively removes all files and directories in a directory. In this function, we first obtain all file and directory information in the directory through the os.ReadDir() function, and traverse the information. If the file information is a directory, the RemoveFiles() function is called recursively; if it is a file, then Use the os.Remove() function to delete. ?

After completing the recursive file deletion, we call the ForceRemoveDir() function to delete the directory. This function calls the os.RemoveAll() function, which removes the directory and all the files and subdirectories it contains. However, it should be noted that before returning the result, we need to determine whether the directory really exists. If it does not exist, nil will be returned directly.

It should be noted that forcibly deleting files has certain risks and needs to be used with caution. It is recommended to back up data before use to avoid data loss.

The above is the detailed content of Golang force delete directory. For more information, please follow other related articles on the PHP Chinese website!