Placeholder Image

Subtitles section Play video

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

TOMMY MACWILLIAM: So let's get started writing our first iOS app.

Subtitles and vocabulary

Click the word to look it up Click the word to find further inforamtion about it