如何在Go语言中向文件开头追加内容，使最新写入内容位于首行？

Got it, so you want to add new content to the very top of a file in Go instead of appending to the end—totally get the use case! Unlike appending (which is straightforward with standard library tools), prepending requires a bit more work because most operating systems don’t natively support inserting data at the start of a file. Here’s how to pull it off properly:

Basic Implementation #

This simple function handles the core logic: read the existing file content, combine it with your new content (with the new stuff first), then write everything back to the file.

package main

import (
	"io/ioutil"
	"os"
)

func prependToFile(filename string, content string) error {
	// Read existing content from the file
	existingBytes, err := ioutil.ReadFile(filename)
	if err != nil {
		// If the file doesn't exist, just create it with the new content
		if os.IsNotExist(err) {
			return ioutil.WriteFile(filename, []byte(content), 0644)
		}
		return err
	}

	// Combine new content + existing content
	newContent := []byte(content + string(existingBytes))

	// Write the combined content back to the original file
	return ioutil.WriteFile(filename, newContent, 0644)
}

func main() {
	// Example usage: add a new header line to example.txt
	err := prependToFile("example.txt", "This is the new first line!\n")
	if err != nil {
		panic(err)
	}
}

Key Improvements & Notes #

• Preserve File Permissions: The hardcoded 0644 permission works for most cases, but you can reuse the original file’s permissions instead to avoid unintended changes:

  // Get original file's metadata to retain permissions
  fileInfo, err := os.Stat(filename)
  if err != nil {
      return err
  }
  // Use the original permissions when writing back
  return ioutil.WriteFile(filename, newContent, fileInfo.Mode().Perm())
  

• Handle Large Files: If you’re working with huge files, loading the entire content into memory isn’t efficient. Use a temporary file instead:
  1. Create a temp file in the same directory
  2. Write your new content to the temp file
  3. Copy the original file’s content into the temp file
  4. Replace the original file with the temp file
     Here’s a snippet for this approach:

  import "io"
  
  func prependLargeFile(filename string, content string) error {
      // Create a temporary file
      tempFile, err := os.CreateTemp("", "prepend-temp-*")
      if err != nil {
    	  return err
      }
      defer os.Remove(tempFile.Name()) // Clean up if something fails
  
      // Write new content first
      if _, err := tempFile.WriteString(content); err != nil {
    	  return err
      }
  
      // Open original file
      originalFile, err := os.Open(filename)
      if err != nil {
    	  if os.IsNotExist(err) {
    		  return os.Rename(tempFile.Name(), filename)
    	  }
    	  return err
      }
      defer originalFile.Close()
  
      // Copy original content to temp file
      if _, err := io.Copy(tempFile, originalFile); err != nil {
    	  return err
      }
  
      // Flush temp file to disk and close it
      if err := tempFile.Sync(); err != nil {
    	  return err
      }
      tempFile.Close()
  
      // Replace original file with temp file
      return os.Rename(tempFile.Name(), filename)
  }
  

• Line Endings: Don’t forget to add a newline (\n) to your content if you want the new line to be separated from the original first line—otherwise, the text will merge together.

Critical Considerations #

• Concurrency: If multiple processes are writing to the same file, this approach can cause race conditions. Add file locking (using syscall.Flock on Unix-like systems, for example) to prevent data corruption.
• Backups: For important files, create a backup of the original before overwriting it—just in case something goes wrong during the write operation.

内容的提问来源于stack exchange，提问作者BurakCan