Operatorer i JavaScript

I denne artikkelen forklarer vi operatorene i JavaScript.

YouTube Video

Operatorer i JavaScript

Operatorer i JavaScript er symboler eller nøkkelord som brukes til å utføre beregninger eller sammenligninger på tall og variabler. Det finnes ulike typer operatører, som hver utfører forskjellige operasjoner. Her er noen av de viktigste operatorene oppsummert:.

Aritmetiske operatorer

JavaScript sine aritmetiske operatører 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 utfører grunnleggende matematiske operasjoner på tall. I tillegg til addisjon og subtraksjon kan du utføre operasjoner som modulus, inkrement og dekrement. Merk at verdien som returneres av inkrement eller dekrementering avhenger av om operatoren er plassert før eller etter operanden.

Tildelingsoperatorer

JavaScript sine tilordningsoperatører 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 brukes til å tilordne verdier til variabler eller oppdatere verdier til variabler. I tillegg til vanlig tilordning finnes det tilordningsoperatorer for aritmetiske operasjoner som addisjon og modulus.

Sammenligningsoperatorer

JavaScript sine sammenlikningsoperatører 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 verdier og returnerer enten sann eller falsk.
• Likhetsoperatoren (==) konverterer automatisk ulike typer om nødvendig før sammenligningen utføres. Den strenge likhetsoperatoren (===) utfører ingen typekonvertering under sammenligning og returnerer true bare hvis begge verdiene har samme type og samme verdi. Å bruke den strenge likhetsoperatoren (===) bidrar til å forhindre feil forårsaket av utilsiktet typekonvertering, så det anbefales å bruke den fortrinnsvis.

Logiske operatorer

JavaScript sine logiske operatører 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 brukes når det er flere betingelser for å evaluere kombinasjoner av betingelser.

Prioritet for logiske operatører

I JavaScript evalueres logiske operatører generelt i rekkefølgen NOT først, etterfulgt av AND og til slutt OR.

NOT har høyest prioritet

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

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

AND har høyere prioritet enn OR

AND har høyere prioritet enn OR, så AND-delen evalueres først.

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

På denne måten evalueres AND (&&)-delen først, og resultatet sendes til OR (||).

AND og OR utfører kortslutningsevaluering

JavaScript sine AND og OR utfører kortslutningsevaluering. Hvis resultatet kan bestemmes av venstresidens verdi, blir ikke høyresidens uttrykk evaluert.

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 tilfeller vil ikke console.log() bli kjørt.

Etabler eksplisitt prioritet

Ved å uttrykkelig gruppere uttrykkene med parenteser, kan du forhindre misforståelser om prioritetsrekkefølge.

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

Forskjeller mellom naturlig språk og programtolkning

Når du bruker logiske operatører, er det viktig å være oppmerksom på tvetydigheter i naturlig språk. For eksempel, når man sier 'hvit hund eller katt,' kan det bety enten 'en hvit hund eller en hvilken som helst farge på katt' eller 'en hvit hund eller en hvit katt.'. I kode vil det se slik ut:.

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

Siden naturlig språk inneholder slike tvetydigheter, må man være nøye når man koder eller designer.

Ternær operator (betingelsesoperator)

JavaScript inkluderer en ternær operator (betingelsesoperator).

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

Den skrives i formen betingelse ? verdi hvis sann : verdi hvis falsk.

Bitvis operatorer

JavaScript bitvise operatorer inkluderer 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)

Bitoperatorer utfører beregninger på tall på bitnivå. De brukes vanligvis til lavnivåbehandling.

Typeoperatorer

JavaScript typeoperatorer inkluderer 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

Typeoperatorer brukes til å kontrollere typen til en verdi eller til å konvertere den til en spesifikk type.

typeof-operatoren returnerer typen til en variabel.

instanceof-operatoren sjekker om et objekt tilhører en spesifikk klasse.

Sammendrag

• Aritmetiske operatorer utfører grunnleggende beregninger.
• Tildelingsoperatorer tilordner eller oppdaterer verdier i variabler.
• Sammenligningsoperatorer sammenligner to verdier og returnerer true eller false.
• Logiske operatorer vurderer kombinasjoner av betingelser.
• Ternære operatorer lar deg skrive betingede utsagn i en kortere form enn if.
• Bitvise operatorer utfører beregninger på bitnivå.
• Typeoperatorer lar deg kontrollere typen til en verdi.

Du kan følge med på artikkelen ovenfor ved å bruke Visual Studio Code på vår YouTube-kanal. Vennligst sjekk ut YouTube-kanalen.

YouTube Video