Golang filepath Glob Function

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

The filepath.Glob function in Golang is part of the path/filepath package and is used to find all file paths that match a given pattern. This function is particularly useful when you need to search for files or directories that match specific naming conventions or patterns, such as all .txt files in a directory or files that start with a particular prefix.

Introduction
filepath.Glob Function Syntax
Examples
- Basic Usage
- Searching in Subdirectories
- Handling No Matches
Real-World Use Case Example
Conclusion

Introduction

The filepath.Glob function performs a pattern match against file paths, returning a list of paths that match the specified pattern. The pattern can include wildcards like *, ?, and [...] to match various file names and extensions. It is similar to the shell globbing feature found in Unix-like systems.

filepath.Glob Function Syntax

The syntax for the filepath.Glob function is as follows:

func Glob(pattern string) (matches []string, err error)

Parameters:

pattern: A string representing the pattern to match against file paths. The pattern can include wildcards such as *, ?, and character classes [abc].

Returns:

matches: A slice of strings containing the file paths that match the given pattern.
err: An error value that is non-nil if the pattern is invalid (e.g., an invalid syntax in the pattern).

Examples

Basic Usage

This example demonstrates how to use filepath.Glob to find all .txt files in the current directory.

Example

package main

import (
	"fmt"
	"path/filepath"
)

func main() {
	matches, err := filepath.Glob("*.txt")
	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	for _, match := range matches {
		fmt.Println("Found file:", match)
	}
}

Output:

Found file: report.txt
Found file: notes.txt
Found file: data.txt

Explanation:

The filepath.Glob function searches for all files in the current directory that have a .txt extension and returns the matching file paths.
Each matched file is printed out.

Searching in Subdirectories

This example shows how to use filepath.Glob to search for all .go files in the src/ directory.

Example

package main

import (
	"fmt"
	"path/filepath"
)

func main() {
	matches, err := filepath.Glob("src/*.go")
	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	for _, match := range matches {
		fmt.Println("Found Go file:", match)
	}
}

Output:

Found Go file: src/main.go
Found Go file: src/utils.go

Explanation:

The filepath.Glob function is used to search for all .go files in the src/ directory.
It returns the file paths that match the pattern, and these paths are printed.

Handling No Matches

This example demonstrates how to handle the case where no files match the specified pattern.

Example

package main

import (
	"fmt"
	"path/filepath"
)

func main() {
	matches, err := filepath.Glob("*.md")
	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	if len(matches) == 0 {
		fmt.Println("No markdown files found.")
	} else {
		for _, match := range matches {
			fmt.Println("Found markdown file:", match)
		}
	}
}

Output:

No markdown files found.

Explanation:

The filepath.Glob function searches for .md files in the current directory.
Since no files match the pattern, the function returns an empty slice, and the program prints a message indicating that no files were found.

Real-World Use Case Example: Cleaning Up Temporary Files

Suppose you are developing a tool that cleans up temporary files in a directory. You can use filepath.Glob to find all files with a .tmp extension and delete them.

Example: Deleting Temporary Files

package main

import (
	"fmt"
	"os"
	"path/filepath"
)

func cleanupTempFiles() error {
	matches, err := filepath.Glob("*.tmp")
	if err != nil {
		return err
	}

	for _, match := range matches {
		fmt.Println("Deleting file:", match)
		err := os.Remove(match)
		if err != nil {
			return err
		}
	}

	return nil
}

func main() {
	err := cleanupTempFiles()
	if err != nil {
		fmt.Println("Error cleaning up temporary files:", err)
	} else {
		fmt.Println("Temporary files cleaned up successfully.")
	}
}

Output:

Deleting file: temp1.tmp
Deleting file: temp2.tmp
Temporary files cleaned up successfully.

Explanation:

The cleanupTempFiles function uses filepath.Glob to find all .tmp files in the current directory.
It then deletes each matching file using os.Remove.
If the cleanup process completes successfully, the program prints a success message.

Conclusion

The filepath.Glob function in Go is used for finding files that match specific patterns. Whether you're searching for files by extension, name, or other criteria, filepath.Glob makes it easy to locate and work with matching files in a directory. By using this function, you can simplify file management tasks, such as cleaning up temporary files, organizing directories, or processing specific types of files in your Go applications.

My Top and Bestseller Udemy Courses. The sale is going on with a 70 - 80% discount. The discount coupon has been added to each course below:

Spring Boot + RabbitMQ Course - The Practical Guide

Java Guides

Search This Blog