0:00
[MUSIC]
All right so now that we've looked at how to create basic and
raw value type enumerations, let's see how we can actually use enumerations.
When we're working with enumerations, either if they're
of basic enumeration type or a raw value type enumeration,
we often can use switches to eliminate a lot of if-else style of programming.
And the other benefit of using switches is that switches are exhaustive.
So one good thing is that enums and switches work really well hand in hand.
In the enum, we list out all the possible cases and in the switch,
we can make sure that we have provided the behavior that our program should perform.
For every possibility of that enum and the compiler will help us,
when we use a switch if we forget a case or
if we are are using an associated raw value type for our enum.
For example with int, we may have only
listed out cases in our enum for int values of zero, one, two and three.
But of course there are many more ints than just zero, one, two and three.
So we'll learn how to use a default statement to take care of.
All the other possible ints that could come in to that enum and
make sure that our switch is exhaustive.
That way we've guaranteed that we provided a behavior for
every possibility in that enum.
All right, we can use the init with raw value
initializer on any enum type that has a raw value.
2:12
So we'll see that in the playground, keep in mind that the type
may be inferred when assigning or comparing enumerations.
So, again, like we saw, we can often just say dot and
then the name of the case instead of having to write
the name of the eNum dot the name of the case, as we've seen earlier.
And let's go to the playground and see this in action.
All right, so let's look at using enumerations.
2:43
Here I have a function called showman count inside of my.
In numeration, Milky Way planet,
we'll talk about multiplying methods on an enum type in another lesson.
But for now, let's take a look at how we can use switch statements
to work with enums.
3:03
Okay, we could have created an array of moons and
asked for the count of that array.
We could have also had a moon count computed property to do that for us.
But because we can't actually store
the arrays of moons into a property on the enum type,
I showed you earlier that enum types do not support storage properties.
Then we would of had to type up the arrays of moons
once inside of our showMoonCount function and, as we'll see in just a moment,
we would have had to type it up in our showMoonNames function again.
So that's one of the limitations of enumerations is that we can't
hold all of the data for the object that we're modeling in the single
code object because stored properties are not supported.
4:26
So we have a switch, and notice how we have the switch keyword followed
by the value, excuse me, the object that will be switching over.
In this case we'll be switching over self, now because this function,
show moon count is inside of MilkyWayPlanet
itself here as an instance of the MilkyWayPlanet type.
So in other words it's going to be a planet.
5:26
and here I've list out the cases for
mercury, venus, earth, mars, Jupiter, Saturn, Uranus and Neptune.
Now that's fine, even though there are more ints than
0 through 7 we have eight cases here, but
it's going to start at 0 so 0 through 7 gives us eight cases
even though there are more numbers above 7
since I've referenced self, I'm just going to care about
the actual cases themselves and not their associated int values.
So this switch here is exhaustive because I've listed out a case for
each of the eight different cases that are enumerated
AKA listed out inside of my e-mail.
Okay, so now I've just gone and
hardcoded in the number of moons that we know exist for each of these planets, and
I'll later be able to show SomePlanet.ShowMoonCount and
get this value printed out in my console.
6:43
Let's look at another switch.
So here I have show moon names function.
Again this is a function inside of the milky way planet enum or
we say it's a method on the milky way planet type,
6:58
because it comes inside of the curly braces that define that type.
All right, so let's look at this second switch.
Now, here I have
a switch, and I'm switching over self, again.
7:17
Here I've done something different.
I looked at the case,
Milky Way planet with rawValue of zero.
So normally we wouldn't do this but I wanted to make the point that
since we have an associated rawValue type,
I can actually, excuse me, I can actually
create an instance of MilkyWayPlanet to be Represent mercury.
And then if self is equal to mercury
the switch will fall into this case of the switch,
and of course again we know mercury has no moons.
Let me just make one other point here, I put an exclamation point because there
may not be a case to find for raw value type of zero, in our case there is.
We know that there is because we just created that ENUM, but
we may not get a valid result from this initializer.
8:37
if I had put 8 here the result of that initializer would be nill.
So, I put this exclamation point here to say that the raw value,
initing with a raw value of zero, I know is definitely going to give me mercury, so
go ahead and force unwrap that value and treat it as a not nil valid value.
And we know, because we're the developer, that it will come out to be mercury.
Okay, now look at what else is going on here in this switch.
I have the case for Venus, a case for Earth.
We know Earth's moon is called Luna, so
I can show the moon name, that's what this function is trying to do.
I have Mars and Neptune, but notice that I have left out a couple of planets.
9:26
To make sure that this switch is exhaustive,
I've put in a default case here.
Let me show you why.
If I comment out the default case for a moment, the compiler will complain at me,
and it will say switch must be exhaustive, consider adding default clause.
9:47
All right, so that means that there are more cases in the enum that were switching
over than I've listed out cases for in the switch.
So, I could either do what I did up here and
make sure that I list out every single different case, or
I can do what the compiler is suggesting.
I don't want to say, it's not recommending that I do,
it's just suggesting it, in putting your default clause.
So, I have said, in other words, if you are not Mercury,
we know that this evaluates to Mercury, we just talked about that.
So in other words, if you're not Mercury, or you're not Venus, or Earth, or Mars, or
Neptune, then let's go into this default case and say this planet has too many
moons to list, because some of the planets in the Solar System we know have 27, 50,
53 moons, and for the sake of this presentation, and also in a real
application it might not really make sense to list out that much information.
You have to decide what is right for your implementation.
Justin-Nicholas ToyamaUCI Extension Instructor
Frank AyarsUCI Extension Instructor
Ralf BrockhausUCI Extension Instructor
