7 typer av JavaScript-operatörer du måste känna till

En operator är en symbol som talar om för tolken att utföra en specifik matematisk, relationell eller logisk operation. Operatörer tar en eller flera operander och kan manipulera målvärden eller operander.

I den här artikeln kommer du att lära dig om olika operatorer i JavaScript och hur du använder dem med exempel.

JavaScript-operatörstyper

Det här är de olika operatorerna som JavaScript stöder:

1. Aritmetiska operatorer
2. Uppdragsoperatörer
3. Strängoperatorer
4. Jämförelseoperatörer
5. Logiska operatorer
6. Bitvisa operatörer
7. Specialoperatörer

1. Aritmetiska operatorer

Du kan använda aritmetiska operatorer för att utföra matematiska beräkningar på operanderna. JavaScript tillhandahåller följande aritmetiska operatorer:

Tilläggsoperatör (+)

Du kan använda additionsoperatorn (+) för att utföra addition på operanderna.

låt a = 12;
låt b = 10;
låt resultatet = a+b;
console.log (resultat)
console.log (1+2);
console.log (a+6);

Produktion:

22
3
18

Subtraktionsoperatör (-)

Använd subtraktionsoperatorn (-) för att subtrahera den högra operanden från den vänstra operanden.

låt a = 10;
låt b = 4;
låt resultat = a-b;
console.log (resultat);
console.log (23-20);

Produktion:

6
3

Multiplikationsoperator (*)

Använd multiplikationsoperatorn (*) för att multiplicera operanderna.

låt a = 10;
låt b = 4;
låt resultat = a*b;
console.log (resultat);
console.log (23*20);

Produktion:

40
460

Divisionsoperatör (/)

Du kan använda divisionsoperatorn (/) för att utföra division på operanderna.

låt a = 10;
låt b = 4;
låt resultat = a/b;
console.log (resultat);
console.log (40/20);

Produktion:

2.5
2

Modulus Operator (%)

Moduloperatorn (%) returnerar heltalsresten genom att dyka två operander.

låt a = 10;
låt b = 4;
låt resultatet = a%b;
console.log (resultat);
console.log (40%20);

Produktion:

2
0

Exponentieringsoperatör (**)

Exponentieringsoperatorn (**) beräknar basen till exponentpotensen (bas^exponent).

låt a = 3;
console.log (a**4);

Produktion:

81

Öka operatör (++)

Inkrementoperatorn (++) ökar heltalsvärdet med ett.

låt a = 3;
// Värdet av a=4 och returnerar 4
console.log(++a);
// Värdet på a=5 och returnerar 4
console.log (a++);
// Värdet av a=5 och returnerar 5
console.log (a);

Produktion:

4
4
5

Minska operatör (--)

Minskningsoperatören (--) minskar heltalsvärdet med ett.

låt a = 3;
// Värdet av a=2 och returnerar 2
console.log(--a);
// Värdet av a=1 och returnerar 2
console.log (a--);
// Värdet av a=1 och returnerar 1
console.log (a);

Produktion:

2
2
1

Unary Plus-operatör (+)

Den unära plusoperatorn (+) försöker konvertera operanden till ett tal om det inte redan är det.

console.log (typeof("10"));
console.log (typeof(+"10"));
console.log (typeof (false));
console.log (typeof(+false));

Produktion:

sträng
siffra
booleskt
siffra

Unary Negation Operator(-)

Den unära negationsoperatorn (-) returnerar negationen av dess operand.

låt a = 10;
console.log(-a);

Produktion:

-10

2. Uppdragsoperatörer

Använd tilldelningsoperatorer för att tilldela värden till variabler. JavaScript tillhandahåller följande tilldelningsoperatorer:

Uppdragsoperatör(=)

Du kan använda uppdragsoperatorn (=) för att tilldela höger operandvärde till vänster operand.

// Tilldela 10 till en
låt a = 10;
console.log (a);

Produktion:

10

Tilläggsuppdragsoperatör (+=)

Tilläggsuppdragsoperatören (+=) används för att lägga till vänster och höger operandvärden och tilldela resultatet till den vänstra operanden.

låt a = 10;
låt b = 5;
// Motsvarar a = a+b
a += b;
console.log (a);

Produktion:

15

Subtraktionsuppdragsoperatör (-=)

Subtraktionstilldelningsoperatorn (-=) kommer att subtrahera den högra operanden från den vänstra operanden och tilldela resultatet till den vänstra operanden.

låt a = 10;
låt b = 5;
// Motsvarar a = a-b
a -= b;
console.log (a);

Produktion:

5

Multiplikationstilldelningsoperatör (*=)

Använd tilldelningsoperatorn för multiplikation (*=) för att multiplicera vänster- och högeroperandvärdena och tilldela resultatet till vänsteroperand.

låt a = 10;
låt b = 5;
// Motsvarar a = a*b
a *= b;
console.log (a);

Produktion:

50

Division Assignment Operator (/=)

Du kan använda operatören för divisionstilldelning (/=) för att dela det vänstra operandvärdet med det högra operandvärdet och tilldela resultatet till den vänstra operanden.

låt a = 10;
låt b = 5;
// Motsvarar a = a/b
a /= b;
console.log (a);

Produktion:

2

Återstående uppdragsoperatör (%=)

Den återstående uppdragsoperatören (%=) delar den vänstra operanden med den högra operanden och tilldelar resten till den vänstra operanden.

låt a = 10;
låt b = 5;
// Motsvarar a = a%b
a %=b;
console.log (a);

Produktion:

0

Exponentieringstilldelningsoperatör (**=)

Operatorn för exponentieringstilldelning (**=) höjer den vänstra operanden till höger operand och tilldelar resultatet till den vänstra operanden.

låt a = 10;
låt b = 5;
// Motsvarar a = a**b
a **= b;
console.log (a);

Produktion:

100000

De bitvisa tilldelningsoperatorerna (<<=, >>=, >>>=, &=, ^=, |=, &&=, ||=, ??=) fungerar på liknande sätt. Du kommer att lära dig om de bitvisa operatorerna i de kommande avsnitten.

Relaterad: En introduktion till datatyper i JavaScript

3. Strängoperatörer

Sammankopplingsoperatorn (+) används för att sammanfoga (lägga till) strängar.

let result = "Make" + "Använd" + "Av";
console.log (resultat);

Produktion:

Använda

4. Jämförelseoperatörer

Jämförelseoperatorer används för att jämföra operander och det returnerar ett logiskt värde (Sann eller falsk) på basis av jämförelse. JavaScript tillhandahåller följande jämförelseoperatorer:

Equal Operator (==)

Den lika operatorn (==) returnerar Sann om operanderna är lika. Den jämför bara värdena för operander och ignorerar deras typ medan den jämförs.

console.log (2==4);
console.log("2"==2);

Produktion:

falsk
Sann

Inte lika operatör(!=)

Inte lika operatör (!=) returnerar Sann om operanderna inte är lika. Den ignorerar också typen av operander vid jämförelse.

console.log (2!=4);
console.log (2!="2");

Produktion:

Sann
falsk

Strict Equal-operatör ()

Den strikt lika operatören () returnerar Sann om operanderna är lika. Den jämför båda – värdena och typerna av operander medan man jämför.

console.log (24);
console.log("2"2);

Produktion:

falsk
falsk

Strict Not Equal Operator (!==)

Den strikt inte lika operatören (!==) returnerar Sann om operanderna inte är lika. Den jämför också båda – värdena och typen av operander under jämförelse.

console.log (2 !== 4);
console.log (2 !== "2");

Produktion:

Sann
Sann

Större än operatören (>)

Den större än operatorn (>) returnerar sant om den vänstra operanden är större än den högra operanden.

console.log (10>4);
console.log (5>5);

Produktion:

Sann
falsk

Större än eller lika operatör (>=)

Operatorn större än eller lika (>=) returnerar sant om den vänstra operanden är större än eller lika med den högra operanden.

console.log (10 >= 4);
console.log (5 >= 5);

Produktion:

Sann
Sann

Mindre än operatör (

Den mindre än-operatören (<) returnerar sant om den vänstra operanden är mindre än den högra operanden.

console.log (10<4);
console.log (5<5);

Produktion:

falsk
falsk

Mindre än eller lika operatör(<=)

Operatorn mindre än eller lika (<=) returnerar sant om den vänstra operanden är mindre än eller lika med den högra operanden.

console.log (10 <= 4);
console.log (5 <= 5);

Produktion:

falsk
Sann

Relaterad: Hur man bygger en enkel kalkylator med HTML, CSS och JavaScript

5. Logiska operatörer

Enligt tjänstemannen MDN Dokument, JavaScript tillhandahåller följande logiska operatorer:

Logiskt OCH (&&)

Användande: expr1 && expr2

Returnerar expr1 om det kan konverteras till false; annars returnerar expr2. När det används med booleska värden, && returnerar Sann om båda operanderna är sanna; annars kommer den tillbaka falsk.

console.log (true && false);

Produktion:

falsk

Logiskt ELLER (||)

Användande: expr1 || expr2

Returnerar expr1 om den kan konverteras till true; annars returnerar expr2. När det används med booleska värden, || returnerar Sann om endera operanden är sann; om båda är falska, returneras falsk.

console.log (true || false);

Produktion:

Sann

Logisk INTE (!)

Användande: !expr

Returnerar falsk om dess enda operand kan konverteras till sant; annars återkommer Sann.

console.log(!true);

Produktion:

falsk

6. Bitwise operatörer

JavaScript tillhandahåller följande bitvisa operatorer:

Bitvis OCH Operator (&)

Denna operatör utför en Boolean OCH operation på varje bit av dess heltalsargument.

// I binär-
// 4: 100
// 1: 001
console.log (4 & 1);

Produktion:

0

Bitvis ELLER Operator (|)

Denna operatör utför en Boolean ELLER operation på varje bit av dess heltalsargument.

console.log (4 | 1);

Produktion:

5

Bitvis XOR-operatör (^)

Denna operatör utför en boolesk exklusiv ELLER operation på varje bit av dess heltalsargument.

console.log (4 ^ 1);

Produktion:

5

Bitvis INTE Operator (~)

Denna operator vänder alla bitar i operanden.

console.log(~4);

Produktion:

-5

Notera: JavaScript konverterar tal till 32-bitars heltal med tecken innan en bitvis operation utförs. Och när operationen utförs konverterar den resultatet tillbaka till 64-bitars JavaScript-nummer.

Vänster växeloperatör (<

Denna operator flyttar alla bitar i sin första operand åt vänster med antalet platser som anges i den andra operanden.

console.log (4<<1);

Produktion:

8

Högerväxlingsoperatör (>>)

Denna operator flyttar alla bitar i sin första operand åt höger med antalet platser som anges i den andra operanden.

console.log (4>>1);

Produktion:

2

7. Specialoperatörer

Ternär operatör

Den ternära operatorn är förkortningen av if-else uttalande. Den tilldelar värde till en variabel baserat på ett villkor, syntaxen för densamma är:

skick? värde1: värde2

Om villkoret är sant returnerar operatören värdet på värde1. Annars returnerar den värdet på värde2.

låt resultatet = (200>100)? "Ja Nej";
console.log (resultat);

Produktion:

Ja

Typ av operatör

De sorts operator används för att hitta datatypen för ett värde eller en variabel.

console.log (typeof (100));
console.log (typeof("100"));

Produktion:

siffra
sträng

Använd JavaScript One-Liners för att koda som ett proffs

Du kan utföra ett brett utbud av operationer med bara en kodrad i JavaScript. Oavsett om du behöver blanda en array, upptäcka mörkt läge i en webbläsare, generera slumpmässigt UUID eller hitta medelvärdet för en array, kan du uppnå det med bara en rad kod.

11 JavaScript One-liners du bör känna till

Uppnå mycket med bara lite kod genom att använda detta breda utbud av JavaScript-one-liners.

Läs Nästa

Om författaren