A Boolean expression compares two values to determine a YES or NO value. To compare two values, you have to use a Boolean comparison operator. Table 6-1 lists the various Boolean comparison operators.

Assuming that the value of X is 28, Tables 6-2 shows how the computer would evaluate the various Boolean expressions.

On each side of a Boolean comparison operator, you can have any of the following:

Suppose you had a Boolean expression as follows:

X = 36;
if (X < 98)
{
  NSLog (@"Hello, world!");
}

The first step that the computer would take is to substitute the value of X into the (X < 98) Boolean expression like this:

if (36 < 98)
{
  NSLog (@"Hello, world!");
}

The Boolean expression (36 < 98) evaluates to YES, so the next step would look like this:

if (YES)
{
  NSLog (@"Hello, world!");
}

This code just boils down to this:

NSLog (@"Hello, world!");

Just as mathematical operators let you calculate new values with numbers, Boolean logical operators let you calculate new values using Boolean expressions. Boolean logical operators are useful to evaluate two Boolean expressions.

The following are the four types of Boolean logical operators:

!(YES) = NO
!(NO) = YES

!(X == 86)

!(57 == 86)

!(NO)

!(NO) = YES

while !(validPassword)
{
  Ask for password;
}

if (raining outside) && (need to go outside)
{
  take umbrella;
}

if (raining outside) || (snowing outside)
{
  wear boots;
}

The if statement gets its name because it checks a single Boolean expression. If this Boolean expression is YES, then the if statement follows one or more instructions. If this Boolean expression is NO, then it doesn't do anything.

The simplest if statement lets you run exactly one instruction based on a Boolean expression. In Objective-C, this simple if statement looks like this:

if (Boolean expression) instruction;

To see how to use this simple if statement, modify the VariableTest project from Chapter 5 by following these steps:

The simplest if statement lets you run only one instruction if a Boolean expression is YES. In most cases, you'll need to run two or more instructions if a Boolean expression is YES. To do this, you need to use curly brackets around the instructions you want to run:

if (Boolean expression) {
    instruction1;
    instruction2;
}

To make the curly brackets more visible, you could just place the beginning, left curly bracket on a separate line:

if (Boolean expression)
{
    instruction1;
    instruction2;
}

In either case, using curly brackets lets you run two or more instructions if a Boolean expression is YES.

The if statement runs one or more instructions if a Boolean expression is YES. However, if the Boolean expression is NO, then the if statement doesn't run any instructions. There may be times when you want the computer to follow one set of instructions if a Boolean expression is YES, but follow another set of instructions if the Boolean expression is NO. In such cases, you have two choices.

First, you can create two separate if statements:

if (Boolean expression == YES)
{
    instruction1;
    instruction2;
}
if (Boolean expression == NO)
{
    instructionA;
    instructionB;
}

No matter what the Boolean expression may be (either YES or NO), the instructions in one of these if statements will run. Of course, writing two separate if statements can be clumsy, so Objective-C offers an if-else statement that lets you define two sets of instructions to follow:

if (Boolean expression == YES)
{
    instruction1;
    instruction2;
}
else
{
    instructionA;
    instructionB;
}

This single if-else statement makes much clearer which set of instructions the computer will follow depending on the value of the Boolean expression. If it's YES, then the computer follows the first set of instructions. If it's NO, then the computer follows the second set of instructions.

The if-else statement runs either one set of instructions or a second set of instructions. If the computer does not follow the first set of instructions, it always follows the second set of instructions.

However, you may not want the computer to run a second set of instructions automatically. Instead, you may want to evaluate a second Boolean expression before running the second set of instructions. Such an if-else if statement looks like this:

if (Boolean expression 1 == YES)
{

instruction1;
    instruction2;
}
else if (Boolean expression 2 == YES)
{
    instructionA;
    instructionB;
}

Although it's similar to the ordinary if-else statement, the if-else if statement works a lot differently. If Boolean expression 1 is YES, then the computer runs only the first set of instructions (instruction1 and instruction2). If Boolean expression 1 is NO, then the computer evaluates Boolean expression 2.

If Boolean expression 2 is YES, then the computer follows the second set of instructions (instructionA and instructionB). However, if Boolean expression 2 is NO, then the computer winds up not following any of the instructions.

The preceding if-else if statement could be rewritten as follows:

if (Boolean expression 1 == YES)
{
    instruction1;
    instruction2;
}

if (Boolean expression 1 == NO) && (Boolean expression 2 == YES)
{
    instructionA;
    instructionB;
}

For the computer to follow the second set of instructions (instructionA and instructionB), two conditions must be met. First, Boolean expression 1 must be NO. Second, Boolean expression 2 must be YES.

In addition to letting you evaluate a Boolean expression before running each set of instructions, another advantage of the if-else if statement is that it lets you choose from two or more sets of instructions, such as in this example:

if (Boolean expression 1 == YES)
{
    instruction1;
    instruction2;
}
else if (Boolean expression 2 == YES)
{
    instructionA;
    instructionB;
}
else if (Boolean expression 3 == YES)
{    instructions3;
    instructions4;
}
else if (Boolean expression 4 == YES)
{

instructionsC;
    instructionsD;
}

Unfortunately, the more alternative sets of instructions you include in the if-else if statement, the messier your code gets and the harder it is to read. If you need to check a Boolean expression before running multiple alternative instructions, it's simpler to use a switch statement.

The switch statement is often used to provide a large number of alternative instructions for the computer to follow. The main difference is that a switch statement tries to match a variable to a constant value. For example, consider thesetwo if statements:

if (X == 45)
{
    instruction1;
    instruction2;
}

if (X == 97)
{
    instructionA;
    instructionB;
}

The equivalent switch statement might look like this:

switch (X)
{
    case 45:
       instruction1;
       instruction2;
       break;

    case 97:
       instructionA;
       instructionB;
       break;
}

Rather than just evaluate a YES or NO value, the switch statement takes a value and tries to match it. If the value matches to a specific value, then the computer runs that set of instructions:

switch (expression)
{
    case match1:
       instruction1;
       instruction2;
       break;

   case match2:
       instruction3;
       instruction4;

break;

   case match3:
       instruction5;
       instruction6;
       break;

   default:
       instructionA;
       instructionB;
       break;
}

This switch statement is equivalent to the following if statements:

if (expression == match1)
{
   instruction1;
   instruction2;
}

if (expression == match2)
{
   instruction3;
   instruction4;
}

if (expression == match3)
{
   instruction5;
   instruction6;
}
else
{
   instructionA;
   instructionB;
}

The switch statement is somewhat unusual for two reasons. First, you do not use curly brackets to enclose multiple lines of code inside the switch statement. Second, at the end of each set of instructions, you need to use a break command.

The break command simply tells the computer to stop following instructions. Without this break command, the computer would simply keep following instructions stored in another part of the switch statement. For example, consider the following switch statement where the break command is missing:

switch (expression)
{
    case match1:
       instruction1;
       instruction2;

  default:
       instructionA;
       instructionB;
       break;

}

This is actually equivalent to the following, which is probably not what you want:

switch (expression)
{
    case match1:
       instruction1;
       instruction2;
       instructionA;
       instructionB;
       break;

  default:
       instructionA;
       instructionB;
       break;
}

The case and break commands define the beginning and the end of a group of instructions. If you omit the break command, the computer will get confused and run additional instructions that you didn't intend.

By purposely omitting the break command, you can match multiple values to the same set of instructions:

switch (expression)
{
    case match1:
    case match2:
       instruction1;
       instruction2;
       break;

  default:
       instructionA;
       instructionB;
       break;
}

The preceding switch statement is equivalent to the following:

if (expression == match1)  || (expression == match2)
{
      instruction1;
      instruction2;
}
else
{
     instructionA;
     instructionB;
}

To see how to use a simple switch statement, modify the VariableTest project from the section "The Simplest if Statement," earlier in this chapter, by following these steps:

Go back and change the first line in the applicationDidFinishLoading method to the following:

int X = 1;

Now if you run this program and view the log window, you'll see this:

2010-08-28 17:59:32.654 VariableTest[9921:a0f] X = 1

Go back and change the first line one more time, to the following:

int X = 99;

Now if you run this program and view the log window, you'll see this:

2010-08-28 17:59:32.654 VariableTest[9921:a0f] Default code

By examining the switch statement, you can see exactly how it behaves based on the value that you give it for X.