Skip to main content

Documentation Index

Fetch the complete documentation index at: https://notes.kodekloud.com/llms.txt

Use this file to discover all available pages before exploring further.

In this article, we explore file handling in Golang. File handling involves managing files by retrieving metadata, creating new files, and reading from or writing to files. Golang’s standard libraries integrate these capabilities, ensuring consistent behavior across different operating systems.

​
File Handling Libraries

Golang provides several packages that simplify file handling operations:
  • os: Functions for file operations such as creating, deleting, opening files, and modifying permissions.
  • io: Basic I/O primitives enveloped in user-friendly interfaces.
  • filepath: Functions for parsing and constructing file paths in a portable manner.
  • fmt: Formatting functions for I/O operations, including printing output.
The image is a slide discussing file handling libraries in programming, highlighting packages like os, io, filepath, and fmt for various file operations and I/O functionalities.

​
File Path Construction Using the filepath Package

The filepath package offers methods to build and manipulate file paths portably across operating systems. Key methods include:
  • Join: Constructs a path from multiple elements.
  • Dir: Retrieves the directory portion of a path.
  • Base: Extracts the last element of the path, typically the file name.
  • IsAbs: Checks if a given path is absolute.
  • Ext: Retrieves the file extension.
For example, the Join method concatenates path elements using the appropriate OS-specific separator:
The image is a summary of methods for constructing file paths, including "Join" for portable path construction, "Dir" and "Base" for splitting paths, and "IsAbs" for checking if a path is absolute.

​
Example: Using filepath.Join

package main

import (
	"fmt"
	"path/filepath"
)

func main() {
	// Construct a portable file path
	path := filepath.Join("dir1", "dir2", "text.txt")
	fmt.Println(path) // On Unix: dir1/dir2/text.txt
}
The Join method also normalizes the path by resolving extra separators or relative directory indicators (such as ”../”): 
package main

import (
	"fmt"
	"path/filepath"
)

func main() {
	// Normalizes extra separators
	path := filepath.Join("dir1", "dir2//", "text.txt")
	fmt.Println(path) // Output: "dir1/dir2/text.txt"
}
The following examples illustrate related methods:

​
Retrieve Directory with filepath.Dir

package main

import (
	"fmt"
	"path/filepath"
)

func main() {
	path := filepath.Join("dir1", "dir2", "text.txt")
	fmt.Println(filepath.Dir(path)) // Output: "dir1/dir2"
}

​
Extract Filename with filepath.Base

package main

import (
	"fmt"
	"path/filepath"
)

func main() {
	path := filepath.Join("dir1", "dir2", "text.txt")
	fmt.Println(filepath.Base(path)) // Output: "text.txt"
}

​
Check Absolute Path with filepath.IsAbs

package main

import (
	"fmt"
	"path/filepath"
)

func main() {
	relPath := filepath.Join("dir1", "dir2", "text.txt")
	absPath := "/dir/file"
	fmt.Println(filepath.IsAbs(relPath)) // Output: false
	fmt.Println(filepath.IsAbs(absPath))   // Output: true
}

​
Retrieve File Extension with filepath.Ext

package main

import (
	"fmt"
	"path/filepath"
)

func main() {
	path := filepath.Join("dir1", "dir2", "text.txt")
	fmt.Println(filepath.Ext(path)) // Output: ".txt"
}
Changing the file extension reflects accordingly, as shown below: 
package main

import (
	"fmt"
	"path/filepath"
)

func main() {
	path := filepath.Join("dir1", "dir2", "text.js")
	fmt.Println(filepath.Ext(path)) // Output: ".js"
}

​
Retrieving File Metadata with os.Stat

Golang’s os.Stat function is used to obtain metadata about files or directories. This metadata includes file name, size, permissions, and an indicator of whether the path represents a directory.
Using os.Stat is a quick way to verify file attributes before processing them in your application.
package main

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

func main() {
	// Replace with your file path.
	fileInfo, err := os.Stat("/Users/priyanka/temp.txt")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println("Name:", fileInfo.Name())   // e.g., temp.txt
	fmt.Println("Size:", fileInfo.Size())   // File size in bytes
	fmt.Println("Mode:", fileInfo.Mode())   // Permission bits
	fmt.Println("IsDir:", fileInfo.IsDir()) // false if it's a file
}
Running the above code might produce an output similar to: 
temp.txt
27
-rw-r--r--
false

​
Reading Files

Golang provides convenient methods to read file contents. The os.ReadFile function reads the entire content of a file at once and returns a byte slice along with any error encountered. 
package main

import (
	"fmt"
	"os"
)

func main() {
	path := "/Users/priyanka/text.txt"
	data, err := os.ReadFile(path)
	if err != nil {
		fmt.Println(err)
		return
	}
	// Print raw byte slice output
	fmt.Println(data)
	// Convert to string for human-readable output
	fmt.Println(string(data))
}
For a file containing “Hello World”, the output might look like: 
[72 101 108 108 111 32 87 111 114 108 100 10]
Hello World
For large files or when reading data in chunks, you can open the file with os.Open and then read portions into a buffer: 
package main

import (
	"fmt"
	"os"
)

func main() {
	file, err := os.Open("/Users/priyanka/text.txt")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer file.Close()

	b := make([]byte, 4)
	for {
		n, err := file.Read(b)
		if err != nil {
			fmt.Println("Error:", err)
			break
		}
		fmt.Print(string(b[:n]))
	}
}
The output may appear as follows: 
Hell
o Wo
rld
Error: EOF

​
Writing and Appending to Files

Golang’s os.OpenFile function provides a flexible method to open or create files with specific flags and permissions. Commonly used flags include:
FlagDescriptionExample Usage
os.O_RDONLYOpen the file in read-only modeReading file contents
os.O_WRONLYOpen the file in write-only modeWriting data to a file
os.O_RDWROpen the file in read-write modeReading and writing simultaneously
os.O_APPENDAppend data to the file when writingAdding log entries or new content
os.O_CREATECreate the file if it does not existCreating a new file
os.O_EXCLUsed with O_CREATE to ensure the file does not already existPreventing accidental overwrites
os.O_SYNCOpen the file for synchronous I/OFor data consistency in critical operations
os.O_TRUNCTruncate the file when openedOverwriting existing file content
To write strings to a file, use the WriteString method on the file object.

​
Example: Appending Data to a File

package main

import (
	"fmt"
	"os"
)

func main() {
	// Open file with append, create, and write-only flags, with 0644 permissions.
	file, err := os.OpenFile("/Users/priyanka/temp.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer file.Close()

	// Append a string to the file.
	if _, err := file.WriteString("Hope you had a good day!"); err != nil {
		fmt.Println(err)
	}
}
If the file does not exist, the os.O_CREATE flag ensures that it is created with the specified permissions. If the file exists, the string is appended to the current content.
In this article, we covered how to construct file paths, retrieve file metadata, read file contents (both entirely and in chunks), and write or append data to files using Golang. This foundational knowledge is essential for effectively managing files in your applications.

Watch Video