In this tutorial, you are going to learn about the Swift enum (Enumerations) with some examples. Enum is the short form of Enumerations.
In Swift programming, an enum or enumeration is a user-defined data type that consists of a fixed set of related values. It enables Swift programmers to work with those values in a type-safe way within the code.
To create an enum in Swift, we use the enum
keyword as you can see below:
enum City {
case London, Chicago, Delhi, Geneva
}
In the above example, City
is the name of the enum. London, Chicago, Delhi and Geneva are the values defined inside our enum.
As enum is a data type in Swift, you can create variables for the enum type like you can see below:
var currentCity: City
In the above example, currentCity
is a City type variable. We have previously assigned values in City
.
In our variable of the City enum type, we can only store the values present in the enum. In our case, we can only store values between London, Chicago, Delhi, Geneva
.
In the example below, we are storing a value in our enum type variable:
// assigning Geneva to the currentCity variable
var currentCity = City.Geneva
In the example above, we have assigned a member value Geneva
to the enum variable currentCity
.
enum City {
case London, Chicago, Delhi, Geneva
}
// Creating the enum variable of City type
var currentCity: City
// assigning Geneva to the City variable
currentCity = City.Geneva
print("Current City is:", currentCity)
Output:
Current City is: Geneva
Swift provides a protocol that is the CaseIterable
protocol. Using the for loop, we can easily iterate over enum cases if we set the CaseIterable
protocol to the enum. We just need to set this protocol at the time of creating the enum.
Below is how to set the CaseIterable
protocol for an enum:
enum City: CaseIterable {
....
}
And below is given how to use the for loop to iterate over the enum cases:
for currentCity in City.allCases {
...
}
You can see that we are using the allCases
property to loop through the enum cases. Inside for loop
we will write our code to get all the enum cases.
Below is an example where we are iterating over the cases values of a Swift enum:
// Creating the enum with CaseIterable protocol
enum City: CaseIterable {
case London, Chicago, Delhi, Geneva
}
// Iterating over the cases value of enum using for loop
for currentCity in City.allCases {
print(currentCity)
}
Output:
London
Chicago
Delhi
Geneva
In the above example, we have created an enum City
with the protocol CaseIterable
. After that, we use the for-loop. We are using the allCases property with the Swift for loop to iterate over the cases of the enum.
Now it’s time to see how we can use the enum with the switch statement in Swift.
Below is an example where we are using an enum with a switch statement:
enum City {
case London, Chicago, Delhi, Geneva
}
// Creating enum variable of City type
var currentCity = City.Delhi
// Using enum with switch statement
switch(currentCity) {
case .Chicago:
print("I am in Chicago.")
case .Delhi:
print("I am in Delhi")
case .Geneva:
print("I am in Geneva");
case .London:
print("I am in London");
}
Output:
I am in Delhi
We can also assign values to each of the enum cases like you can see in the code sample below:
enum Price : Int {
case low = 5000
case high = 9500
...
}
In the above example, we have assigned 5000 to the low
case and 9500 to the high
case. These values we assigned in this example are called the raw values.
You can see that we have used the Int
keyword with our enum name which defines that the cases in the enum only can take integer raw values.
If we want to access raw value from our enum, then we can do it easily. Below is how we can access a raw value:
// access raw value
Price.low.rawValue
Below is the example:
enum Price : Int {
case low = 5000
case high = 9500
}
// access raw value
var priceLow = Price.low.rawValue
print(priceLow)
Output:
5000
In our above example, we have first created an enum Price
. We have created two raw values low
and high
that can accept only integer types of values. After that, we are accessing the raw value of low
using the rawValue
property in Swift.
In this example, we have created the raw values of integer types. But it can also be of strings, characters, integers, or floating-point number types.
We can also attach additional information to a Swift enum case just like below:
enum Employer {
// associate value
case fullName(String)
...
}
In the above code, we have attached a string type in the fullName
case.
Now below is given how we are assigning the associated value to the case:
Employer.fullName("Linda Anderson")
Now see the example below:
enum Employer {
// associate value of string type
case fullName(String)
//associate value of integer type
case age(Int)
}
// Assigning string type value to fullName
var employerName = Employer.fullName("Linda Anderson")
print(employerName)
// Assigning integer type value to age
var employerAge = Employer.age(28)
print(employerAge)
Output:
fullName("Linda Anderson")
age(28)
In the example above, the string type associated value Linda Anderson
is assigned to the fullName
case. On the other hand, the integer type associated value 28
is assigned to the age
case.