Using Enumerations Part 1

Loading...

En provenance du cours de University of California, Irvine

Toward the Future of iOS Development with Swift

74 notes

University of California, Irvine

Toward the Future of iOS Development with Swift

74 notes

Cours 5 sur 6 dans Specialization iOS Development for Creative Entrepreneurs

An introduction to the Swift programming language. This will prepare you for more extensive iOS app development and build a foundation for advanced iOS development topics. Upon completing this course, you will be able to: 1. Associate the relationship of Swift and Objective-C and their use in iOS and Mac (OS X) programming 2. Develop the ability to read and write Swift code 3. Distinguish how both programming languages can be used together in applications 4. Demonstrate how to write applications entirely in Swift with the help from several iOS programming samples 5. Determine how Swift can be used for development on new platforms such as Apple Watch and Apple TV 6. Create a working client-server iPhone application with location services that you can add to your portfolio.

À partir de la leçon

Looking Further into Swift

The content for this week will build on the knowledge and examples from the previous week. You will start combining the basic programming skills studied in the previous week to start manipulating data in functions and learn how functions can be used in different Types (i.e. enums, structs, classes). This will prepare you for working in a full application setting, which will be the focus of Week 4. You will learn about some of the more advanced Swift programming language features that are often useful in bringing together a complete system like a full-blown iPhone application.

How to Create Basic Enumerations7:25

How to Create Raw-Value Enumerations8:48

Using Enumerations Part 111:17

Using Enumerations Part 25:33

Using Enumerations Part 37:35

Enumerations Methods and Limitations4:26

Rencontrer les enseignants

Justin-Nicholas Toyama
UCI Extension Instructor
Lead iOS Developer at Smilefish Corporation
Frank Ayars
UCI Extension Instructor
CTO and Director of Software Development at Smilefish Corporation
Ralf Brockhaus
UCI Extension Instructor
Founder and CEO at Smilefish Corporation

[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.

To convert raw values from just their normal int, or string value,

or whatever your raw value type is, into an instance of that enum case.

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.

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.

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.

All right, so

in order to use emos to represent the planned data that we've been.

Working within the examples so

far, we'll break that information out into these different functions.

Okay, so let's look at how this showMoonCount function works.

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.

So I can say switch over self and if self is of the case Mercury.

Then print 0 because we're trying to show the Moon count and Mercury has no moons.

So I'll list out all of the different cases that might supports.

Now, notice that Milky Way planet is an int type

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.

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,

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.

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.

If for example we typed init with a raw value of 8,

well we know our raw values only go from 0 through 7, so

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.

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.

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.

My point here is to show you how to use.

A default case to satisfy that requirement that you're switch be exhaustive.

[MUSIC]

Explorer notre catalogue

Rejoignez-nous gratuitement et obtenez des recommendations, des mises à jour et des offres personnalisées.

Coursera propose un accès universel à la meilleure formation au monde, en partenariat avec des universités et des organisations du plus haut niveau, pour proposer des cours en ligne.

© 2019 Coursera Inc. Tous droits réservés.

Télécharger dans l'App Store

Disponible sur Google Play