![How to create nested directory in Golang? [SOLVED]](/golang-create-nested-directory/golang-create-nested-directories.jpg)
In this tutorial we will explore different methods which are possible to create nested directories in golang.
Example-1: Create nested directories using os.Mkdir
Here is a simple example where we are creating nested directories inside one parent directory:
package main
import (
"fmt"
"os"
)
func main() {
myDir := "/tmp/topDir"
// Create the top-level directory
err := os.Mkdir(myDir, 0755)
if err != nil {
panic(err)
}
// Create the subdirectories
err = os.Mkdir(myDir+"/subdir1", 0755)
if err != nil {
panic(err)
}
err = os.Mkdir(myDir+"/subdir2", 0755)
if err != nil {
panic(err)
}
fmt.Println("Nested directories created successfully!")
}
Output:
# go run main.go
Nested directories created successfully!
Verify the directories are created:
# tree /tmp/topDir/
/tmp/topDir/
├── subdir1
└── subdir2
2 directories, 0 files
But this solution is not very Robust, as if the same code is ran again:
# go run main.go
mkdir /tmp/topDir: file exists
So this code will not check for sub paths, if the parent directory
itself is present. The second problem with this code is that it is very
big and does not handle multi level of nested directories. In such case
we have to use os.Mkdir() multiple times.But let’s not get carried
away, this also is definitely an option but we can also achieve this
using standard libraries. Let’s check other examples.
Example-2: Check if directory exists and then create nested directories
We will enhance our previous code to first check for existing directory
with the same name before trying to create it, to avoid any failures. We
will use os.Stat to check if directory exists and use
os.Mkdir(myDir, 0755) to create the directories. Similarly we check if
the subdirectories exist in the same way, and if they don’t exist, we
create them using os.Mkdir(subdir1, 0755) and
os.Mkdir(subdir2, 0755).
package main
import (
"fmt"
"os"
)
func main() {
myDir := "/tmp/topDir"
_, err := os.Stat(myDir)
if os.IsNotExist(err) {
fmt.Println("creating ", myDir)
err := os.Mkdir(myDir, 0755)
if err != nil {
panic(err)
}
}
subdir1 := myDir + "/subdir1"
_, err = os.Stat(subdir1)
if os.IsNotExist(err) {
fmt.Println("creating ", subdir1)
err := os.Mkdir(subdir1, 0755)
if err != nil {
panic(err)
}
}
subdir2 := subdir1 + "/subdir2"
_, err = os.Stat(subdir2)
if os.IsNotExist(err) {
fmt.Println("creating ", subdir2)
err := os.Mkdir(subdir2, 0755)
if err != nil {
panic(err)
}
}
fmt.Println("Nested directories created successfully!")
}
Example-3: Create nested directories using os.MdirAll()
Instead of running os.Mkdir() for every directory and sub-directory,
we can use os.MkdirAll() function to create nested directories in
single line:
func main() {
// Create the top-level directory
err := os.MkdirAll("/path/to/topdir/subdir1/subdir2", 0755)
if err != nil {
fmt.Println(err)
return
}
fmt.Println("Nested directories created successfully!")
}
Here is a sample code which will takea string argument representing the complete nested directory structure and creates the directories if they don’t exist.
package main
import (
"fmt"
"os"
"path/filepath"
)
func createNestedDirs(path string) error {
_, err := os.Stat(path)
if os.IsNotExist(err) {
// Create parent directories if they don't exist
err = os.MkdirAll(filepath.Dir(path), 0755)
if err != nil {
return fmt.Errorf("error creating parent directories: %v", err)
}
// Create the directory
err = os.Mkdir(path, 0755)
if err != nil {
return fmt.Errorf("error creating directory: %v", err)
}
fmt.Println("Directory created successfully at :", path)
} else {
fmt.Println("Directory already exists at :", path)
}
return nil
}
func main() {
path := "/tmp/topdir/subdir1/subdir2"
err := createNestedDirs(path)
if err != nil {
panic(err)
}
}
In the above example, we created a function
createNestedDirs(path string) error which takes a string argument
representing the complete nested directory structure. Inside the
function we first check if the directory exists by calling
os.Stat(path). If the directory doesn’t exist, we create it using
os.MkdirAll(filepath.Dir(path), 0755) which creates all the parent
directories, and os.Mkdir(path, 0755) creates the directory.
The filepath.Dir(path) function takes the input path and returns the
parent directory of that path, so that all the parent directories are
created before creating the final directory.
In the main function, we call createNestedDirs(path) function with the
desired directory path, and check for errors.
Output:
$ go run main.go
Directory created successfully at : /tmp/topdir/subdir1/subdir2
Tree structure of our directories:
# tree /tmp/topdir/
/tmp/topdir/
└── subdir1
└── subdir2
2 directories, 0 files
Example-4: Using shell command (mkdir -p) to create nested directories
In golang you can use
exec package
to execute shell commands in golang. While most of us already know,
in shell it is a one line command to create nested directories so we can
also utilise the same in golang with exec.Command() function.
package main
import (
"fmt"
"os/exec"
)
func main() {
path := "/path/to/topdir/subdir1/subdir2"
cmd := exec.Command("mkdir", "-p", path)
err := cmd.Run()
if err != nil {
fmt.Println(err)
return
}
fmt.Println("Nested directories created successfully!")
}
In this example, we use the exec.Command function to create a new
command to run the mkdir command with the -p option, which creates
the parent directories as well if they don’t exist. The path variable is
passed as the argument to the command which is the path of the nested
directory.
The cmd.Run() function runs the command and waits for it to complete,
and it returns an error if the command fails.
You can also use cmd.Output() which runs the command and returns the
output and error or cmd.Start() which starts the command and returns
an error if the command can’t be started.
Output
# go run main.go
Nested directories created successfully!
# tree /path/
/path/
└── to
└── topdir
└── subdir1
└── subdir2
4 directories, 0 files
Summary
In this tutorial we covered different methods to create nested
directories in golang. The most used function is os.Mkdir() which can
create nested directories for you or alternatively we can add additional
enhancement to the code to first check for existing directories and
create only if it doesn’t exist by using os.IsNotExist() function. We
can also use shell command mkdir -p </path/to/dir> using
exec.Command() function to achieve this.
