Static and Mutating Methods with self

    Let’s make it practical

    Practical with Storyboard

    Create an enum called Storyboard with raw value, String. It contains a computed property called, identifier whose type is String.

    You no longer have to type manually.

    1. let profile = Storyboard.profile
    2. profile.identifier // "profile"

    Hypothetically, you may need to create a function with a parameter whose type is Storyboard.

    1. func describeStoryboard(storyboard: Storyboard) -> String {
    2.   switch storyboard {
    3.   case .profile:
    4.     return "\(storyboard.identifier): Profile picture, followers"
    5.   case .setting:
    6.     return "\(storyboard.identifier): Logout, invite"
    7.   case .newsfeed:
    8.     return "\(storyboard.identifier): videos, texts"
    9.   }
    10. }

    Instead of typing manually, you are able to pick and choose any cases within Storyboard. Look familar?

    1. describeStoryboard(storyboard: .profile)

    Mutating Method

    You may create a mutating function that mutates its own case.

    1. enum MealProcess: String {
    2.   case breakfast, lunch , dinner
    4.   var description: String {
    5.     return self.rawValue
    6.   }
    8.   mutating func nextMeal() {
    9.     print("Time to move on from \(self.description)")
    11.     switch self {
    12.     case .breakfast:
    13.       self = .lunch
    14.       print("I had a nice lunch")
    15.     case .lunch:
    16.       self = .dinner
    17.       print("I had a nice dinner")
    18.     case .dinner:
    19.       self = .breakfast
    20.       print("I had a nice breakast")
    21.     }
    22. }

    Let us initialize an object with the breakfast case and call the nextMeal() function.

    Create an enum called, AppleDevices. It contains a static function which returns AppleDevices based on the name of the parameter used in the function.

    1. enum AppleDevices {
    2.   case iWatch, iPhone, iMac, MacPro
    4.   static func getAppleDevice(name: String) -> AppleDevices? {
    5.     switch name {
    6.     case "iWatch":
    7.       return .iWatch
    8.     case "iPhone":
    9.       return .iPhone
    10.     case "iMac":
    11.       return .iMac
    12.     case "MacPro":
    13.       return .MacPro
    14.     default:
    15.       return nil
    16.     }
    17.   }
    18. }

    You may return an initialized enum object by calling getAppleDevice.

    1. let userProduct = AppleDevices.getAppleDevice(name: "iWatch")
    2. print(userProduct) //  AppleDevices.iWatch

    Let us refactor using raw value.

    1. enum AppleDevices: String {
    2.   case iWatch, iPhone, iMac, MacPro
    4.   static func getProduct(name: String) -> AppleDevices? {
    5.     return AppleDevices(rawValue: name)
    6.   }
    8.   static func getAppleDevice(enterName: String) -> AppleDevices? {
    9.     switch enterName {
    10.     case "iWatch", "iPhone", "iMac", "MacPro":
    11.       return getProduct(name: enterName)
    12.     default:
    13.       return nil
    14.     }
    15.   }
    16. }

    Looks nice and zen.

    Custom Init

    You may add a custom init method to create an object you wish.

    1. enum AppleDevice: String {
    2.   case iWatch, iPhone, iMac, MacPro
    4.   init?(name: String) {
    5.     if name == "iWatch" {
    6.       self = .iWatch
    7.     } else {
    8.       return nil
    9.     }
    12. AppleDevice(name: "iWatch")
    13. AppleDevice(rawValue: "iWatch")

    Another example with number category.

    You may organize a group of HTTP instructions using enums instead of multiple tuples.

    1. //: HTTP Request
    2. enum HttpError: String {
    3.   case Code400 = "Bad Request"
    4.   case Code401 = "Unauthorized"
    5.   case Code402 = "Payment Required"
    6.   case Code403 = "Forbidden"
    7.   case Code404 = "Page Not Found"
    9.   var description: String {
    10.     return self.rawValue
    11.   }
    12. }
    14. HttpError.Code400.description

    Like Storyboard, you want to limit typing with your fingers. Instead, pick and choose.

    1. enum CellType: String {
    2.   case ButtonValueCell = "ButtonValueCell"
    3.   case UnitEditCell = "UnitEditCell"
    4.   case LabelCell = "LabelCell"
    5.   case ResultLabelCell = "ResultLabelCell"
    7.   var name: String {
    8.     return self.rawValue
    9.   }
    10. }
    1. import UIKit
    3. enum NavigationTheme {
    4.   case Placid
    5.   case Warning
    6.   case Danger
    8.   var barTintColor: UIColor {
    9.     switch self {
    10.     case .Placid: return UIColor.clear
    11.     case .Warning: return UIColor.blue
    12.     case .Danger: return UIColor.red
    13.     }
    14.   }
    15. }

    You may get barTintColor based on the enum case.

    1. let colorSituation = NavigationTheme.Placid
    2. colorSituation.barTintColor

    Enums also support extension. Let us add a custom init.

    The example above is useful for coloring a to-do list app.

    Let us retrieve barTintColor based on numberOfTasks.

    1. let currentColor = NavigationTheme(numberOfTasks: 10).barTintColor

    Conclusion

    You’ve tasted the power of enums. Again, no more typing. In your head, you should be thinking how to deploy enums to beautify your previous projects. If the iOS engineers have not used enums for any APIs, for instance, , we, developers, have to memorize and type all day while checking the documentation unlimited times. Use it for your advantage as well.

    In the following lesson, you will learn how to add multiple enums within a single enum.

    Note: Learn Swift with Bob is available on . If you wish to receive a discount link, you may sign up here.