Ebben az oktatóanyagban megismerheti a JavaScript-ben elérhető különböző operátorokat és azok használatát példák segítségével.
Mi az üzemeltető?
A JavaScript-ben az operátor egy speciális szimbólum, amelyet operandusokkal (értékek és változók) végeznek. Például,
2 + 3; // 5
Itt +egy olyan üzemben, amely végrehajtja túlmenően, 2és 3vannak operandusok.
JavaScript operátor típusok
Itt van egy lista a különböző operátorokról, amelyeket megtanul ebben az oktatóanyagban.
- Feladatkezelők
- Számtani operátorok
- Összehasonlító operátorok
- Logikai operátorok
- Bitenkénti operátorok
- Vonós operátorok
- Egyéb üzemeltetők
JavaScript hozzárendelési operátorok
A hozzárendelési operátorokat értékek hozzárendeléséhez használják a változókhoz. Például,
const x = 5;
Itt az =operátort használjuk 5a változó értékének hozzárendeléséhez x.
Az alábbiakban felsoroljuk a gyakran használt hozzárendelési operátorokat:
| Operátor | Név | Példa |
|---|---|---|
= | Hozzárendelés operátor | a = 7; // 7 |
+= | Összeadás hozzárendelés | a += 5; // a = a + 5 |
-= | Kivonás hozzárendelése | a -= 2; // a = a - 2 |
*= | Szorzási hozzárendelés | a *= 3; // a = a * 3 |
/= | Osztály kijelölése | a /= 2; // a = a / 2 |
%= | A fennmaradó feladat | a %= 2; // a = a % 2 |
**= | Hatványozási feladat | a **= 2; // a = a**2 |
Megjegyzés: Az általánosan használt hozzárendelési operátor a =. Meg fogják érteni, más értékadó operátort, például +=, -=, *=stb egyszer megtudjuk aritmetikai operátorok.
JavaScript számtani operátorok
A számtani operátorokat a számtani számítások elvégzésére használják . Például,
const number = 3 + 5; // 8
Itt az +operátort két operandus hozzáadására használják.
| Operátor | Név | Példa |
|---|---|---|
+ | Kiegészítés | x + y |
- | Kivonás | x - y |
* | Szorzás | x * y |
/ | Osztály | x / y |
% | Maradék | x % y |
++ | Növekmény (1-es lépések) | ++x vagy x++ |
-- | Csökkentés (1-es csökkentések) | --x vagy x-- |
** | Hatványozás (teljesítmény) | x ** y |
1. példa: Számtani operátorok a JavaScript-ben
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);
További információkért keresse fel a ++ és - operátort.
Kimenet
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
Megjegyzés : A ** operátort az EcmaScript 2016-ban vezették be, és egyes böngészők nem biztos, hogy támogatják őket. További információért keresse fel a JavaScript hatványozási böngésző ügyfélszolgálatát.
JavaScript összehasonlító operátorok
Az összehasonlító operátorok két értéket hasonlítanak össze, és logikai értéket adnak vissza, truevagy false. Például,
const a = 3, b = 2; console.log(a> b); // true
Itt az összehasonlító operátort >használják annak összehasonlítására, hogy az a nagyobb-e mint b.
| Operátor | Leírás | Példa |
|---|---|---|
== | Egyenlő : visszatér, trueha az operandusok egyenlőek | x == y |
!= | Nem egyenlő : visszatér, trueha az operandusok nem egyenlőek | x != y |
=== | Szigorúan egyenlő : trueha az operandusok egyenlőek és azonos típusúak | x === y |
!== | Szigorú, nem egyenlő : trueha az operandusok egyenlőek, de különböző típusúak, vagy egyáltalán nem egyenlőek | x !== y |
> | Nagyobb, mint : trueha a bal operandus nagyobb, mint a jobb operandus | x> y |
>= | Nagyobb vagy egyenlő : trueha a bal operandus nagyobb vagy egyenlő a jobb operandussal | x>= y |
< | Kevesebb mint : trueha a bal operandus kisebb, mint a jobb operandus | x < y |
<= | Kevesebb vagy egyenlő : trueha a bal operandus kisebb vagy egyenlő a jobb operandussal | x <= y |
2. példa: Összehasonlító operátorok a JavaScript-ben
// 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
Megjegyzés: Ha +karakterláncokkal használják, összefűzést végez. Ha azonban +számokkal használják, akkor összeadást hajt végre.
Egyéb JavaScript operátorok
Itt található a JavaScript-ben elérhető egyéb operátorok listája. Ezeket az operátorokat későbbi oktatóanyagokban ismerheti meg.
| Operátor | Leírás | Példa |
|---|---|---|
, | kiértékeli több operandus és visszaadja az utolsó operandus értékét. | let a = (1, 3 , 4); // 4 |
?: | értéket ad vissza a feltétel alapján | (5> 3) ? 'success' : 'error'; // "success" |
delete | töröl egy objektum tulajdonságát vagy egy tömb elemét | delete x |
typeof | karakterláncot ad vissza, amely az adattípust jelzi | typeof 3; // "number" |
void | elveti a kifejezés visszatérési értékét | void(x) |
in | visszatér, trueha a megadott tulajdonság az objektumban van | prop in object |
instanceof | visszatér, trueha a megadott objektum a megadott objektumtípusú | object instanceof object_type |
