Lesson 4

Greetings! Today, we're diving into the exciting realm of **Dart comparison operators**. These operators play a significant role in directing the execution of code based on comparisons.

Our core objective is to understand `comparison operators`

and their use in a Dart programming context. We will delve into various Dart comparison operators and enrich your understanding through practical, real-world examples.

Imagine monitoring a sports championship. Outcomes depend on evaluating conditions such as the scores of the competing teams. These decisions allude back to comparisons, which resemble situations in programming. In Dart, we utilize `comparison operators`

to make such decisions.

Dart has six comparison operators: *equivalent to* (`==`

), *not equivalent to* (`!=`

), *greater than* (`>`

), *less than* (`<`

), *greater than or equal to* (`>=`

), and *less than or equal to* (`<=`

). They yield `true`

or `false`

results, known as boolean values.

Consider the following: a comparison of one team's score to that of another:

Dart`1int teamAScore = 150; // score of Team A 2int teamBScore = 130; // score of Team B 3print('Is Team A leading Team B?'); 4print(teamAScore > teamBScore); 5// Prints: Is Team A leading Team B? true`

In the Dart code snippet above, we compared `teamAScore`

and `teamBScore`

using the `>`

operator. The output is `true`

because `teamAScore`

is indeed higher than `teamBScore`

.

Let's further explore the *equivalent to* (`==`

) and *not equivalent to* (`!=`

) operators. These are necessary when you need to compare values, such as comparing the current team's fouls to the allowable ones:

Dart`1int currentFouls = 5; // current number of fouls 2int permittedFouls = 5; // allowable number of fouls 3 4bool haveReachedLimit = currentFouls == permittedFouls; // the outcome is 'true' 5bool isUnderLimit = currentFouls != permittedFouls; // the outcome is 'false'`

The `==`

operator checks whether `currentFouls`

equals `permittedFouls`

, yielding a `true`

outcome. On the other hand, the `!=`

operator checks for their inequality, resulting in `false`

.

Next, we'll examine the *less than* (`<`

), *greater than* (`>`

), *less than or equal to* (`<=`

), and *greater than or equal to* (`>=`

) operators. These are primarily used for numeric data comparisons. Suppose you're evaluating two players and want to decide which one has fewer penalties. These operators can help:

Dart`1int penaltiesPlayerA = 3; // number of penalties for Player A 2int penaltiesPlayerB = 1; // number of penalties for Player B 3 4bool hasALessPenalties = penaltiesPlayerA < penaltiesPlayerB; // outcome is 'false' 5bool hasBEqualOrLessPenalties = penaltiesPlayerA >= penaltiesPlayerB; // outcome is 'true'`

We juxtaposed the number of penalties for two players. *Player A* doesn't have fewer penalties than *Player B*, hence `hasALessPenalties`

renders `false`

. However, *Player B* has equal or fewer penalties than *Player A*, resulting in `hasBEqualOrLessPenalties`

as 'true'.

Excellent work! We've journeyed through the comparison operators in Dart and their practical applications. With this newfound knowledge, you're equipped to control decision-making and effectively steer the coding flow of your Dart programs. Next, we'll enhance your learning through interactive hands-on exercises. Get ready for an exciting challenge!