Friday, June 21, 2024
HomeIOS DevelopmentWhat are enums in Swift? – Donny Wals

What are enums in Swift? – Donny Wals


Swift comes with varieties of objects that we will use to write down kind declarations. All of them have their very own distinct options, upsides, and disadvantages. On this put up I’d prefer to zoom in on the enum kind so you will get a way of what enums are, and when they are often helpful.

On this put up we’ll cowl the next matters:

  • Understanding the fundamentals of enums
  • Figuring out when an enum must be used
  • Avoiding enum overuse

Let’s soar proper in!

Understanding the fundamentals of enums

In Swift, enums are values varieties which are declared utilizing the enum key phrase. Each potential worth of the enum is named a “case”. Enums can both be used as an inventory of circumstances that fashions particular (mutually unique) values or constants. For instance, we may signify an inventory of working programs for SwiftUI apps as follows:

enum OperatingSystem {
  case iOS, iPadOS, macOS, visionOS, tvOS, watchOS
}

If we have been to cross an working system to a operate or assign it to a variable, that will look a bit of like this:

// assigning a variable
var os: OperatingSystem = .macOS

// or passing to a operate
let binary = buildAppBinaryFor(.watchOS)

Since enums are firstclass residents in Swift, they’ll conform to protocols, outline capabilities, and even have computed properties. Word which you can’t add saved properties to an enum like you’ll be able to to a struct.

Enums are extremely helpful when we have to signify a finite set of predefined states. With a enum, it’s not possible to create or use state that aren’t right which might be extremely helpful. Think about that you simply’d need to manually kind out an animation kind as a string in SwiftUI as an alternative of passing .easeInOut and understanding that in case your code compiles you handed an accurate animation kind. In the event you needed to cross the string "easeInOut" the compiler wouldn’t be capable to kind test that you simply handed a sound worth and you may be bitten by typos equivalent to "aeseInOut" which isn’t splendid.

Though you’ll be able to’t leverage saved properties when utilizing enums, you’ll be able to affiliate values with enums and you may give them uncooked values.

An enum with uncooked values seems to be like this:

enum OperatingSystem: String {
  case iOS = "iOS"
  case iPadOS = "iPadOS"
  case macOS = "macOS"
  // and many others...
}

On this case, my uncooked enum values match the enum case names instantly. Which means that as an alternative of including each potential worth after the case identify, I can specify that my enum makes use of a uncooked String worth with out modifying my circumstances:

enum OperatingSystem: String {
  case iOS, iPadOS, macOS, visionOS, tvOS, watchOS
}

Defining enums with uncooked values is extremely helpful once you need to create your enum values from exterior assets like once you’re decoding JSON. Having uncooked values lets you create enum cases like this:

let os: OperatingSystem? = OperatingSystem(rawValue: "iOS")

In fact, when hardcoding the uncooked worth it will be a lot better to only use .iOS instantly but when the uncooked worth comes from an exterior supply we will attempt to make an enum with the worth we obtained. If this works, we get an enum case again and if not, we get nil. This occurs after we cross a uncooked worth that’s not outlined on the enum.

The very last thing I’d like to indicate you earlier than we speak about up and draw back of enums is defining an enum with an related worth.

An instance of such an enum is Swift’s built-in Consequence kind:

enum Consequence<Success, Failure: Error> {
    case success(Success)
    case failure(Failure)
}

This enum makes use of generics to permit builders to make use of customized values for Success and Failure however you may as well outline an enum with out generics for related values. For instance:

enum Animation {
  case none
  case easeIn(period: CGFloat)
  // ...
}

With this Animation enum we will cross completely different animation configurations which are all grouped as potential values underneath a single kind. That is tremendous handy!

In the event you get to a degree the place you’d like to check some worth to an enum case that has an related worth, you’ll need to learn up on if case let syntax utilizing this put up I’ve on that matter.

Now that you understand a bit about what enums are, let’s talk about when it is smart to make use of them.

Figuring out When to Use an Enum

Enums are perfect for managing a set group of associated values in a method that makes your code clearer and safer. Studying to acknowledge when an enum would make sense is a key ability that can actually provide help to to write down higher and safer code over time.

The record under can be utilized that can assist you work out whether or not an enum matches your present use case:

  • Enums are excellent when a variable can solely take a restricted set of predetermined values. In the event you’re coping with choices, states, or modes inside your software which are finite and recognized, enums assist implement this constraint with the assistance of the compiler.
  • Enums are wonderful for managing state in your purposes. For example, you probably have a UI management with a number of states like lively, inactive, disabled, and many others., an enum ensures you deal with all potential states whereas additionally stopping builders from passing not possible or incorrect states.
  • In the event you’re utilizing constants which are intently associated and must be grouped underneath a single kind, enums make this group clear and logical. For instance, error varieties, configuration choices, and different comparatively brief finite lists of values.

Over time you’ll develop increasingly assured in your potential to know whether or not an enum is smart in your use case. I believe it’s essential to know that not every little thing can or must be represented as an enum.

For instance, I believe it’s clever to be sure that your enums are pretty small. An enum that holds dozens of circumstances might be too giant and also you’re not grouping intently associated values collectively. It may make sense to refactor your giant record of circumstances right into a smaller record that makes use of related values to group sub-values collectively.

It’s additionally a good suggestion to maintain a detailed eye on how Apple makes use of enums in Swift and SwiftUI themselves. Utilizing enums for related eventualities ought to offer you some confidence that you simply’re choosing the proper instrument for the job.

And when unsure, check with the record above and belief your instincts; they is perhaps higher than you assume.

RELATED ARTICLES

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Most Popular

Recent Comments