Betreiber in JavaScript

Im wirklichen Leben haben Sie gesehen, wie wir hinzufügen, zwei Werte subtrahieren. In ähnlicher Weise wird diese Aktion in einer Programmiersprache durch die Hilfe von durchgeführt Betreiber. In einfachen Worten, mathematisch oder logisch Operationen können durch den Einsatz von Operatoren durchgeführt werden. Die Bediener führen diese Funktionen auf einzelner oder mehrfacher aus Operanden Ergebnisse erzielen. Hier sind Operanden die Datenwerte, für die Vorgänge ausgeführt werden.

Wie jede andere Programmiersprache verwendet JavaScript auch verschiedene Operatoren. Es ist hilfreich, da es die Aufgabe des Vergleichs und Manipulation von Werten für den Benutzer erleichtert.

In diesem Artikel werden wir verschiedene Betreiber in JavaScript zusammen mit ihrer Verwendung und Beispielen besprechen.

Art der Betreiber in JavaScript

In JavaScript sind verschiedene Betreiber verfügbar, einige sind unten aufgeführt:

1. Rechenzeichen
2. Zuordnungsbetreiber
3. Vergleichsoperatoren
4. Logische Operatoren
5. String -Operatoren

Verstehen wir diese Betreiber einzeln mit Beispielen für ein besseres Verständnis.

Rechenzeichen

Arithmetische Operatoren helfen bei der Durchführung aller mathematischen Grundberechnungen wie Addition, Subtraktion, Multiplikation und Abteilung. Im Folgenden finden Sie verschiedene arithmetische Operatoren:

Betreiber	Name
+	Zusatz
-	Subtraktion
/	Aufteilung
*	Multiplikation
%	Rest
++	Erhöhung um 1
-	Abnehmen um 1
**	Exponentiell (Macht)

Beispiel für arithmetische Operatoren

Sei x = 3;
lass y = 2;
// Addition
Konsole.log ('x + y =', x + y); // 5
// Subtraktion
Konsole.log ('x - y =', x - y); // 1
// Multiplikation
Konsole.log ('x * y =', x * y); // 6
// Aufteilung
Konsole.log ('x / y =', x / y); // 1.5
// Rest von 3/2 wird 1 sein
Konsole.log ('x % y =', x % y); // 1
// Erhöht um 1
Konsole.log ('++ x =', ++ x); // x wird 4 sein
Konsole.log ('x ++ =', x ++); // Drucke 4 und dann auf 5 erhöht
Konsole.log ('x =', x); // 5
// Abnahme um 1
Konsole.log ('-x =', --x); // x wird 4 sein
Konsole.log ('x-- =', x--); // Drucke 4 und dann auf 3 abgenommen
Konsole.log ('x =', x); // 3
// Exponentiation
Konsole.log ('x ** y =', x ** y); // 3 Kraft von 2 ist 9

Zuordnungsbetreiber

In JavaScript werden Zuweisungsoperatoren verwendet, um einer Variablen einige Werte zuzuweisen. Zum Beispiel:

Sei x = 3;
const y = 5;

Hier sind x und y Variablen, denen die Werte 3 bzw. 5 zugewiesen werden. Im Folgenden finden Sie einige Zuordnungsoperatoren:

Betreiber	Name
=	Abtretung
+=	Additionszuordnung
-=	Subtraktionszuordnung
*=	Multiplikationszuweisung
/=	Abteilungsaufgabe
%=	Restzuordnung
** =	Exponentiationszuordnung

Beispiel für Zuordnungsbetreiber

Sei x = 3; // Werte mit dem Zuordnungsbetreiber zuweisen
// Additionszuweisung
Konsole.log ('x += 3', x += 3); // 6, jetzt x = 6
// Subtraktionszuweisung
Konsole.log ('x -= 2', x -= 2); // 4, jetzt x = 4
// Multiplikationszuweisung
Konsole.log ('x *= 2', x *= 2); // 8, jetzt x = 8
// Abteilungsaufgabe
Konsole.log ('x /= 2', x /= 2); // 4
// Restzuweisung
Konsole.log ('x %= 2', x %= 2); // 0
// Exponentiationszuweisung
sei x = 5;
Konsole.log ('x ** = 2', x ** = 2); // 25

Vergleichsoperatoren

Vergleichsbetreiber arbeiten, indem sie zwei Werte vergleichen und wahr und falsch zurückgeben:

Betreiber	Name
==	Gleich
!=	Nicht gleich
===	Streng gleich
!==	Streng nicht gleich gleich
>	Größer als
<	Weniger als
> =	Größer als oder gleich
<=	Weniger als oder gleich

Beispiel für Vergleichsoperatoren:

// Gleicher Operator
Konsole.log (3 == 2); // FALSCH
Konsole.log (3 == '3'); // WAHR
// kein gleicher Bediener
Konsole.Protokoll (3 != 4); // WAHR
Konsole.log ('Welt' != 'Welt'); // FALSCH
// Strikter gleicher Operator
Konsole.log (7 === '7'); // FALSCH
Konsole.log (6 === 6); // WAHR
// streng nicht gleicher Bediener
Konsole.Protokoll (8 !== '8'); // WAHR
Konsole.Protokoll (3 !== 3); // FALSCH

Logische Operatoren

Logische Operatoren werden verwendet, um logische Operationen für Datenwerte zu verarbeiten. Daher geben sie einen Booleschen Wert zurück:

Betreiber	Name
&&	Logisch und
||	Logisch oder
!	Logisch nicht

Beispiel für logische Operatoren:

// logisch und
Konsole.log (7 == 7 && 7 == 7); // true und der Bediener funktioniert, wenn beide angegebenen Aussagen wahr sind
Konsole.log (7 == 7 && 7 == 87!= 7); // Falsch, eine der Aussagen ist nicht wahr
// logisch oder
Konsole.log (7 == 7 || 7!= 7); // True oder Operator funktioniert, wenn eine der angegebenen zwei Aussagen wahr ist
// logisch nicht
Konsole.Protokoll(!7 == 7); // falsch, wäre wahr gewesen, wenn der Ausdruck nicht wahr wäre.

String -Operatoren

String -Operatoren werden verwendet, um zwei oder mehr Zeichenfolgen oder eine Nummer und eine Zeichenfolge zu verbinden.

Beispiel für String -Operatoren:

Sei x = 5 + 25; // 30
Sei y = "5" + 5; // 55
sei z = "Welt" + 5; // World5

Abschluss

Typeof -Operatoren in JavaScript werden verwendet, um das Programm darüber zu informieren, welcher mathematische Betrieb durchgeführt werden soll. In diesem Artikel haben wir verschiedene Operatoren in JavaScript gelernt, wie sie verwendet werden und ihre Funktionalität. Die Bediener helfen den Benutzern, schwierige Aufgaben problemlos und logischerweise logisch auszuführen.

Jeder spezifische Bediener steht dem Benutzer zur Verfügung, um eine bestimmte Funktionalität in seinem Programm zu implementieren. Ich hoffe, dies hilft Ihnen bei einem besseren Verständnis der Betreiber in JavaScript und im Allgemeinen, da die Kernkonzepte in jeder Programmiersprache miteinander verbunden sind.