IF conditions and programs that make decisions — Programming fundamentals

• Lesson notes
• Recommended watching
• Optional
• Lesson transcript

Lesson notes

condition formally looks like this:

IF (condition) THEN
  do something
IF (other_condition) THEN
  do some other thing 
IF (none of those conditions) THEN
  do something else

JavaScript function that accepts a number and returns its absolute value:

const abs = (num) => {
    if (num > 0) {
        return num;
    } else if (num < 0) {
        return -num;
    } else {
        return 0;
    }
}

Conditions can be either true or false. For example, (num > 0) is true when num is 9 or 15, but it's false when num is -18 or, say, 0.

Things that answer TRUE or FALSE are called predicates.

Other math predicates in JavaScript include:

===
!==
>
<
>=
<=

Examples:

512 === 512;    // true
512 === 988;    // false

512 !== 378;    // true
512 !== 512;    // false

512 > 500;      // true
512 > 689;      // false

512 < 900;      // true
512 < -30;      // false

512 >= 512;     // true
512 >= 777;     // false

512 <= 512;     // true
512 <= 600;     // true
512 <= 5;       // false

AND (&&):

OR (||):

NOT (!):

Alternative way of implementing abs function:

const abs = (num) => {
    if (num === 0 || num > 0) {
        return num;
    } else {
        return -num;
    } 
}

Think of another way of implementing the same function using >= sign.

Same function means "the function behaves the same way from the outside, but the insides (the implementation) can be different".

Recommended watching

• AND OR NOT - Logic Gates Explained - Computerphile
• See How Computers Add Numbers In One Lesson

Optional

JavaScript and many other languages also have a short-hand version of the if statement: it's called conditional or ternary operator:

condition ? expression : expression

Here there is only one condition and two options: one for true and one for false.

const absValue = (num === 0 || num > 0) ? num : -num;

We create an absValue and assign it a value. This value depends on the condition: if condition is true, then num is used, otherwise -num is used.

Lesson transcript

So far we've been using our programs as glorified calculators. Of course, they can do more, and the next big idea is to make computers make decisions based on some information.

Check this out: in mathematics there is a concept of absolute value. This is how it's defined:

Don't worry, it's simple: if number is positive, then its absolute value is the same as the number; if number is negative, then its absolute value is the negation of the number. Basically, drop the minus if it's there and that's it.

One way to think of it is: it's the distance from zero.

Imagine you want to describe a black box — a function — that accepts a number and returns its absolute value. You'll need to make a rule inside the box, something like this:

IF number is greater than 0 THEN
  return number
IF number is less than 0 THEN
  return -number
IF number is 0 THEN
  return 0

This is a condition, and formally it looks like this:

IF (condition) THEN
  do something
IF (other_condition) THEN
  do some other thing 
IF (none of those conditions) THEN
  do something else

Let's make our function for real now:

const abs = (num) => {
    if (num > 0) {
        return num;
    } else if (num < 0) {
        return -num;
    } else {
        return 0;
    }
}

This function has one argument — it accepts one thing from the outside. Then we have the if keyword, then goes the condition in brackets, then — a block of instructions that will be running if that condition is met. Next is another condition with else if. else if means "if previous condition is not met but this new condition IS met, then do this next block of instructions".

There can be multiple "else if" blocks, sometimes you have many options.

So now, after we've taken care of positive and negative numbers, there is one more option left: what if number is zero. Note that we don't check for zero explicitly, we just say else. It means "if none of the conditions above are met, then do this next block of instructions". You can safely think that if number is not positive and not negative, it can only be zero. But sometimes we make mistakes when thinking about conditions and options, and many problems in programming come from incorrect conditions.

These conditions in brackets are things that can be either true or false. For example, (num > 0) is true when num is 9 or 15, for example, but it's false when num is -18 or, say, 0.

As you see, greater than and less than math symbols kind of give answers — YES or NO, TRUE or FALSE. There are other things that can give TRUE or FALSE answers:

===
!==
>
<
>=
<=

And here are few more examples:

512 === 512;    // true
512 === 988;    // false

512 !== 378;    // true
512 !== 512;    // false

512 > 500;      // true
512 > 689;      // false

512 < 900;      // true
512 < -30;      // false

512 >= 512;     // true
512 >= 777;     // false

512 <= 512;     // true
512 <= 600;     // true
512 <= 5;       // false

The branch of math that studies these true and false statements is called Boolean algebra. In general, statements of any nature, not just number systems, can be true or false. For example, "I am a human being" is true, while "China is located in South America" is false.

JavaScript has true and false values, and you can actually use them in conditions. For example, you can say if true, and this condition will always be met — because true is always true.

There are many aspects and details in Boolean algebra, but in programming we are mostly concerned about three basic operations: AND, OR, NOT.

AND is when you want two conditions to be true. "I am a human being AND horses eat grass" is true, because both statements are true. "I am a human being AND pigs can fly" is false, becase one statement is true, but other one is false, so together, this whole thing joined by AND is false.

The symbol for AND is double ampersand &&. And this is the so called truth table for AND, it's like a cheat sheet:

So, only TRUE AND TRUE give TRUE, and all other combinations include FALSE, so they result is FALSE.

OR is when you want at least one condition to be true. Following the same examples, "I am a human being OR horses eat grass" is true. "I am a human being OR pigs can fly" is also true. Even though pigs don't fly, I AM a human being, so one of the two statements is true, which makes this whole thing joined by OR to be true.

The symbol for OR is two vertical bars ||.

If there is true, then the result is true.

NOT is simple — it's the opposite. NOT true is false, NOT false is true. "NOT pigs can fly" is true, because "pigs can fly" is false, and NOT false is true.

The symbol for NOT is an exclamation mark !.

In programming there are usually multiple ways to do the same thing. We can re-write our absolute value function differently and get the same result. Let's try to do it using these new ideas:

const abs = (num) => {
    if (num === 0 || num > 0) {
        return num;
    } else {
        return -num;
    } 
}

So now we have only two conditions:

1. If number is zero OR number is greater than 0, then return the number.
2. In any other case return -number.

You can think of yet another way of writing the same function using "greater than or equal" sign, for example. When I say "same function", I mean that the function behaves the same way from the outside, but the insides — the implementation, can be different.