Writing Table Data to Text and CSV Files Using Swift

Welcome to this lesson on writing table data to text files using Swift. Efficiently storing and sharing data is crucial in today's digital environment. Text files are popular due to their simplicity and broad compatibility. This lesson focuses on writing formatted table data into text and CSV files using Swift, leveraging Swift's built-in file-handling capabilities.

By the end of this lesson, you will be able to take a structured data format and write it to text and CSV files using Swift. Let’s dive into this skill and build on what you've learned about parsing tables from text and CSV files.

Before proceeding, let's briefly review two key concepts: Arrays in Swift and basic file handling.

• Arrays: Swift arrays let you store a collection of items, such as rows in a table. Organizing your data into an array format is essential for structured data management.

• File Handling: We've previously covered basic reading operations using String(contentsOfFile:). Now, we'll explore writing data. Swift offers straightforward file manipulation using FileManager, FileHandle, or OutputStream.

These foundational concepts will guide us in the process of writing table data into a text file.

Firstly, we'll define a Person struct, which will serve as the blueprint for our data entries. In this struct, each Person instance has fields corresponding to the columns in our table:

struct Person {
    var name: String
    var age: String
    var occupation: String
}

With our structure in place, we create an array of Person structs. This array, data, acts as a collection of rows where each Person instance signifies an individual record:

let data: [Person] = [
    Person(name: "John", age: "28", occupation: "Engineer"),
    Person(name: "Alice", age: "34", occupation: "Doctor"),
    Person(name: "Bob", age: "23", occupation: "Artist")
]

In this example, we've added three Person structs to our array, each representing a row with fields for name, age, and occupation. This structured approach simplifies the process of adding or modifying rows, facilitating the seamless writing of data to files.

Next, let's write data to a text file with tab delimiters using Swift methods. Here's an example of how to do it:

import Foundation

let fileURL = URL(fileURLWithPath: "output.txt")
let header = "Name\tAge\tOccupation\n"

do {
    try header.write(to: fileURL, atomically: true, encoding: .utf8)
    for person in data {
        let line = "\(person.name)\t\(person.age)\t\(person.occupation)\n"
        try line.append(to: fileURL)
    }
    print("Data successfully written to output.txt (tab-separated).")
} catch {
    print("Failed to write to file: \(error)")
}

extension String {
    func append(to url: URL) throws {
        if let data = self.data(using: .utf8) {
            if FileManager.default.fileExists(atPath: url.path) {
                let fileHandle = try FileHandle(forWritingTo: url)
                defer { fileHandle.closeFile() }
                fileHandle.seekToEndOfFile()
                fileHandle.write(data)
            } else {
                try write(to: url, atomically: true, encoding: .utf8)
            }
        }
    }
}

• Create the Output File: The header Name\tAge\tOccupation is written using write(to:atomically:encoding:).
• Format the Data: Each Person struct is converted into a tab-delimited line.
• Write to File: Each formatted line is appended to the text file, ensuring each entry appears on its own line.

In addition to writing to a text file with tab delimiters, you may also need to write the data in CSV (Comma-Separated Values) format. Here's how you can achieve this in Swift:

let csvFileURL = URL(fileURLWithPath: "output.csv")
let csvHeader = "Name,Age,Occupation\n"

do {
    try csvHeader.write(to: csvFileURL, atomically: true, encoding: .utf8)
    for person in data {
        let csvLine = "\(person.name),\(person.age),\(person.occupation)\n"
        try csvLine.append(to: csvFileURL)
    }
    print("Data successfully written to output.csv (comma-separated).")
} catch {
    print("Failed to write to file: \(error)")
}

This code writes the structured data to output.csv using a comma character as the delimiter, ensuring each entry is placed on a new line.

In this lesson, you learned how to effectively structure, write, and verify data stored in a text file using Swift. We started by preparing data using Arrays and struct definitions, then utilized Swift's file-handling techniques to write this data using tabs and commas as delimiters.

We encourage you to engage with the practice exercises that follow this lesson. Apply what you've learned to reinforce your understanding and gain confidence. Keep experimenting with different data structures and adapt them to ensure your outputs meet your expectations. Well done on progressing through this important lesson.