Parsing CSV Files in Swift

In this lesson, we will explore working with CSV files — a prevalent format used for data storage and interchange. By the end of this lesson, you will learn how to read data from CSV files, identify rows and columns separated by commas, and convert string data into integers for further manipulation. This lesson builds on your existing knowledge of file parsing in Swift and introduces new techniques to enhance your data-handling capabilities.

CSV stands for Comma-Separated Values and is a format that stores tabular data in plain text. Each line represents a data row, and columns are separated by commas, allowing for easy storage and interpretation.

Imagine you have a CSV file named data.csv:

Name,Age,Occupation
John,28,Engineer
Alice,34,Doctor
Bob,23,Artist

In this file:

• The first line contains the headers: Name, Age, and Occupation.
• Each subsequent line contains data for an individual, with values separated by commas.

Understanding the structure of CSV files is crucial as it guides us on how to parse the data effectively in our programming environment.

To effectively manage the data lines from a CSV file, we can use Swift arrays to represent our rows of data and structs to provide a more organized representation if needed.

struct Person {
    let name: String
    let age: Int
    let occupation: String
}

var parsedCSVData = [[String]]()

Here, we define a struct Person to encapsulate the data structure for each individual from the CSV file and a 2D array parsedCSVData to store raw CSV lines as arrays of strings for easy parsing and manipulation.

Let's start reading the CSV file using Swift's String(contentsOfFile:) which allows us to handle file input easily.

import Foundation

let fileURL = URL(fileURLWithPath: "data.csv")
do {
    let fileContent = try String(contentsOf: fileURL)
    // ...
} catch {
    print("Error reading file:", error)
}

Here, we utilize String(contentsOfFile:) to read the entire content of the CSV file into a string. It's wrapped in a do-catch block to ensure error handling, allowing us to process the file safely.

With the entire content loaded as a string, we use Swift's string manipulation methods to parse it into a structured format.

let lines = fileContent.components(separatedBy: "\n")
// Skip the header line
for i in 1..<lines.count {
    let line = lines[i]
    if !line.isEmpty {
        let values = line.components(separatedBy: ",")
        
        // Convert values to Person struct
        if values.count >= 3, let age = Int(values[1]) {
            let person = Person(
                name: values[0],
                age: age,
                occupation: values[2]
            )
            // Add to an array of Person objects
            parsedPeople.append(person)
        }
        
        // Also keep the raw data
        parsedCSVData.append(values)
    }
}

In this code snippet:

• We split the file content into lines using components(separatedBy: "\n").
• We skip the header line (index 0) and process only data rows.
• Each line is split into values using components(separatedBy: ",").
• We convert the raw string values into a Person struct, handling the conversion of age from String to Int.
• We store both the structured data (as Person objects) and the raw data (as string arrays).

To verify that the CSV data is correctly parsed and stored, we can print both the raw data and the structured objects:

// Add this at the beginning of the code
var parsedPeople = [Person]()

// Then after parsing, print both representations
print("Parsed CSV Raw Data:")
for record in parsedCSVData {
    print(record)
}

print("\nParsed Person Objects:")
for person in parsedPeople {
    print("Name: \(person.name), Age: \(person.age), Occupation: \(person.occupation)")
}

In this lesson, we covered how to parse CSV files in Swift, focusing on reading data with commas as delimiters. You've learned how to use arrays as flexible structures for holding parsed data and how to use Swift's file-reading and parsing techniques to effectively handle and manage CSV content.

As you move on to practice exercises, remember to verify the correctness of your parsed data and reflect on potential applications of what you've learned. Keep up the excellent work and continue exploring more advanced data-handling techniques in Swift.