Operatorer i JavaScript

I den här artikeln kommer vi att förklara operatorer i JavaScript.

YouTube Video

Operatorer i JavaScript

Operatorer i JavaScript är symboler eller nyckelord som används för att utföra beräkningar eller jämförelser på tal och variabler. Det finns olika typer av operatorer, som var och en utför olika operationer. Här är en sammanfattning av några av de viktigaste operatorerna:.

Aritmetiska operatorer

JavaScripts aritmetiska operatorer inkluderar följande:.

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

Aritmetiska operatorer utför grundläggande matematiska beräkningar på tal. Förutom addition och subtraktion kan du utföra operationer som modulus, increment och decrement. Observera att värdet som returneras vid ökning eller minskning skiljer sig beroende på om operatorn placeras före eller efter operanden.

Tilldelningsoperatorer

JavaScripts tilldelningsoperatorer inkluderar följande:.

 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

Tilldelningsoperatorer används för att tilldela värden till variabler eller uppdatera värdena för variabler. Förutom vanlig tilldelning finns det tilldelningsoperatorer för aritmetiska operationer som addition och modulus.

Jämförelseoperatorer

JavaScripts jämförelseoperatorer inkluderar följande:.

 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

• Jämförelseoperatorer jämför värden och returnerar antingen sant eller falskt.
• Jämförelseoperatorn (==) konverterar automatiskt olika typer om det behövs innan jämförelsen utförs. Den strikta jämförelseoperatorn (===) utför ingen typkonvertering under jämförelsen och returnerar true endast om båda värdena har samma typ och samma värde. Att använda den strikta jämförelseoperatorn (===) hjälper till att förhindra buggar orsakade av oavsiktlig typkonvertering, så det rekommenderas att använda den i första hand.

Logiska operatorer

JavaScripts logiska operatorer inkluderar följande:.

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

Logiska operatorer används när det finns flera villkor, för att utvärdera kombinationer av villkor.

Prioritet för logiska operatorer

I JavaScript utvärderas logiska operatorer vanligtvis i ordningen NOT först, följt av AND och slutligen OR.

NOT har högst prioritet

NOT är en unär operator och utvärderas med högst prioritet.

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

AND har högre prioritet än OR

AND har högre prioritet än OR, så AND-delen utvärderas först.

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

På detta sätt utvärderas AND (&&)-delen först, och dess resultat vidarebefordras till OR (||).

AND och OR utför kortslutningsutvärdering

JavaScripts AND och OR utför kortslutningsutvärdering. Om resultatet kan bestämmas av värdet på vänster sida utvärderas inte uttrycket på höger sida.

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 båda fallen kommer console.log() inte att köras.

Fastställ explicit prioritet

Genom att explicit gruppera uttryck med parenteser kan du undvika missförstånd om prioritet.

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

Skillnader mellan naturligt språk och programtolkning

Vid användning av logiska operatorer är det viktigt att vara medveten om tvetydigheter i naturligt språk. Till exempel, när man säger 'vit hund eller katt' kan det betyda antingen 'en vit hund eller en katt av vilken färg som helst' eller 'en vit hund eller en vit katt.'. I kod skulle det se ut så här:.

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

Eftersom naturligt språk innehåller tvetydigheter som detta krävs försiktighet vid kodning eller design.

Ternär operator (Villkorsoperator)

JavaScript inkluderar en ternär operator (villkorsoperator).

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

Den skrivs i formen villkor ? värde om sant : värde om falskt.

Bitvisa operatorer

JavaScripts bitvisa operatorer inkluderar följande.

 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)

Bitoperatorer utför beräkningar på tal på bitnivå. De används vanligtvis för lågnivåbearbetning.

Typoperatorer

JavaScripts typoperatorer inkluderar följande.

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

Typoperatorer används för att kontrollera en värdes typ eller konvertera det till en specifik typ.

typeof-operatorn returnerar typen av en variabel.

instanceof-operatorn kontrollerar om ett objekt tillhör en specifik klass.

Sammanfattning

• Aritmetiska operatorer utför grundläggande beräkningar.
• Tilldelningsoperatorer tilldelar eller uppdaterar värden i variabler.
• Jämförelseoperatorer jämför två värden och returnerar sant eller falskt.
• Logiska operatorer utvärderar kombinationer av villkor.
• Ternära operatorer låter dig skriva villkorssatser i en kortare form än if.
• Bitvisa operatorer utför beräkningar på bitnivå.
• Typoperatorer låter dig kontrollera typen av ett värde.

Du kan följa med i artikeln ovan med hjälp av Visual Studio Code på vår YouTube-kanal. Vänligen kolla även in YouTube-kanalen.

YouTube Video