TOMMY MACWILLIAM: So let's get
started writing our first iOS app.
So all of the iOS apps
that we write are going
to be written in a program called Xcode.
So Xcode is an IDE or Integrated
Development Environment
that's put out by Apple, and
it contains all of the tools
that you're going to need
to write apps for iOS.
But before we get into that, let's first
take a look at the programming language
that you'll be using to
write all of your iOS apps.
So all of iOS apps are written in Swift.
You might see online that
there is another language out
there called Objective-C that you can
also use, but it's a bit outdated.
And Swift is what Apple
currently recommends
to write all of your iOS apps in.
So Swift is pretty
similar to C, but there
are a few differences that we're
going to go through right now.
The first is variables.
So when you're writing in C
and you create a variable,
every variable is what's called mutable.
And a mutable variable means
once you have a variable,
you can change its value.
You can create an integer called x.
You can set it equal to 5.
And if you want to change it
later to be 50, you can do that,
and that's no problem.
In Swift, there's a distinction between
mutable and immutable variables, where
an immutable variable
once you declare it,
you can never change that value again.
So think about it as a constant.
And, actually, a lot of
the variables that you're
going to create while you're writing
iOS are going to be constant.
So if you're creating
a constant variable
in Swift, which we're
going to do a lot of,
you are going to start the
variable with the word let.
If instead you want to
make it mutable, you
can start the variable
with the word var.
So if you're ever looking
at some source code
and you want to know if a
variable is mutable or not,
you just have to find
where it's declared.
If it says let, it's not.
If it's says var, it is.
So Swift just like C has a
bunch of built-in data types,
and they're pretty similar
to what you've seen before.
You've got Integers,
Doubles, Floats, Strings,
and you notice that all
of these are capitalized.
And Swift also has a
few other built-in data
types that we'll take a look at like
Arrays, Dictionaries, and so on.
So here's our first line
of Swift that we can write.
So you'll see here that we
have a variable called title.
Because it starts with let,
this is an immutable variable,
which means we can't change its value.
If we try, then the Swift
compiler is going to yell at us.
And then after the variable's
name, we have a colon.
And then we have the
type of the variable.
So it's a little bit different than C.
In C, we put the type first and
then have the variable name.
Here we have the name of the
variable first, a colon, and then
the type of the variable.
So this is a String, and then
we have the equals sign and then
the value of the variable.
So in the next line, we're
declaring a mutable variable.
So we started it with the word var.
We call this variable count.
And you'll notice here that I
didn't give this variable a type.
And this is one of the
first new features of Swift
that we'll see compared
to C is that Swift can
infer the type of the variable for you.
So because it says count equals 50 and
that right hand side of the assignment
is an integer, the Swift
compiler can look at that
and say, OK, count must
be an integer because it's
being assigned to an integer value.
So you don't need to
tell me that it's an int.
I can figure that out for you.
And then in the next
line just as we did in C,
we can just change the value of
that variable and keep going.
So, next, let's look at conditions.
They're pretty similar to
what we've seen before.
So in this first line, we're
just creating a new constant.
It's a string variable
of the value of iOS.
And then here we have a condition.
You'll notice here that
in Swift we don't need
to put parentheses around conditions.
This is kind of nice.
Swift basically says, well, we
know the thing after the word
if is going to be a condition so there's
no need to put parentheses around that.
So you're not going to see them
in any of the code that we write.
You can express or and
and in the same way
you did in C with a double
ampersand or a double pipe.
And then in Swift to print
something to the screen,
you can just use the print function.
It's similar to printf, but you can
print out a whole bunch of different
values without needing to do
%d, or %f, or any of that stuff.
And then else's work the same way.
Next, let's look at arrays.
So same syntax as before
for declaring a variable.
We can say let.
Then we have the name
of our variable, which
is values, a colon, and then the type.
And you can see here to
create an array of integers,
I'm going to use brackets and just
put Int inside of those brackets.
And that tells the Swift compiler
that this is an array of integers.
And then to declare the
array, just open bracket,
have your values, and
then a close bracket.
Again, if we wanted to omit the type
of this variable, that would be OK
because a Swift compiler can see
the right-hand side of this variable
is a list of Ints.
So that's the type of that's variable.
And then to iterate
through this array, Swift
has this cool operator called for-in.
So we can just say for value in
values and iterate through this array.
So on the first run of this loop,
the value of value will be 1,
and we'll print out one.
On the second iteration of this
loop, it'll be 2 and so on.
So it's just kind of nice.
You don't have to do the whole
crazy syntax of Int i equals 0.
i is less than values.count. i++.
Swift has this kind of syntactic
sugar to shorten that a bit for you.
So another data type that we'll
see a lot in Swift is dictionaries.
So you can think of a dictionary as
a mapping between keys and values.
So in this example here,
I've created a dictionary
that maps string keys to string values.
So you see here in my type that I
have in brackets String colon String,
and that says that the type
of the keys in this dictionary
is going to be strings.
And then the type of values in this
dictionary is also going to be strings.
And then when I declare
these values, you
can see that I have my
key, so SFO is our key.
And then our value for
that key is San Francisco.
So what I'm basically doing
is mapping airport codes
to the names of those airports.
So Boston's code is BOS.
So I have a key of BOS
and a value of Boston.
Now to iterate through
this dictionary rather,
I can use that sort of
same syntax as before.
I can say for this time
in parentheses code, name.
Here code is going to be
the key in the dictionary,
and name is going to be the
value in the dictionary.
Then I just say the name
of the dictionary itself,
so I'll say airports.
And then I'm going to print
out the code and the name.
And you'll see here that we
have sort of a new syntax
here where you'll see this backslash
and then in parentheses code
and then backslash in parentheses name.
This is something that's
called string interpolation.
And what that means is rather than
printing out backslash parentheses
code, Swift is actually going to take
the value of the variable called code
and print that instead.
So if you're used to
writing C with printf, %d,
it's sort of the same
thing, just a nicer syntax.
Rather than saying %s, code, we can just
put in this backslash in parentheses,
and then it'll print it out for us.
So this is just going to iterate
through this entire dictionary.
So it'll first print SFO, San Francisco.
Then it will print BOS, Boston.
So now let's write some
functions in Swift.
And just like before, you'll notice
that there's this sort of type syntax
that occurs after the
thing that you're creating.
So to create a new function,
we're going to start
with the keyword func, which is kind
of an interesting choice for a keyword.
But they're all going
to start with func.
Then you have the name of your
function just like before.
You notice here that I'm using
camelCase rather than using underscores
to separate words.
Every time I start a new word,
I'm going to use a capital letter.
And this is just a
convention that Swift has,
and every programming language
has its own convention.
But this is what Swift chose.
Then inside of the parentheses
are my parameters to the function.
So this function has one parameter.
It's called name.
And just like before, we're going
to put the type of this parameter
after its name.
So name is a string, and we're going
to use a colon to separate those.
And, lastly, we're going to say
that my function returns a value,
and that value is a string.
So we have this little
right arrow operator.
It's a hyphen and then a
greater than, and then we'll
have the type that
this function returns.
So this function returns a string.
So the body of this
function is pretty simple.
We're going to use that
string interpolation again
by creating a new
immutable string variable.
It's called message.
We can't change its value
because we declared it with let.
Then we're giving it a value of Hello,
and then adding in that name parameter.
So with that variable, we're
trying to do two simple things.
First, we're just going to
print it out to the screen,
and then we're going to return it.
So one other thing you might
notice here is that there
are no semicolons at the ends of lines.
And this is pretty nice.
In C, you sort of had to remember every
single line ends with a semicolon.
If you forgot, your
compiler would yell at you.
In Swift, you don't need to do that.
Semicolons are optional, and so we're
just not going to use them anywhere.
So the Swift compiler can
figure out when your line ends
and then move on to the next one.
So now to call this function, the
syntax is a little bit different.
So we're going to have the name of
the function sayHello and parentheses
again.
But then we're going to specify the name
of the parameter followed by a value.
So you can see here we
have name colon Tommy.
So we're calling this function
with the value of Tommy.
But in Swift by default, you're going
to include the names of each parameter
before their values.
And this is kind of nice,
especially we have a long function
with three or four
parameters and kind of hard
to remember what the
order of those things is.
The Swift is much, much easier
to read that because each one is
going to be prefixed with
what the parameter name is,
so it's a lot easier to read it.
And we'll see a few of those
as we write more code later.
So like in C, Swift also
has this notion of structs.
And if you remember, a struct is
basically a container for data.
It's kind of an object that says, I
can have multiple different entries
or fields inside of this object,
but it represents one thing.
So here we have a struct called Course.
And here it has two fields.
It has a name of the Course, and then
it has the instructor for the Course.
So the syntax is very similar
to what we've seen already.
Both of these fields are immutable
because they're declared with let,
and their data type is String because
we have a colon followed by a string.
So in addition to structs, Swift
also has a more powerful concept
called classes.
So you can think about a
class as basically a struct
that can also have functions.
So in C when you wrote
structs, you basically
only gave them field names
like integers or strings.
But it was hard to put a
function inside of that struct.
With the class, it's much easier.
And when you add a function to a class,
we're going to call that a method.
So let's take a look at an example.
So here we have a class called Person.
Rather than starting off our
declaration with the word struct,
we're going to start it
off with the word class.
Then the name of our class is person.
And it has one field.
This field is called name.
It's mutable because
it starts with the var.
And the type of this field is a string.
So next is our method.
So in Swift, init is a
special method that's
reserved for when you create
an instance of this class.
So our constructor takes one parameter.
That parameter happens
to be called name.
It's string type.
And then the body of our
constructor is pretty simple.
All it does is assign this field name
to whatever it is the user passed in.
And so this last line here is
how we instantiate our class.
So that's how we create
an instance of a person.
That instance you'll often
see referred to as an object.
So, here, same syntax we've seen before.
We're saying let, which
means this is immutable.
The name of our variable is a Person.
We don't need a type.
The Swift compiler will
figure that out for us.
And then we're going to
invoke the constructor.
So we're going to say Person,
which is the name of our class,
and then we're going to pass
in that value as we did before.
So here I'm passing
in the name of Tommy.
And then later I can
simply say person.name,
and that's going to give
me back the value Tommy.
So that's how you would create a class.
But now let's add a method since
we can do that with classes.
So, again, we're going to see
that same syntax as before.
We're going to start off with func.
We're going to call our method sayHello.
Notice, again, I'm using
camelCase to separate words.
I'm starting each new
with a capital letter.
And then the body of that
method is pretty simple.
We're just going to print
out the value of that name.
We can sort of assume that
that same constructor exists
before, so nothing new there.
But now if we look at
the bottom, after I
instantiate that class
to call the method,
I'm just going to say person.sayHello.
You notice that this method didn't
take any arguments this time
because, instead, we're just
using the value that we already
passed in in the constructor.
And so if I say
person.sayHello, this is going
to print out to the screen I am Tommy.
So another feature of classes that's
really powerful is inheritance.
With inheritance, you can create
a subclass of a given class.
So let's suppose that
you write out a class.
Here's an example here.
It's a Vehicle class.
Our Vehicle class is pretty simple.
It just has two things.
It has a function that's called wheels.
It returns an Int.
And that's just going to tell us
how many wheels this vehicle has.
And then we have another method.
It's called go, and that's just going
to print something out to the screen.
It goes fast, so it says Zoom!
And let's say we then want to create
a class that represents a motorcycle.
And a motorcycle is really
similar to this vehicle class.
We probably want to say how
many wheels the motorcycle has,
and maybe this go method is
actually exactly the same.
We don't want to change that at all.
So what we can do is we can create
a subclass of this Vehicle class
and override just one of these methods.
So here's what that looks like.
So here we have a class Motorcycle.
And it's inheriting
from this Vehicle class.
So that's what this colon is.
It's saying that Motorcycle
is a subclass of Vehicle.
And as soon as I do
that, every functionality
that was in our Vehicle class
is now in our Motorcycle class.
So if I didn't have anything
inside of this class,
I could say motorcycle.wheels.
That would give me a value of 4.
I can say motorcycle.go, and that would
print something out to the screen.
But, obviously, motorcycles have
a different number of wheels
than 4 or most of them do at least.
And so what I want to do is just
override that one method and say,
rather than using that
definition that I specified
before, I want to change that and
use this new definition instead.
So you'll notice here that my method
now starts with the word override.
And that tells the Swift compiler
this method already existed
on that superclass or that
parent class, and I know that.
And I want to change
what this method does.
So then I'm going to declare the
method in the same way, so func.
Make sure it's called wheels.
Make sure it also returns an Int.
And now when I specify
a body, this is the body
that will be used if I
recall motorcycle.wheels.
So we'll have a value of 2.
And I can say motorcycle.go.
It's going to print out the
same thing to the screen.
So a few other concepts to cover before
we start writing some Swift code,
and one is this notion of protocols.
When you're writing iOS apps, you're
going to see not only a lot of classes
but a lot of protocols.
If you've ever used other
object-oriented languages before,
these are called interfaces
in most languages,
but Swift calls them protocols.
And you can think about them
basically as a list of methods
that a class must implement.
So here we have a
protocol called Teacher.
It starts with the word
protocol and then it has a name.
And now you'll notice that
in this teach function,
we actually haven't specified a
body, which is really interesting.
We're basically saying that
in order to be a teacher,
you need to know how
to teach, but we're not
going to tell you how to
teach as every teacher might
teach in sort of their own way.
But in order to be
considered a teacher, you
must implement or specify a
definition for some teach method.
So to use this protocol, it's
kind of the same syntax as before
with inheritance where we
can say here's a new class.
It's a CS50.
And a CS50 teacher is a
type of teacher, which means
it has to implement this teach method.
And so here we are at
implements that teach method.
We're specifying that
name of that method.
And we're not going to go
into the body of this method
because it's probably
pretty complicated.
But, here, in order for this to
compile, we have to specify teach.
If we just said class
CS50Teacher colon Teacher
and tried to compile that, it wouldn't
work because the Swift compiler would
tell us, hey, in order to
implement the teacher protocol,
you need to specify a
definition for this method.
We'll see a lot of this later.
One last concept cover is optionals.
And this is another thing you'll see
a lot when you're writing Swift apps.
When you were using C,
remember that you could
assign null to a lot of variables.
You could say I'm not sure what
this variable is going to be yet,
so let's start it off
with a value of null.
And then if you remember,
if you then tried
to use that variable while it was still
null, you probably had a bad time.
There is some sort of
segmentation fault.
Something happened that
you didn't want to.
So Swift really wants to
prevent mistakes like that.
And so in Swift, you can't just
assign null to any variable.
Instead, null is basically a special
type of a variable called an optional.
So in this first line, I'm creating
a new variable called name.
We're using var because we're
going to need to change this later.
And the type of this
variable is a String,
and then you'll see a question mark.
So this says the type
is an optional string.
So the type of this
variable could be String,
or it could be nil, which is
Swift's way of saying null.
But in order to use this variable, I
need to explicitly check if it's nil.
So the way to do that in Swift
is with this if let construct.
So it looks a little weird
the first time you see it.
But what this if let n equals
name is saying if name is not nil,
then assign that value to
a new variable called n.
And we know for sure that
n is not nil at this point
when we're inside of this body.
So we're just going to print it out.
And you'll notice that we're going
to print out n instead of printing
out name because n is our string
variable, and we know it's a string.
And then inside of this else, this
is going to trigger if name is nil.
So if I were to just write
this code and then run it,
I'm going to be inside
of this else block
because I've never
assigned a value to name.
And then it's going to print
out that there's no name.
So as you're writing
Swift for the first time,
this can feel really annoying
because you're really
used to just being able
to do whatever you want.
And say, oh, I know this isn't null.
Don't worry about it.
But the Swift compiler really wants
to help you make those mistakes.
And so tracking down
those crazy seg faults
is not really a thing in
Swift because of the compiler
is what's going to prevent
you from doing that.
You woke up feeling dangerous, and you
want to just say, I have this variable.
It's technically an optional.
Trust me, I know what it is.
Then you can just add an
exclamation point to the end of it.
We'll actually see this a few times
as we're writing iOS code just
to sort of shorten it.
This is dangerous if this
name were actually nil.
At this point, your app would crash.
And Xcode would sort of show you
where that line was when you crashed,
so still a little
better than a seg fault.
But we'll see this a few
times running iOS apps.
But try to really minimize
how much you're doing this
because this is how you get app
crashes is having unexpected unwrapping
with this exclamation point.
Let's look at one last way
to check for optionals.
So this is called a guard clause.
So remember before when we said if let n
equals name, we specified two branches.
We said if it is nil, then do this.
If it's not nil, do this other thing.
A lot of the time when we're writing
Swift code, all we really care about
is handling the case if it is nil.
And if that's true, we probably want
to break out of the function we're in
or display some sort of error
message or something like that.
And that's where the guard clause can
just kind of shorten the amount of code
you have to write.
So this is pretty
similar syntax as before.
Instead of saying if let,
we're going to say guard let.
Same as before.
We're saying n equals name, which
means that if name is not nil,
we're going to assign it to this new
variable called n with the same type.
And then we just have one branch here.
So we're just shortcutting one.
We're saying else do this other thing.
In this case, we're just going
to print out there's no name
and break out of the function we're in.
And then after this
guard clause, we have
this new variable n that we know is of
type string, and we can keep using it.
So you'll see a lot of guard
clauses as I'm writing Swift.
I kind of prefer it because let's say
that you have got a bunch of optional
and you have a bunch
of if lets and then you
know you're sort of indented six levels
deep and it can be kind of crazy,
with guards, you can basically say
at each point, let's just make sure
that everything is sort of
what we expect it to be.
And if it's not, break
out of the function.
But if it is, just sort of keep
going linearly down the function
rather than having a bunch
of these different branches.
So this is sort of a nice syntax to
handle optionals and my preferred one.
OK, so let's open up Xcode and write
our first few lines of Swift together.
So I'm just going to open up Xcode.
And when I do, I'll see
this little splash screen.
And what I want to do is click
on Create a New Xcode Project.
So if I click that, then
I'll have this nice screen.
In here, you can see Xcode actually
has a bunch of different templates
that's built in for me to sort of get
me off the ground running with an app.
So we'll take a look
at some of these later.
But for now, we're going
to come over here to macOS
and click on Command Line Tool.
And what this is going
to do is basically
give us the equivalent
of those C programs
we had with a little main method
that we can just click on Run.
Since we're not going to worry
about some of the iOS stuff yet,
let's just focus on Swift for now.
So we're going to do that.
Let's click Next.
And so here is now some
options for your project.
So that's going to ask
for a product's name.
So we'll just call this a Swift example.
And then it's going to ask you for an
organization name and an organization
identifier.
So if you're publishing
an app to the App Store,
this is basically where you'd specify
the company you're writing the app for
and this organization
identifiers, this unique thing
that you'll get when you
register an App Store account.
Because we're not worrying
about the App Store right now,
don't even worry about that.
So I just put CS50 for
my organization name.
And then a common convention
with organization identifiers
is it's your domain name backwards.
A lot of programming languages
do this, and Swift is among them.
So CS50's domain is cs50.harvard.edu,
so I've done edu.harvard.cs50.
And that's my identifier.
For language, we're going to
make sure that Swift is selected.
You notice you can actually write
iOS apps in C if you really want to.
I wouldn't.
We're going to use Swift.
Then we're going to come
over and click Next.
And then it's just going to open
up a file finder so you can pick
where you want to save your project.
You notice here there's
this Create Git Repository.
If you want to use Git and
you're familiar with that,
you can leave this checked.
If you don't, you can
leave it unchecked.
Doesn't really matter either way.
So I'm just going to leave it checked.
And I'm just going to
put this on my desktop.
And so I will click Create.
And so here we are.
So this is what Xcode looks like.
So in this main area in
the middle, this is where
we're going to be writing our code.
On the left-hand side here is where all
of our different files in the project
are going to be.
And in the right-hand
side, you'll see we'll
use this to change some
properties of different objects
we'll create in the project.
So this project is really simple.
It just has one Swift
file called main.swift.
If I click on that once,
it's going to open it up,
and you'll see here that Swift
generated a bunch of code for me.
It has this sort of nice
header comment at the top
with the name of the file, the
name of the project, my name,
it's copyrighted if you're
concerned about that,
and then some really simple Swift.
So the Swift program just starts
off this one line import Foundation.
This basically just pulls in a bunch
of libraries if we want to use them,
and we will later, and then
just a simple print function.
So we know what that's doing.
So let's just run this project
that Xcode generated for us.
So up in the top left here
is this little Play button.
So if you just click the Play
button, what this is going to do
is compile this Swift
code into an executable.
And then it's going to run it for us.
So when we're writing iOS apps, this is
going to run in a little iOS simulator.
Right now, we're just writing
sort of plain Swift, so it's not.
And down here, Xcode just opened
up this little thing for me.
I can drag to make it a bit bigger.
And this is the output
of this terminal app.
So as you'd expect, it
printed out Hello, World!
And then the program ended.
This exit code 0-- if
you remember back from C,
you would often return 0 from your Int
main function if nothing went wrong.
Swift is basically
saying the same thing.
Nothing went wrong.
This just ran, and that was the output.
So we can clear out this print
line since we won't need that.
And let's write some code.
So the first program we're going to
write is a little sorting hat program.
So what this is going to do
is it's going to sort students
into these different CS50 tracks.
So this is the mobile track.
We also have a web
track and a games track.
And so we're just going to write a
little program that will randomly
assign students to tracks.
So the first thing we
want to do is create
a new class that represents a track.
So I'm going to create this class.
I'm going to call it Track.
And each Track is going to
have a few different fields.
It's going to have a name of
the Track, so I'll say let name.
That's a string.
And you notice that Xcode has
this really handy autocomplete.
Basically, as I continue
to type, you'll see this.
And so if you just hit Enter, you
can take the first suggestion.
It can appear as you're typing really
fast if you just hit Enter a lot.
So each track has a name, and
then it also has an instructor.
And let's just sort of
make that a String too.
Again, we'll use autocomplete.
And then here you'll notice that
this Swift compiler is already
being helpful and saying
that we have a class,
but we haven't created any
constructors for that class.
And because I have a few fields
here that don't have a value,
I'll need to create those constructors.
So we're just going to
create one constructor.
So we'll say init.
Again, Xcode sort of
autocompleting for us.
And we have two parameters.
So we have one called name.
It's a String.
We have one called instructor.
It's a String.
All we want this constructor
to do is assign those.
So we'll say self.name equals name.
self.instructor equals instructor.
And there we go.
We have a class.
We have a class representing a Track.
So now let's create our list of Tracks.
So we have these three different
Tracks, Mobile, Web, and Gaming.
So let's create a new
list called tracks.
If we want, we can give
this a type of Track.
We don't need to since
the Swift compiler is
going to figure that out for us.
And so we'll open up our new array.
And so now we're going to
instantiate three Tracks.
So remember to do that, we're just
going to say the name of our Track.
Once I hit open parentheses, Xcode
is going to be really helpful
and say here's the parameters to
that one constructor you created.
So I just hit Enter.
And it's going to fill
all this in for me.
So let's start.
Let's say the name of
our Track is Mobile.
And then if I want to jump
over to this next place holder
here after instructor, if I just hit
Tab, my cursor is going to jump over.
So I can say the first
instructor is Tommy.
And then the next
Track, let's say is Web.
That instructor is Brian.
And then the last Track is Games,
and that instructor is Colton.
And so there we go.
So now I have created an array of Tracks
that has three values, and each of them
represents a different
instance of this class.
So if I want, I can just sort of
make sure that this is compiled.
If I hit Command-B, that's
going to build the project
or compile it but not run it.
So I'm just going to hit Command-B.
You'll see Build Succeeded.
That means that there were
no compilation errors.
Now, if I for example forgot a
comma here and then I hit Command-B,
you'll notice that I
have this Build Failed.
And this Xcode is going to highlight
in red where my syntax error is.
So it's really neat is if I click
this little red circle here,
Xcode is going to offer
to fix my code for me.
So if I just click Fix, it's
going to insert that comma for me,
and then I can move on with my day.
And just to sanity check, if we take
out the type of this Track's variable,
if I remove that, then
click Build, we're
still going to succeed
because Swift is going
to say at right-hand side of this
expression is a list of three Tracks.
So, obviously, the type of this
has to be a list of Tracks.
OK, so we've got that.
So now let's define a list of students.
So let's say this time we
have some list of students.
We know we don't have
to give this a type.
So let's just call these three
students three totally random names
that are really common like
Harry, Ron, and Hermione.
That's our list of
students, and we're also
going to want to have some variable
to keep track of how we're going
to assign these students to Tracks.
And so a really nice way to do
this would be with a dictionary
where the keys in our
dictionary can be students
and the values of those dictionaries can
be the track that they're assigned to.
So we know that we're going to need
to change and update this dictionary.
So what that means, instead
of using let as we've
been doing for most of the time
here, we're now going to use var.
So let's say my var assignments.
And this time we do need to specify a
type because initially this dictionary
is going to be empty.
So because it's empty, Swift has
no idea what kind of type it is.
So we're going to say
that this dictionary is
a mapping from String to Track.
So the keys are Strings.
The values are Tracks.
But, initially, it's
just going to be empty.
So to create an empty dictionary
in Swift, that's our syntax,
open bracket, colon, closed bracket.
If this was just an empty array, I
could do this, but it's a dictionary.
So we need that colon.
OK, so let's think about the logic here.
So what we want to do is iterate through
each element in our students array,
decide on a random Track, and then
assign that Track to the student's name
in this assignments list.
So to start, let's just
loop over our students.
So we can say for student in students.
Again, Xcode helped you out
there with the autocomplete.
I didn't have to specify
any types at all.
We just sort of understand
that student is now
a String because every element in
this students list is a string.
So just a sanity check and
make sure on the right track,
let's just print out
each student's name.
So we can say print student.
And then we're going to run it.
So if you can just hit Command-R to run.
Compiled OK.
And then, yeah, this
is what we expected.
So here we have the students in the
order we declared them all printed out.
So that's not super interesting.
So let's figure out how to
assign them to a random Track.
So we want to say, let's create
a new variable called Track.
And we want to set that
equal to a random Track.
We're just going to have
a really simple sort here.
And so what we want to do is
generate a random number between 0
and the number of tracks that we have.
And this is where Xcode
autocomplete can be really helpful.
You can just sort of start typing
and then browse the autocomplete
to see what they suggest.
So I happen to know that to generate a
random number I'm going to say Int dot,
and then I have this random method.
But if I was also curious what
other methods are on this Int,
I can just sort of start typing
and then just sort of browse.
And it's going to tell me all
about what these methods do
and what their parameters are,
but I wanted this random one.
So you can see here
that Xcode will tell me
that this returns a random
value, then a specified range.
Great, that's what I want.
So I'll hit Enter.
And now I'm going to
specify a range in Swift.
So this is kind of cool, but
you can say 0 dot dot less than
and then the size of the range.
So this is going to be tracks.
And I'm going to hit Enter.
And tracks.count is going to give me the
total number of elements in that tracks
list.
So this syntax is
basically a way of saying
I want sort of a range of numbers.
I want the start to be 0, and I want the
end to be the size of the tracks array.
So what this is going to do is generate
a random number between 0 and 3
exclusive or 0 and 2 inclusive.
So that's my random number.
So now I want to assign
that Track to a student.
So to do that, I'm going
to say assignments.
As my key, I'm going to specify student.
So this says inside of
this dictionary I want
to create a new value
for the key student,
and then I want to give that a value.
So then I can just say
tracks, and I'm going to index
into that array just like I did
in C with my new integer track,
and that's it.
So I notice that those
warnings went away.
The Swift compiler is
happy with me, and now I've
iterated through those students
and assigned them a Track.
So, last, we want to make
sure that this works,
so let's just print out the assignments.
So remember before to
iterate through a dictionary,
we're going to create a new for-in loop.
But this time you need to
specify the key and the value,
so let's say for student
track in assignments.
So here now we have two variables.
This first variable
has a type of string.
The second variable has a type of
track because that's what our map was.
And let's just print out the assignment.
So we're going to say print out.
And then we're going to start
using this variable interpolation.
So I'm going to say
backslash and parens.
Now I can start typing student.
And what's really cool is Xcode
is going to notice that you're
in this backslash parens thing.
So if you start typing, it's going to
autocomplete with variable names you
might want to print out.
So if I just say student, you'll see
it sort of start autocompleting for me.
I'll just hit Enter.
So there's the name of
the student, and then we
can say the student got my track.
And then I don't want to
just print out the object.
I want to print out one of those fields.
So I can say track.name and
then say with track.instructor.
So there we go.
So here I'm just printing
out one line, but I've
used this variable interpolation a
few different times, the first one
to print out the value of student.
And then take this object and just
convert it into this nice string
by saying track.name, track.instructor.
If we hit Run, we get Build Succeeded.
And there we go.
Nobody is taking Mobile, so we're
just going to have to click Run again.
Still no one's taking Mobile.
There we go.
I think I got my favorite student here.
So each time you're
running, you're going
to get a different random
list of assignments.
And so that's it for our
introduction to Swift.
This covers basically
all of the syntax details
you're going to need to start
writing some simple apps in Swift.
And so in the next video, let's
start writing our first iOS app.
