Operatorer i JavaScript

I denne artikel vil vi forklare operatorer i JavaScript.

YouTube Video

Operatorer i JavaScript

Operatorer i JavaScript er symboler eller nøgleord, der bruges til at udføre beregninger eller sammenligninger på tal og variabler. Der er forskellige typer operatorer, der hver især udfører forskellige operationer. Her er en oversigt over nogle af de vigtigste operatorer:.

Aritmetiske Operatorer

JavaScript's aritmetiske operatorer inkluderer følgende:.

 1let a = 10; // Initialize variable 'a' with the value 10
 2let b = 3;  // Initialize variable 'b' with the value 3
 3
 4// Perform and display arithmetic operations between 'a' and 'b'
 5console.log("Addition (a + b):      ", a + b); // 13
 6console.log("Subtraction (a - b):   ", a - b); // 7
 7console.log("Multiplication (a * b):", a * b); // 30
 8console.log("Division (a / b):      ", a / b); // 3.333...
 9console.log("Modulus (a % b):       ", a % b); // 1
10
11// Demonstrate post-increment operation on 'a'
12// Output the current value of 'a' (10), then increment
13console.log("Post-increment (a++):  ", a++);
14// Display the incremented value of 'a' (11)
15console.log("Value of 'a' after increment:", a);
16
17// Demonstrate pre-increment operation on 'a'
18// Increment 'a' first (12) then output
19console.log("Pre-increment (++a):   ", ++a);
20
21// Demonstrate post-decrement operation on 'a'
22// Output the current value of 'a' (12), then decrement
23console.log("Post-decrement (a--):  ", a--);
24// Display the decremented value of 'a' (11)
25console.log("Value of 'a' after decrement:", a);
26
27// Demonstrate pre-decrement operation on 'a'
28// Decrement 'a' first (10) then output
29console.log("Pre-decrement (--a):   ", --a);

Aritmetiske operatorer udfører grundlæggende matematiske operationer på tal. Udover addition og subtraktion kan du udføre operationer som modulus, inkrement og dekrement. Bemærk, at værdien returneret af inkrement eller dekrement varierer afhængigt af, om operatoren er placeret før eller efter operanden.

Tildelingsoperatorer

JavaScript's tildelingsoperatorer inkluderer følgende:.

 1let x = 10;
 2
 3x += 5;  // x = x + 5, so x becomes 15
 4console.log('After x += 5 : ', x);  // 15
 5
 6x -= 10;
 7console.log('After x -= 10 : ', x);  // 5
 8
 9x *= 3;
10console.log('After x *= 3 : ', x);  // 15
11
12x /= 3;
13console.log('After x /= 3 : ', x);  // 5
14
15x %= 2;
16console.log('After x %= 2 : ', x);  // 1

Tilordningsoperatorer bruges til at tildele værdier til variabler eller opdatere variablernes værdier. Ud over almindelig tilordning findes der tilordningsoperatorer til aritmetiske operationer som addition og modulus.

Sammenligningsoperatorer

JavaScript's sammenligningsoperatorer inkluderer følgende:.

 1console.log("5 == '5' evaluates to:", 5 == "5");   // true (because the values are equal)
 2console.log("5 === '5' evaluates to:", 5 === "5"); // false (because the types are different)
 3console.log("5 != '5' evaluates to:", 5 != "5");   // false
 4console.log("5 !== '5' evaluates to:", 5 !== "5"); // true
 5console.log("5 > 2 evaluates to:", 5 > 2);         // true
 6console.log("5 < 2 evaluates to:", 5 < 2);         // false
 7console.log("5 >= 5 evaluates to:", 5 >= 5);       // true
 8console.log("5 <= 4 evaluates to:", 5 <= 4);       // false
 9console.log("5 >= '5' evaluates to:", 5 >= "5");   // true
10console.log("5 <= '5' evaluates to:", 5 <= "5");   // true

• Sammenligningsoperatorer sammenligner værdier og returnerer enten sandt eller falsk.
• Lighedsoperatoren (==) konverterer automatisk forskellige typer, om nødvendigt, før sammenligningen udføres. Den strikte lighedsoperator (===) udfører ingen typekonvertering under sammenligningen og returnerer kun true, hvis begge værdier har samme type og samme værdi. Ved at bruge den strikte lighedsoperator (===) kan man undgå fejl forårsaget af utilsigtet typekonvertering, så det anbefales at foretrække dens brug.

Logiske operatorer

JavaScript's logiske operatorer inkluderer følgende:.

1let a = true;
2let b = false;
3
4console.log("a && b evaluates to:", a && b);  // false
5console.log("a || b evaluates to:", a || b);  // true
6console.log("!a evaluates to:", !a);          // false

Logiske operatorer bruges, når der er flere betingelser, til at evaluere kombinationer af betingelser.

Prioritet for logiske operatorer

I JavaScript evalueres logiske operatorer generelt i rækkefølgen NOT først, efterfulgt af AND og til sidst OR.

NOT har den højeste prioritet

NOT er en unær operator og evalueres med den højeste prioritet.

1console.log(!true || false);  // false

AND har højere prioritet end OR

AND har højere prioritet end OR, så AND-delen evalueres først.

1console.log(true || false && false);  // true

På denne måde evalueres AND (&&)-delen først, og dens resultat sendes videre til OR (||).

AND og OR udfører kortslutningsevaluering

JavaScript's AND og OR udfører kortslutningsevaluering. Hvis resultatet kan bestemmes af venstresidens værdi, evalueres højresidens udtryk ikke.

1let a = false && console.log("This will not be printed");
2console.log(a);  // false
3
4let b = true || console.log("This will not be printed");
5console.log(b);  // true

I begge tilfælde vil console.log() ikke blive udført.

Etabler eksplicit prioritet

Ved eksplicit at gruppere udtryk med parenteser kan du forhindre misforståelser om prioritet.

1console.log(true || (false && false));  // true

Forskelle mellem naturligt sprog og programfortolkning

Når du bruger logiske operatorer, er det vigtigt at være opmærksom på tvetydigheder i naturligt sprog. For eksempel, når man siger 'hvid hund eller kat', kan det betyde enten 'en hvid hund eller en kat af enhver farve' eller 'en hvid hund eller en hvid kat.'. I kode ville det se sådan ud:.

1if (isWhite && isDog || isCat) {
2    console.log(' "A white dog" or "a cat of any color" ');
3}
4
5if (isWhite && (isDog || isCat)) {
6    console.log(' "A white dog" or "a white cat" ');
7}
8
9console.log(true || (false && false));  // true

Da naturligt sprog indeholder tvetydigheder som denne, skal man være forsigtig, når man koder eller designer.

Ternær Operator (Betinget Operator)

JavaScript inkluderer en ternær operator (betinget operator).

1let age = 20;
2let message = age >= 18 ? "Adult" : "Minor";
3console.log(message);  // "Adult"

Det skrives i formen betingelse ? værdi hvis sandt : værdi hvis falsk.

Bitvise Operatorer

JavaScript bitvise operatorer omfatter følgende.

 1let x = 0x0F & 0x0C;
 2console.log("0x0F & 0x0C evaluates to:", x, "(0x0C, 12)");  // 0x0C (12)
 3
 4x = 0x04 | 0x02;
 5console.log("0x04 | 0x02 evaluates to:", x, "(0x06, 6)");  // 0x06 (6)
 6
 7x = 0x0F ^ 0x0C;
 8console.log("0x0F ^ 0x0C evaluates to:", x, "(0x03, 3)");  // 0x03 (3)
 9
10// The inverted number is represented as a negative value
11// because JavaScript numbers are stored as signed 32-bit integers.
12x = ~0x0C;
13console.log("~0x0C evaluates to:", x, "(-13, 0xF3)");  // 0xF3 (-13)
14
15x = 0x04 << 1;
16console.log("0x04 << 1 evaluates to:", x, "(0x08, 8)");    // 0x08 (8)
17x = 0x04 >> 1;
18console.log("0x04 >> 1 evaluates to:", x, "(0x02, 2)");    // 0x02 (2)

Bitoperatører udfører beregninger på tal på bitniveau. De bruges normalt til lavniveau-behandling.

Typeoperatører

JavaScript typeoperatorer omfatter følgende.

1console.log(typeof "Hello");  // "string"
2console.log(typeof 42);       // "number"
3
4let arr = [1, 2, 3];
5console.log("arr instanceof Array : ", arr instanceof Array); // true

Typeoperatører bruges til at kontrollere typen af en værdi eller konvertere den til en bestemt type.

typeof-operatoren returnerer typen af en variabel.

instanceof-operatoren kontrollerer, om et objekt tilhører en specifik klasse.

Sammendrag

• Aritmetiske operatører udfører grundlæggende beregninger.
• Tildelingsoperatører tildeler eller opdaterer værdier i variabler.
• Sammenligningsoperatører sammenligner to værdier og returnerer sandt eller falsk.
• Logiske operatører evaluerer kombinationer af betingelser.
• Ternære operatører gør det muligt at skrive betingede udtryk i en kortere form end if.
• Bitvise operatører udfører beregninger på bitniveau.
• Typeoperatører giver mulighed for at kontrollere typen af en værdi.

Du kan følge med i ovenstående artikel ved hjælp af Visual Studio Code på vores YouTube-kanal. Husk også at tjekke YouTube-kanalen.

YouTube Video