Chapter 37a - Reading Files

Reading files is a fundamental operation in programming, allowing developers to access and manipulate stored data. Files serve as containers for storing information such as plain text, binary data, or structured formats like JSON, CSV, or XML. The ability to read files is critical for tasks ranging from loading configuration settings to processing large datasets.

There are different types of files to consider:

Text Files: Store human-readable characters, often encoded in UTF-8 or ASCII. These files are ideal for logs, configuration settings, or documents.
Binary Files: Contain data in a non-human-readable format, such as images, videos, or compiled program data.
Delimited Files: Include structured data separated by delimiters, like commas (CSV), tabs, or pipes. These are commonly used for tabular data.
JSON/XML: Hierarchical or structured formats frequently used for APIs or data exchange between systems.

In this article, we’ll dive into how files can be read and used in Python, PHP, Go, C++, and Zig, focusing on their unique approaches and practical examples.

Understanding File Modes and Their Importance

Before reading files, it's essential to understand file modes. File modes determine how a file is opened and interacted with:

Read Mode (r): Opens a file for reading only. If the file does not exist, an error is raised.
Write Mode (w): Creates a file or overwrites an existing one.
Append Mode (a): Opens a file for writing at the end without altering the existing content.
Binary Mode (b): Used for binary files, combined with other modes, e.g., rb (read binary).

For example:

To read a text file: Use r mode.
To read a binary file: Use rb mode.

Reading Text Files in Different Programming Languages

Python Example for Reading Text Files

# Reading a file line by line
with open('example.txt', 'r') as file:
    for line in file:
        print(line.strip())

PHP Example for Reading Text Files

// Reading a file line by line
$file = fopen("example.txt", "r");
while (($line = fgets($file)) !== false) {
    echo trim($line) . PHP_EOL;
}
fclose($file);

Go Example for Reading Text Files

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	file, err := os.Open("example.txt")
	if err != nil {
		panic(err)
	}
	defer file.Close()

	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		fmt.Println(scanner.Text())
	}
	if err := scanner.Err(); err != nil {
		panic(err)
	}
}

C++ Example for Reading Text Files

#include <iostream>
#include <fstream>
#include <string>

int main() {
    std::ifstream file("example.txt");
    if (!file.is_open()) {
        std::cerr << "Unable to open file" << std::endl;
        return 1;
    }

    std::string line;
    while (std::getline(file, line)) {
        std::cout << line << std::endl;
    }
    file.close();
    return 0;
}

Zig Example for Reading Text Files

const std = @import("std");

pub fn main() !void {
    var file = try std.fs.cwd().openFile("example.txt", .{ .read = true });
    defer file.close();

    var reader = std.io.bufferedReader(file.reader());
    var line: []u8 = undefined;

    while (try reader.readUntilDelimiterOrEofAlloc(std.heap.page_allocator, '\n', &line)) |hasNext| {
        if (hasNext) {
            std.debug.print("{}\n", .{line});
        }
    }
}

Binary Files: Reading Raw Data

Binary files require special handling since their content is not human-readable. They are used to store images, audio files, and serialized objects.

Python Example for Reading Binary Files

with open('example.bin', 'rb') as file:
    data = file.read()
    print(data)

PHP Example for Reading Binary Files

$data = file_get_contents("example.bin");
echo bin2hex($data);

Go Example for Reading Binary Files

package main

import (
	"fmt"
	"os"
)

func main() {
	data, err := os.ReadFile("example.bin")
	if err != nil {
		panic(err)
	}
	fmt.Println(data)
}

C++ Example for Reading Binary Files

#include <iostream>
#include <fstream>
#include <vector>

int main() {
    std::ifstream file("example.bin", std::ios::binary);
    if (!file.is_open()) {
        std::cerr << "Unable to open file" << std::endl;
        return 1;
    }

    std::vector<char> buffer((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
    file.close();

    for (char byte : buffer) {
        std::cout << std::hex << (int)(unsigned char)byte << " ";
    }
    return 0;
}

Zig Example for Reading Binary Files

const std = @import("std");

pub fn main() !void {
    var file = try std.fs.cwd().openFile("example.bin", .{ .read = true });
    defer file.close();

    const data = try file.readAllAlloc(std.heap.page_allocator);
    std.debug.print("{x}\n", .{data});
}

Line-by-Line vs Whole File Reading: Pros and Cons

Line-by-Line Reading

Pros: Memory efficient, suitable for large files.
Cons: Slower for small files as each line involves I/O operations.

Whole File Reading

Pros: Faster for small files, simpler implementation.
Cons: May consume significant memory for large files.

Python Example for Whole File Reading

with open('example.txt', 'r') as file:
    content = file.read()
    print(content)

Using Delimited and Structured Files

Delimited files like CSV or structured formats like JSON are common in data processing.

Python: Reading a CSV File

import csv

with open('data.csv', 'r') as file:
    reader = csv.reader(file)
    for row in reader:
        print(row)

PHP: Reading a CSV File

$file = fopen("data.csv", "r");
while (($row = fgetcsv($file)) !== false) {
    print_r($row);
}
fclose($file);

Go: Reading a CSV File

package main

import (
	"encoding/csv"
	"fmt"
	"os"
)

func main() {
	file, err := os.Open("data.csv")
	if err != nil {
		panic(err)
	}
	defer file.Close()

	reader := csv.NewReader(file)
	rows, err := reader.ReadAll()
	if err != nil {
		panic(err)
	}

	for _, row := range rows {
		fmt.Println(row)
	}
}

C++: Reading a CSV File

#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>

int main() {
    std::ifstream file("data.csv");
    if (!file.is_open()) {
        std::cerr << "Unable to open file" << std::endl;
        return 1;
    }

    std::string line;
    while (std::getline(file, line)) {
        std::istringstream ss(line);
        std::string cell;
        while (std::getline(ss, cell, ',')) {
            std::cout << cell << " ";
        }
        std::cout << std::endl;
    }
    file.close();
    return 0;
}

Zig: Reading a CSV File

const std = @import("std");

pub fn main() !void {
    const allocator = std.heap.page_allocator;
    const file = try std.fs.cwd().openFile("data.csv", .{ .read = true });
    defer file.close();

    var reader = std.io.bufferedReader(file.reader());
    var line: []u8 = undefined;

    while (try reader.readUntilDelimiterOrEofAlloc(allocator, '\n', &line)) |hasNext| {
        if (hasNext) {
            std.debug.print("{}\n", .{line});
        }
    }
}

Conclusion

Reading files is an essential skill in programming, offering access to vast amounts of stored data. Whether working with simple text files, binary formats, or structured data, the right approach depends on your requirements. By understanding file modes, line-by-line reading, and handling different file types, developers can efficiently work with data in any programming language.

Last modified: 26 January 2025