[MUSIC]
Okay, I promised that we were done with guess my number.
But I didn't say we were done with if statements.
I still need to show you an example with multiple else if branches.
I've got one here.
It's called day of the week.
And I can pop it up in the editor just by double clicking it, and here it is.
It's a little longer, so I'll need to have some more space, and
I can get that by just stretching the editor window down like this.
Woah, how long is this thing woah, not much command window left,
but at least we can see all of our function.
Our new function will the print the name of the day of the week when we call it and
give it the number of the day of the week as an input argument.
It's number n.
And it will also identify it as either a weekday or a weekend day.
We have a long if else if else statement here, because it has six else if branches.
So, counting its if and its else branches, it has a total of eight branches.
After this long if else if else statement comes a separate if else statement.
As I've mentioned, the function takes n,
the number identifying the day of the week, as an input.
The long if else if else statement then checks n,
comparing it one by one to the numbers one,
two, three, four, five, six, and seven.
When the first true condition is reached,
let's say n is three, we would print out the day of the week.
In that case, would be Tuesday.
And then, we set day type,
a variable called day type here, equal to one, if it's a weekday.
Or two if it's a weekend day, here is a two, here is a two.
The else branch here is just there to handle errors.
If the input is not one of the integers one to seven,
then none of these first seven conditions can be true.
So we take that else branch.
And in that branch we print out an appropriate error message.
Right here.
And then we return from the function.
We'll say more about this return keyword a little bit later.
This second if statement, this if else statement
down here is here to tell the user whether the day is a weekday or not.
It checks the day type variable, and if it's equal to one,
it prints, which is a weekday, otherwise it prints, which is a weekend day.
In either case after the y here of the word day, we included a backslash n.
This is the escape sequential, remember, that puts us to a new line.
We wanted to get ready for the MATLAB prompt.
Notice, though, that we omitted the new line in all the fprintf statements above.
And we did that so when the name of the day and
the comma are printed out, this text following it,
which is a weekday or which is a weekend day, will be on the same line.
Notice one last detail about the printing, we included a space here before
the switches so that there will be a space between this comma after the weekday or
weekend day name is printed, and this phrase, which is a.
Well it's time to try this function out.
Well, we'll note that this is an American function.
The week starts on Sunday.
And, that looks good.
Wednesday is what we would expect.
We would put in a 4.
Let's see, Sunday, Monday, Tuesday, Wednesday.
Yep, that's right.
And we can see that Sunday is identified properly as a weekend day.
And Wednesday is a weekday.
So far, so good.
So, we've tried a weekend day.
We've tried a weekday.
Now, we need to make a mistake and see if we handle errors properly.
[SOUND] Well, it handled the error just right.
It's passed all the tests.
I'd say this is a working function.
Well, it handled the error just right, and
it did that because of the return statement inside this else branch.
Return is not only a keyword, it's an entire statement.
And it does just what it's name suggests.
When MATLAB executes the return statement, it immediately quits the function and
disregards all the other statements following it.
Most typical use of the return is exactly what we're doing here.
We encounter an error.
And it's time to quit the function.
Functions normally quit only when they reach the end of their statements.
But you may want to have a function return earlier, either because of an error,
just like this case, that was detected before the end of the function is reached,
or simply because the function is done with its work before then end is reached.
In either case, the return is what you need.
Let's just remove the return statement for a second and
see what happens with this bad input.
I'm going to hit delete here.
So, let's just run it again.
Since that's the last thing we did, all I have to do is hit up arrow and return.
And what did we get here?
Let me stretch this up a little bit so we can see better.
We got the error message, Number must be from one to seven.
But then this is an ugly result, here.
This ugliness happens because day_type is not assigned a value when the input is out
of range.
And, none of these else ifs or this if happens, and so,
none of these assignment statements take place.
day_Type equals.
Since it doesn't have a value, MATLAB has forced to step in and take charge.
This sort of behavior is termed an ungraceful exit.
And it's an embarrassment for any self-respecting programmer.
But with the return statement in there, and let's put it back.
There.
The function ends gracefully, and that's how all nice functions behave.
So let's do it one more time.
There.
Return statement is a convenient way to handle this situation.
And indeed, it's a convenient way to handle any situation for
which there's nothing more that a function can do or needs to do.
We've seen quite a few variants of the if statement.
Let's summarize what we've learned.
The simple if statement has a condition and
a block of statements that's executed if the condition is true.
If the condition is false,
then the statements in the block will not be executed.
The if else statement lets you specify a block of statements for
the case when the condition is false, also.
So, there's a separate block of statements for each of two cases.
That is true or false.
Because of that else branch,
exactly one block of statements will always be executed.
The if else if statement lets you specify multiple conditions that are checked one
by one until the first true condition is found.
Then, the corresponding block of statements is executed, and
MATLAB skips to the end.
If none of the conditions is true,
then none of the statements in the blocks will be executed.
The if else if else-statement is very similar to the if else if statement.
The only difference is that we add an else branch after the last else if branch.
The else block at the end will be executed only if all the previous conditions
are false.
But because of that else branch,
exactly one block of statements will always be executed.
[MUSIC]
[APPLAUSE]