Placeholder Image

字幕列表 影片播放

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