Swift程序设计入门是由四门课程组成的专业课程系列的第一门。这个专业系列旨在为你提供从零开始开发iOS程序的工具与技能。Swift是iOS上崭新而强大的编程语言，到这门课结束的时候，你将有能力展示使用Swift编程的中级应用。在完善的实践指导下，你将熟练掌握Swift编程的语法、面向对象的基本原则、内存管理、功能概念等等。在致力于Swift编程教学方面，这门课程是独一无二的。在新的特性与功能的帮助下，你将站在编写iOS程序的最前沿。请注意：参与本门课程（以及完整的专业课程）要求必须拥有一台Mac电脑；另外，虽然不做强制要求，但最好拥有一部iPhone或iPad。这门课程的设计和测试（以及内容传达）都是基于一台Mac。我们知道黑苹果和Windows下的Mac虚拟机，但我们依然不推荐使用PC。希望你们在这个新的旅程中过得愉快。
Debugging
Loading...
來自 University of Toronto 的課程
Swift 程序设计入门
1171 個評分
從本節課中
Introductions and Getting Started
Meet the teaching staff, get oriented to the platform, set up your work environment and get ready to program! We wish to remind you from the start that to take part in this course (and the full specialization) it is required to have Mac computer and, though not required, ideally an iPhone, iPod, or an iPad. This course has been designed and tested (and content delivered) on a Mac. While we are aware of hacks and workarounds for running OSX in a virtual machine on Windows, we do not recommended a PC. To find out of this specialization is for you, download the SHIFT Photo Editing app at http://beautifulapps.mobi and try it out. If you take this specialization, then you will learn to create an app similar to SHIFT.
與講師見面
Parham AarabiProfessor
Department of Electrical and Computer Engineering
[MUSIC]
Okay we're back.
What should we talk about next?
>> All right, like we left off last time, we're going to
check out some debugging features of Xcode, which are actually really powerful.
It's probably one of the best debuggers in the world.
>> So we've added some code here to actually debug,
just a couple lines of code.
We wanted to create a simple app that just shows a picture on the screen.
So, Jack why don't you run it and
let's see what our app actually is doing right now.
>> Sounds good, so- >> Obviously
it's gonna work perfectly the first time, like all our apps do.
>> Yep, we've sneakily added code.
>> Yeah.
>> That's not supposed to happen.
>> That's not supposed to happen.
So our debugger stopped debugging, so maybe we'll just re-record this.
[LAUGHS] >> That's okay, we'll just run along.
>> Actually you should've cleaned it, I think, maybe.
[LAUGH] >> Okay, so as we're cleaning this,
what happened is, we wanted to rehearse what was supposed to happen.
And- >> It's supposed to not work,
but it worked.
[LAUGH] >> I know.
>> This is how good we are.
It works when we're not even trying to have it work.
[LAUGH] >> All right, so
you've already got a sneak preview of what's supposed to happen.
But hey where's our image Mike?
>> Yeah, you were supposed to load an image there, with your code there,
Jack but maybe something is missing.
>> I know.
>> We could try and guess what the problem is but
maybe- >> That's not how we do things here.
>> Utilize the features of Xcode as a modern integrated
developer environment and use the interactive debugging system that it has.
Which lets us look at what the code is doing while it's running.
So what's the first you can do with the debugger?
>> All right, so don't worry about any of this.
Just where you see here that looks like I am creating image named shift,
and I'm sending this image to an image of image view.
Sounds like you should be doing the right thing.
But, the first thing, as you mentioned, would be setting your break point.
And in Xcode, it's super easy.
Just go over to the left, next to the line number, and click right here and
I got a break point on this line.
>> Yeah so, break point is gonna stop it running, pause it.
You noticed we sort of manually paused it before, in the previous lecture.
This will tell it to pause on a specific line every time it runs.
When we manually paused it, it kinda paused in some random spot but
we wanna pause it here.
And that will let us inspect the state of the program at that particular spot.
We can see what the value of the variables are,
run the code line by line, see what changes as it's running.
So that's what a break point does, and so I tracked it.
You just click on the line in that kind of gutter area.
You only have to select a breakpoint on
the particular spot where you want it to stop.
And then you can go line by line after that.
So only one breakpoint is required.
If you wanna delete a breakpoint, you can sort of drag it, click and drag it off
until you get that little x icon then it can disappear like a little cloud.
[LAUGH] >> Yeah, so
break points will stop whenever your code gets there.
Since our code has already stopped doing anything, it's not gonna ever get here.
So we'll have to run that again.
>> Start over.
>> Starting it over.
Now, oh what just happened?
Our code just executed here.
It tells us that we're on the first threat.
This is break point 1.1 which is a nice name that it has.
And this debug panel, which was not here before,
came up by itself which is really neat.
And so let's see what happens.
So on the left, we just chose the stack, which is basically how we got here.
Don't worry about it right now.
[LAUGH] Down here we have a split panel here.
In our debug view the left one will show us most variables in our scope right now.
And we have an image, and we always have self, which points to ourself, and
don't worry about it too much.
In the right here we have a command line, we have lldb running,
which is our debugger, where you can type stuff.
And actually this code has not run yet.
>> Yeah, at this point.
>> It stopped before it actually run that code, so-
>> So we're gonna see-
>> Everything is uninitialized.
[LAUGH] >> So here,
if we look at image, I have no idea what's going on here.
But you can use print object, which is po short for
print object, image which is our variable.
And at this point it's not even defined, right?
I mean we weren't even here,
so it's gonna give us an error because we stopped before this code actually ran.
So all you're debugging sort of tools, buttons, are on this bar right here.
And the one we're going to use now is this little step over thing, which
means to execute the next line of code and go right over it, and we'll do that.
And everything incremented.
Now we're here which means this code has run.
And we can run the same code, and it'll tell us.
It tells us that image is nil.
And our image is supposed to be shift, its not supposed to be nil, and
nil just means- >> It's just a special that means that
nothing happened.
And we know from the UI image, that function there,
that if it returns nil it means that it had an error loading that image.
So you want to maybe you could sort of guess what happened.
If we're getting nil then we're setting that image to our image view,
then it's not going to show up on screen, we're not actually getting.
So we basically, we solved our problem- >> [LAUGH]
>> We can kinda guess what the problem is-
>> The problem is we don't,
this image is either not called shift, or
an image named shift does not exist in our project which is very true.
Because, I mean- >> We deleted it, secretly.
[LAUGH] >> [LAUGH] On accident.
>> Secretly.
>> Not on purpose.
[LAUGH] >> And so, we're gonna put it back.
And conveniently, it's right here and
it's the same image you saw in the beginning of this module.
And we're gonna add it into this assets folder which is a special place for
images Xcode provides.
You simply drag it over, and it goes right in.
It creates this nice thing for you, and we'll talk about all the details later.
>> But this is basically how you, one way to add stuff, anything really,
into your project.
You can add images, videos, other kinds of resources,
as long as Xcode knows what to do with that kind of file, it'll handle it.
It'll include it into your project.
And when you dragged and dropped it in there it copied it into your project so
you have a new copy of that for this project.
And it will get included in the app when it gets compiled.
>> And you can right-click on it.
And there's almost always going to be a show in finder button, so
you can check, and yep.
There's a copy of this image, it's not on the desktop.
If you keep going up that sort of stack you'll see what I mean.
This is our app, it's inside our assets, and we got, have that shift image.
>> X ode place that for you, it's kind of like iTunes.
It grabs all your stuff that you drag into it and
puts it into it's own folder structure.
>> Which is pretty neat.
>> Yeah, it's pretty nice. >> Pretty nice.
And so, instead of, so we're gonna let this run, sorry.
And then re-run the app, basically, to see if that helped.
So if I just run it again, it re-compiled that asset.
Oh, it stopped again.
Okay, right cuz we did not remove the break point.
And we could have avoided that by clicking on it and it would dim it up.
So it would be inactive break point.
>> Yeah, so you have two options.
You can either delete a break point if you don't want it anymore, or
you can just click it again to make it sort of this dim transparent blue.
And that inactivates it, or deactivates it temporarily.
It's a good feature if you're kind of stuck on something, or
you wanna turn on the breakpoints, turn it off sometimes, but
keep it around just in case you need it.
>> Yeah, and it's very useful also because breakpoints in Xcode are,
again as in everything with Xcode, much more than they seem.
There are really advanced features you can do with break points in Xcode.
If you set up a really cool break point, you might not want to just throw it away.
And so, there's many things that you can do here, but we're not gonna go into that.
And we will provide some resources if you're interested in advanced debugging,
which you shouldn't need, at least at this point.
So, stepping on, continue this code, if we step past it now.
There's a few ways, I mean we've used this in the past but
let's try other ways inspecting to code.
You can actually just hover over image variable and
it'll give you sort of the same thing you would see down here
except in this really cool little eyeball thingy.
Which- >> Yep, it actually shows you-
>> Actually shows you- [LAUGH]
>> The contents of the,
cuz the image object knows how to print itself or
communicate with the debugger and send that information.
So the debugger can kind of inspect that state of that variable,
which is really useful.
>> And this is really cool because it's actually reading it straight from
the memory of the program, like not from your disk, not from my desktop,
not from that.
It's actually what's loaded into this variable right here.
And now when we set the image, and
we let it continue, which is this button by the way,
this continue program execution button, will allow the app to keep running.
And woah, we got the image.
>> Yep, and we knew this might be familiar to a lot of people,
if they've used the web view, the developer view in Safari or Chrome.
You also get a JavaScript debugger, it's quite a similar idea,
you can also step through code and inspect values of your JavaScript.
So this offers you many of the same features.
And maybe a few more advanced ones as well.
>> Yeah and just to actually, I'll show you some cool on the rest of these.
I mean you have step over, step in, and step out,
which are the basic debugger command, the mini debugger.
And Xcode it has the most cool UI debugging button right here
called debug view here key.
And we'll be using this in this course.
And just to show you, when you press it, it actually takes your app and
breaks down the components on screen and displays it in these nice boxes.
And you can actually sort of explode it out.
>> Whoa. >> And see all the layers.
And it's really cool.
This is probably one of, I mean, I haven't seen this anywhere else, than Xcode.
And it's really helpful if you're confused.
Yeah, and when you're confused like, for example, if your label
was behind the image you wouldn't be able to see it and like hey, where's my label?
And you press this you can sort of blow it up and you can see the label there and
you'll know right away.
I mean it's helpful in many cases for your view and
just a really nice cool thing about Xcode.
>> Yeah I've used that before.
I had things that weren't laying out properly, and
I needed to see why, what the hierarchy looked like.
It was hard to tell from the code what was happening.
So, that was quite a useful feature when I was debugging that.
And you can also see on the top left there, since our code is still running,
you get some running info about the amount of CPU,
and memory, and disk, and network usage your code is using.
So you can track if your code is really slow, for example.
You can keep an eye on the CPU usage, as well.
As memory usage, you don't want that memory usage maybe to go up infinitely,
for example, while your code is running.
So it's pretty useful,
live kind of view of what's happening while your program is running.
>> And again, this is a very simplified version of the very powerful instruments
that comes with X code, and we'll likely demo it later in this course.
That allows you to get very detailed information on execution times,
like program performance, memory usage,
pretty much everything you would want to know about your app when it's running.
And with that- >> That concludes our
intro to the debugger.
The most important things that you've noticed here,
hopefully, are how to set break points, how to inspect values
of your variables while your stopped at a break point, and how to step over code.
Those are really great ways to kind of keep an eye, and figure out what's going
wrong when you're writing code if something's not working out.
This is the kind of stuff that's used by professional programmers all the time,
not just beginners.
Everybody makes mistakes and
has things that are happening that are kind of unusual and unexpected.
So, it's good to be familiar and comfortable using the debugger.
And the faster you get with that, and more comfortable you get using that,
the faster you will be able to solve any problems that you have with your code.
>> Yes, the debugger will soon become your best friend.
