Getting the Day of Week in Swift: Evolution from NSDate to Calendar and Practical Implementation

Core Principles of Date Format Configuration

When processing date strings in Swift, correctly configuring the dateFormat property of NSDateFormatter is crucial. A common mistake is using the format "YYYY-MM-DD", where "YYYY" represents the week-based year and "DD" represents the day of the year, which may lead to incorrect date parsing. The correct format should be "yyyy-MM-dd", where "yyyy" denotes the calendar year and "dd" denotes the day of the month. For example, for the string "2014-08-27", the proper parsing approach is as follows:

let formatter = DateFormatter()
formatter.dateFormat = "yyyy-MM-dd"
let todayDate = formatter.date(from: "2014-08-27")

This format adheres to the Unicode Technical Standard #35 specification, ensuring consistency across platforms and locales.

Correct Methods for Extracting Calendar Components

The core of obtaining the day of the week lies in correctly using Calendar's component method. In the original problem, the developer attempted to use NSCalendarUnit.WeekdayOrdinalCalendarUnit, which actually retrieves the ordinal of the weekday within the month, not the weekday itself. The correct calendar unit is .weekday, and the corresponding NSDateComponents property is also weekday.

In Swift 3 and later, the API has been significantly simplified. Here is a complete function implementation:

func getDayOfWeek(_ today: String) -> Int? {
    let formatter = DateFormatter()
    formatter.dateFormat = "yyyy-MM-dd"
    guard let todayDate = formatter.date(from: today) else { return nil }
    let myCalendar = Calendar(identifier: .gregorian)
    let weekDay = myCalendar.component(.weekday, from: todayDate)
    return weekDay
}

This function returns an integer from 1 to 7, where 1 represents Sunday and 7 represents Saturday. The guard statement with optional binding ensures nil is returned for invalid input strings, enhancing code robustness.

Swift Version Evolution and Best Practices

From Swift 2 to Swift 4, date handling APIs have undergone significant changes. In Swift 2, the code was more verbose:

func getDayOfWeek(today: String) -> Int? {
    let formatter = NSDateFormatter()
    formatter.dateFormat = "yyyy-MM-dd"
    if let todayDate = formatter.dateFromString(today) {
        let myCalendar = NSCalendar(calendarIdentifier: NSCalendarIdentifierGregorian)!
        let myComponents = myCalendar.components(.Weekday, fromDate: todayDate)
        let weekDay = myComponents.weekday
        return weekDay
    } else {
        return nil
    }
}

Swift 3 introduced cleaner syntax, renaming NSDate to Date, NSCalendar to Calendar, and simplifying component extraction. DateComponents no longer requires explicit unwrapping, as values can be directly obtained via Calendar's component method.

Extension Methods and Localized Output

Beyond obtaining the numeric representation of the day of the week, practical development often requires localized text output. This can be achieved by extending the Date class:

extension Date {
    func dayOfWeek() -> String? {
        let dateFormatter = DateFormatter()
        dateFormatter.dateFormat = "EEEE"
        return dateFormatter.string(from: self).capitalized
    }
}

Here, the "EEEE" format retrieves the full weekday name, such as "Monday" or "Tuesday". The capitalized method ensures proper capitalization according to English conventions. For locale-specific requirements, the capitalized(with: locale) method can be used.

Error Handling and Code Optimization

In practical applications, boundary cases and error handling must be considered. The original code used force unwrapping (!), which could cause runtime crashes with incorrectly formatted input strings. The improved version uses optional types and guard statements to safely handle invalid input.

Additionally, constants (let) should be preferred over variables (var) unless values genuinely need to change. This aids compiler optimization and code readability. For instance, formatter and calendar do not change during function execution and should be declared as constants.

Practical Application Examples

The following complete usage example demonstrates how to safely call the function and process results:

if let weekday = getDayOfWeek("2014-08-27") {
    print("Numeric representation of weekday: \(weekday)") // Output: 3 (representing Tuesday)
    
    let date = Date() // Get current date
    if let weekdayName = date.dayOfWeek() {
        print("Text representation of weekday: \(weekdayName)") // Output: Wednesday
    }
} else {
    print("Invalid date format input")
}

This example combines both numeric and text output methods, showcasing flexible application in real-world scenarios.

Summary and Recommendations

Obtaining the day of the week in Swift involves several key aspects: correct date format configuration, accurate extraction of Calendar components, proper error handling, and API version adaptation. Developers are advised to:

1. Always use the "yyyy-MM-dd" format for parsing date strings
2. Use the .weekday calendar unit to obtain the day of the week
3. Safely handle optional values, avoiding force unwrapping
4. Choose appropriate APIs based on the Swift version
5. Consider using extension methods to improve code reusability

By following these best practices, robust and maintainable date handling code can be written to meet various application requirements.