Comparison Operators

Let's start with what comparison operators are in the first place. So...

Here are the main comparison operators in TypeScript:

== (equal): Compares two values for equality, converting them to a common type if necessary. For example:


              12
            
let example = 5 == "5";
console.log(example); // true

=== (strict equal): Compares two values for equality without type conversion. This operator considers both type and value. For example:


              1234
            
let first = 5 === 5; // true, as values and types match
let second = 5 === "5"; // false, as types are different
console.log(first);
console.log(second);

!= (not equal): Compares two values for inequality, converting them to a common type if necessary;
!== (strict not equal): Compares two values for inequality without type conversion.


              1234
            
let first = 5;
let second = '5';
console.log(first != second)
console.log(first !== second)

> (greater than): Checks if the left value is greater than the right value. For example:


              12
            
let example = 10 > 5; // true
console.log(example);

< (less than): Checks if the left value is less than the right value. For example:


              12
            
let example = 10 < 5; // false
console.log(example);

>= (greater than or equal to): Checks if the left value is greater than or equal to the right value.
<= (less than or equal to): Checks if the left value is less than or equal to the right value.


              12345
            
let first = 5;
let second = 5;
let third = 10;
console.log(first >= second);
console.log(first <= third);

Advanced

Type Casting Explanation:

Type casting, also known as type conversion, is the process of changing the data type of a value from one type to another. In TypeScript, this can be done explicitly using type assertions or conversion functions. For example, converting a number to a string:

Type casting is necessary when you want to ensure that a value is treated as a specific type in a particular context, especially when TypeScript's type inference is not sufficient. It helps you control the types of variables and avoid type-related errors in your code.

Note

We'll talk about what functions are and how to create and use them later in this course. It's an important topic, but for now, it's too early.

1. What's the difference between `==` and `===` in TypeScript?

2. Which operator do you use to check if one value is greater than another in TypeScript?

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 2. Capítulo 1