Vergleichsoperatoren

Beginnen wir damit, was Vergleichsoperatoren überhaupt sind. Also...

Hier sind die wichtigsten Vergleichsoperatoren in TypeScript:

== (equal): Vergleicht zwei Werte auf Gleichheit und konvertiert sie bei Bedarf in einen gemeinsamen Typ. Zum Beispiel:

let example = 5 == "5";

console.log(example); // true


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

=== (strikte Gleichheit): Vergleicht zwei Werte auf Gleichheit ohne Typumwandlung. Dieser Operator berücksichtigt sowohl Typ als auch Wert. Zum Beispiel:

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);


              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);

!= (ungleich): Vergleicht zwei Werte auf Ungleichheit, indem sie bei Bedarf in einen gemeinsamen Typ umgewandelt werden;
!== (strikte Ungleichheit): Vergleicht zwei Werte auf Ungleichheit ohne Typumwandlung.

let first = 5;

let second = '5';

console.log(first != second)

console.log(first !== second)


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

> (größer als): Überprüft, ob der linke Wert größer als der rechte Wert ist. Zum Beispiel:

let example = 10 > 5; // true

console.log(example);


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

< (kleiner als): Überprüft, ob der linke Wert kleiner als der rechte Wert ist. Zum Beispiel:

let example = 10 < 5; // false

console.log(example);


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

>= (größer als oder gleich): Überprüft, ob der linke Wert größer als oder gleich dem rechten Wert ist.
<= (kleiner als oder gleich): Überprüft, ob der linke Wert kleiner als oder gleich dem rechten Wert ist.

let first = 5;

let second = 5;

let third = 10;

console.log(first >= second);

console.log(first <= third);


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

Fortgeschritten

Erklärung der Typumwandlung:

Typumwandlung, auch bekannt als Typkonvertierung, ist der Prozess der Änderung des Datentyps eines Wertes von einem Typ in einen anderen. In TypeScript kann dies explizit mit Typ-Assertions oder Konvertierungsfunktionen durchgeführt werden. Zum Beispiel die Umwandlung einer Zahl in einen String:


javascript
9
1
2
3
let num: number = 42;
let str: string = num.toString(); 
// Explicit type casting from number to string

Typumwandlung ist notwendig, wenn Sie sicherstellen möchten, dass ein Wert in einem bestimmten Kontext als ein bestimmter Typ behandelt wird, insbesondere wenn die Typinferenz von TypeScript nicht ausreicht. Es hilft Ihnen, die Typen von Variablen zu kontrollieren und typbezogene Fehler in Ihrem Code zu vermeiden.

Hinweis

Wir werden später in diesem Kurs darüber sprechen, was functions sind und wie man sie erstellt und verwendet. Es ist ein wichtiges Thema, aber im Moment ist es noch zu früh.

1. Was ist der Unterschied zwischen `==` und `===` in TypeScript?

2. Welchen Operator verwenden Sie, um zu überprüfen, ob ein Wert größer als ein anderer in TypeScript ist?

War alles klar?

Danke für Ihr Feedback!

Abschnitt 2. Kapitel 1

Fragen Sie AI

Fragen Sie alles oder probieren Sie eine der vorgeschlagenen Fragen, um unser Gespräch zu beginnen

Vergleichsoperatoren

Fortgeschritten

Erklärung der Typumwandlung:

1. Was ist der Unterschied zwischen == und === in TypeScript?

2. Welchen Operator verwenden Sie, um zu überprüfen, ob ein Wert größer als ein anderer in TypeScript ist?

1. Was ist der Unterschied zwischen `==` und `===` in TypeScript?