Hone logo
Hone
Problems

Go File Master: Read, Write, and Process Files

This challenge will test your ability to perform fundamental file operations in Go. You'll implement functions to read data from a file, write data to a file, and process the file's content. Mastering these skills is crucial for building any application that interacts with persistent storage.

Problem Description

You are tasked with creating a Go program that can perform three core file operations:

  1. Read File Content: Implement a function that reads the entire content of a given file into a string.
  2. Write Content to File: Implement a function that writes a given string content to a specified file. If the file exists, it should be overwritten.
  3. Count Words in File: Implement a function that reads a file and returns the total number of words it contains. Words are defined as sequences of non-whitespace characters separated by whitespace.

Key Requirements:

  • Each operation should be implemented as a distinct Go function.
  • Error handling is paramount. Your functions should gracefully handle potential errors during file operations (e.g., file not found, permission denied, write errors) and return an appropriate error value.
  • The io and os packages in Go should be utilized for file operations.
  • For word counting, consider how to split the file content into words effectively.

Expected Behavior:

  • ReadFileContent(filePath string) (string, error): Returns the file's content as a string and nil error on success, or an empty string and an error if an issue occurs.
  • WriteContentToFile(filePath string, content string) error: Returns nil error on success, or an error if writing fails.
  • CountWordsInFile(filePath string) (int, error): Returns the word count and nil error on success, or 0 and an error if an issue occurs during reading or processing.

Edge Cases to Consider:

  • Empty files.
  • Files with only whitespace.
  • Files that do not exist (for reading and counting).
  • Permissions issues for reading/writing.
  • Large files (though for this challenge, focus on correctness over extreme optimization for massive files).

Examples

Example 1: Reading and Writing

Let's assume you have a file named my_data.txt with the following content:

Hello, Go!
This is a sample file.

Input to ReadFileContent("my_data.txt"): (No explicit input, function call with filename)

Output from ReadFileContent("my_data.txt"):

"Hello, Go!\nThis is a sample file.\n"
<nil>

Explanation: The function successfully reads the entire content of my_data.txt and returns it as a string.

Input to WriteContentToFile("new_file.txt", "This is new content."):

filePath: "new_file.txt"
content: "This is new content."

Output from WriteContentToFile("new_file.txt", "This is new content."):

<nil>

After this call, new_file.txt will contain:

This is new content.

Explanation: The function creates or overwrites new_file.txt with the provided string content.

Example 2: Counting Words

Let's assume you have a file named word_sample.txt with the following content:

One two three
Four five six seven.
Eight nine.

Input to CountWordsInFile("word_sample.txt"): (No explicit input, function call with filename)

Output from CountWordsInFile("word_sample.txt"):

9
<nil>

Explanation: The function reads the file, splits its content into words (e.g., "One", "two", "three", "Four", "five", "six", "seven.", "Eight", "nine."), and counts them, returning 9. Note that punctuation attached to words is considered part of the word in this basic definition.

Example 3: Edge Case - Empty File

Let's assume you have an empty file named empty.txt.

Input to ReadFileContent("empty.txt"):

filePath: "empty.txt"

Output from ReadFileContent("empty.txt"):

""
<nil>

Explanation: Reading an empty file correctly returns an empty string and no error.

Input to CountWordsInFile("empty.txt"):

filePath: "empty.txt"

Output from CountWordsInFile("empty.txt"):

0
<nil>

Explanation: Counting words in an empty file results in a count of 0 and no error.

Constraints

  • File paths will be valid UTF-8 strings.
  • Content strings will be valid UTF-8 strings.
  • The challenge does not require handling concurrent file access.
  • The maximum file size to consider for word counting is up to a few megabytes, so a simple approach of reading the entire file into memory is acceptable.

Notes

  • The os package provides functions like os.Open, os.Create, ioutil.ReadAll (or io.ReadAll in newer Go versions), and file.Write.
  • The strings package might be useful for processing the file content, particularly for word splitting.
  • Remember to close opened files using defer file.Close() to prevent resource leaks.
  • Consider how to handle newline characters (\n) when reading and processing file content.
  • For word counting, you might want to use strings.Fields as a starting point.
Loading editor...
go