I den här handledningen lär du dig om olika operatörer som finns tillgängliga i JavaScript och hur du använder dem med hjälp av exempel.
Vad är en operatör?
I JavaScript är en operatör en speciell symbol som används för att utföra operationer på operander (värden och variabler). Till exempel,
2 + 3; // 5
Här +är en operatör som utför addition och 2och 3är operander.
JavaScript-operatörstyper
Här är en lista över olika operatörer som du kommer att lära dig i denna handledning.
- Uppdragsoperatörer
- Aritmetiska operatörer
- Jämförelseoperatörer
- Logiska operatörer
- Bitvisa operatörer
- Strängoperatörer
- Andra operatörer
JavaScript-tilldelningsoperatörer
Tilldelningsoperatörer används för att tilldela variabler värden. Till exempel,
const x = 5;
Här används =operatören för att tilldela värde 5till variabel x.
Här är en lista över vanliga uppdragsoperatörer:
| Operatör | namn | Exempel |
|---|---|---|
= | Uppdragsoperatör | a = 7; // 7 |
+= | Tilläggsuppgift | a += 5; // a = a + 5 |
-= | Subtraktionstilldelning | a -= 2; // a = a - 2 |
*= | Multiplikationstilldelning | a *= 3; // a = a * 3 |
/= | Division Uppdrag | a /= 2; // a = a / 2 |
%= | Resterande uppdrag | a %= 2; // a = a % 2 |
**= | Exponentieringstilldelning | a **= 2; // a = a**2 |
Obs! Den vanligaste uppdragsoperatören är =. Du kommer att förstå andra tilldelningsoperatorer såsom +=, -=, *=etc. När vi lär aritmetiska operatörer.
JavaScript-aritmetiska operatörer
Aritmetiska operatorer används för att utföra aritmetiska beräkningar . Till exempel,
const number = 3 + 5; // 8
Här används +operatören för att lägga till två operander.
| Operatör | namn | Exempel |
|---|---|---|
+ | Tillägg | x + y |
- | Subtraktion | x - y |
* | Multiplikation | x * y |
/ | Division | x / y |
% | Resten | x % y |
++ | Inkrement (steg med 1) | ++x eller x++ |
-- | Minskning (minskning med 1) | --x eller x-- |
** | Exponentiering (kraft) | x ** y |
Exempel 1: Aritmetiska operatorer i JavaScript
let x = 5; let y = 3; // addition console.log('x + y = ', x + y); // subtraction console.log('x - y = ', x - y); // multiplication console.log('x * y = ', x * y); // division console.log('x / y = ', x / y); // remainder console.log('x % y = ', x % y); // increment console.log('++x = ', ++x); // x is now 6 console.log('x++ = ', x++); // x returns 6 and then increases by 1 console.log('x = ', x); // decrement console.log('--x = ', --x); // x is now 6 console.log('x-- = ', x--); // x returns 6 and then increases by 1 console.log('x = ', x); //exponentiation console.log('x ** y =', x ** y);
Besök ++ och - operatören för att lära dig mer.
Produktion
x + y = 8 x - y = 2 x * y = 15 x / y = 1,6666666666666667 x% y = 2 ++ x = 6 x ++ = 6 x = 7 --x = 6 x-- = 6 x = 5 x ** y = 125
Obs! ** Operatören ** introducerades i EcmaScript 2016 och vissa webbläsare stöder kanske inte dem. Om du vill veta mer besöker du webbläsarsupport för JavaScript-exponentiering.
Jämförelse av JavaScript-operatörer
Jämförelseoperatörer jämför två värden och returnerar ett booleskt värde, antingen trueeller false. Till exempel,
const a = 3, b = 2; console.log(a> b); // true
Här används jämförelseoperatören >för att jämföra om a är större än b.
| Operatör | Beskrivning | Exempel |
|---|---|---|
== | Lika med : returnerar trueom operanderna är lika | x == y |
!= | Inte lika med : returnerar trueom operanderna inte är lika | x != y |
=== | Strikt lika med : trueom operanderna är lika och av samma typ | x === y |
!== | Strikt inte lika med : trueom operanderna är lika men av olika typ eller inte alls lika | x !== y |
> | Större än : trueom vänsteroperand är större än högeroperand | x> y |
>= | Större än eller lika med : trueom vänster operand är större än eller lika med höger operand | x>= y |
< | Mindre än : trueom den vänstra operanden är mindre än den högra operanden | x < y |
<= | Mindre än eller lika med : trueom den vänstra operanden är mindre än eller lika med den högra operanden | x <= y |
Exempel 2: Jämförelseoperatörer i JavaScript
// equal operator console.log(2 == 2); // true console.log(2 == '2'); // true // not equal operator console.log(3 != 2); // true console.log('hello' != 'Hello'); // true // strict equal operator console.log(2 === 2); // true console.log(2 === '2'); // false // strict not equal operator console.log(2 !== '2'); // true console.log(2 !== '2'); // false
Output
true true true true true false false true
Comparison operators are used in decision making and loops. You will learn about the use of comparison operators in detail in later tutorials.
JavaScript Logical Operators
Logical operators perform logical operations and return a boolean value, either true or false. For example,
const x = 5, y = 3; (x < 6) && (y < 5); // true
Here, && is the logical operator AND. Since both x < 6 and y < 5 are true, the result is true.
| Operator | Description | Example |
|---|---|---|
&& | Logical AND: true if both the operands are true, else returns false | x && y |
|| | Logical OR: true if either of the operands is true; returns false if both are false | x || y |
! | Logical NOT: true if the operand is false and vice-versa. | !x |
Example 3: Logical Operators in JavaScript
// logical AND console.log(true && true); // true console.log(true && false); // false // logical OR console.log(true || false); // true // logical NOT console.log(!true); // false
Output
true false true false
Logical operators are used in decision making and loops. You will learn about the use of logical operators in detail in later tutorials.
JavaScript Bitwise Operators
Bitwise operators perform operations on binary representations of numbers.
| Operator | Description |
|---|---|
& | Bitwise AND |
| | Bitwise OR |
^ | Bitwise XOR |
~ | Bitwise NOT |
<< | Left shift |
>> | Sign-propagating right shift |
>>> | Zero-fill right shift |
Bitwise operators are rarely used in everyday programming. If you are interested, visit JavaScript Bitwise Operators to learn more.
JavaScript String Operators
In JavaScript, you can also use the + operator to concatenate (join) two or more strings.
Example 4: String operators in JavaScript
// concatenation operator console.log('hello' + 'world'); let a = 'JavaScript'; a += ' tutorial'; // a = a + ' tutorial'; console.log(a);
Output
helloworld JavaScript tutorial
Obs: När den +används med strängar utför den sammankoppling. Men när det +används med siffror utför det tillägg.
Andra JavaScript-operatörer
Här är en lista över andra operatörer som är tillgängliga i JavaScript. Du kommer att lära dig mer om dessa operatörer i senare handledning.
| Operatör | Beskrivning | Exempel |
|---|---|---|
, | utvärderar flera operander och returnerar värdet för den senaste operanden. | let a = (1, 3 , 4); // 4 |
?: | returnerar värde baserat på villkoret | (5> 3) ? 'success' : 'error'; // "success" |
delete | tar bort ett objekts egendom eller ett element i en matris | delete x |
typeof | returnerar en sträng som anger datatypen | typeof 3; // "number" |
void | kasserar uttryckets returvärde | void(x) |
in | returnerar trueom den angivna egenskapen finns i objektet | prop in object |
instanceof | returnerar trueom det angivna objektet är av den angivna objekttypen | object instanceof object_type |
