Az operátor egy szimbólum, amely egy értékre vagy adatra vonatkozik. Ez egy konkrét műveletet jelent az adatokkal való munka során. Azokat az adatokat, amelyeken az operátorok dolgoznak, operandusnak nevezzük. Egy vagy több értékkel használható egyetlen érték előállításához. Az összes szabványos JavaScript operátor elérhető a TypeScript programmal.
Példa
10 + 10 = 20;
A fenti példában a „10” és „20” értékek operandusnak, míg a „+” és „=” operátoroknak ismertek.
Operátorok a TypeScriptben
A TypeScriptben az operátorok a következő módokon osztályozhatók.
- Aritmetikai operátorok
- Összehasonlító (relációs) operátorok
- Logikai operátorok
- Bitenkénti operátorok
- Hozzárendelési operátorok
- Ternáris/feltételes operátor
- Összefűzési operátor
- Üzemeltető típus
Aritmetikai operátorok
Az aritmetikai operátorok numerikus értékeket vesznek fel operandusként, végrehajtanak egy műveletet, majd egyetlen numerikus értéket adnak vissza. A leggyakoribb aritmetikai operátorok az összeadás(+), a kivonás(-), a szorzás(*) és az osztás(/).
java listadoboz
| Operátor | Operator_Name | Leírás | Példa |
|---|---|---|---|
| + | Kiegészítés | Az értékek hozzáadását adja vissza. | let a = 20; let b = 30; let c = a + b; console.log( c ); // <strong>Output</strong> 30 |
| - | Kivonás | Az értékek különbségét adja vissza. | let a = 30; let b = 20; let c = a - b; console.log( c ); // <strong>Output</strong> 10 |
| * | Szorzás | Az értékek szorzatát adja vissza. | let a = 30; let b = 20; let c = a * b; console.log( c ); // <strong>Output</strong> 600 |
| / | Osztály | Elvégzi az osztási műveletet, és visszaadja a hányadost. | let a = 100; let b = 20; let c = a / b; console.log( c ); // <strong>Output</strong> 5 |
| % | Modulus | Elvégzi az osztási műveletet, és visszaadja a maradékot. | let a = 95; let b = 20; let c = a % b; console.log( c ); // <strong>Output</strong> 15 |
| ++ | Növekedés | A változó értékének eggyel növelésére szolgál. | let a = 55; a++; console.log( a ); // <strong>Output</strong> 56 |
| -- | Csökkenés | A változó értékének eggyel való csökkentésére szolgál. | let a = 55; a--; console.log( a ); // <strong>Output</strong> 54 |
Összehasonlító (relációs) operátorok
Az összehasonlító operátorok a két operandus összehasonlítására szolgálnak. Ezek az operátorok igaz vagy hamis logikai értéket adnak vissza. A fontos összehasonlító operátorok az alábbiakban találhatók.
| Operátor | Operator_Name | Leírás | Példa |
|---|---|---|---|
| == | Egyenlő | Ellenőrzi, hogy a két operandus értéke egyenlő-e vagy sem. | let a = 10; let b = 20; console.log(a==b); //false console.log(a==10); //true console.log(10=='10'); //true |
| === | Azonos (egyenlő és azonos típusú) | Ellenőrzi, hogy a két operandus típusa és értéke egyenlő-e vagy sem. | let a = 10; let b = 20; console.log(a===b); //false console.log(a===10); //true console.log(10==='10'); //false |
| != | Nem egyenlő | Ellenőrzi, hogy a két operandus értéke egyenlő-e vagy sem. | let a = 10; let b = 20; console.log(a!=b); //true console.log(a!=10); //false console.log(10!='10'); //false |
| !== | Nem azonos | Ellenőrzi, hogy a két operandus típusa és értéke egyenlő-e vagy sem. | let a = 10; let b = 20; console.log(a!==b); //true console.log(a!==10); /false console.log(10!=='10'); //true |
| > | Nagyobb, mint | Ellenőrzi, hogy a bal oldali operandusok értéke nagyobb-e, mint a jobb oldali operandusé, vagy sem. | let a = 30; let b = 20; console.log(a>b); //true console.log(a>30); //false console.log(20> 20'); //false |
| >= | Nagyobb vagy egyenlő | Ellenőrzi, hogy a bal oldali operandusok értéke nagyobb-e vagy egyenlő-e a jobb oldali operandus értékével vagy sem. | let a = 20; let b = 20; console.log(a>=b); //true console.log(a>=30); //false console.log(20>='20'); //true |
| < | Kevesebb, mint | Ellenőrzi, hogy a bal oldali operandusok értéke kisebb-e, mint a jobb oldali operandusé, vagy sem. | let a = 10; let b = 20; console.log(a <b); true console.log(a<10); false console.log(10<'10'); false< pre></b);> |
| <=< td> | Kisebb vagy egyenlő | Ellenőrzi, hogy a bal oldali operandusok értéke kisebb-e vagy egyenlő-e a jobb oldali operandus értékével vagy sem. | let a = 10; let b = 20; console.log(a<=b); true console.log(a<="10);" console.log(10<="10" ); true< pre></=b);> |
Logikai operátorok
A logikai operátorok két vagy több feltétel egyetlen kifejezésben való kombinálására szolgálnak, és a logikai eredményt igaz vagy hamis értékre adják vissza. A logikai operátorok az alábbiakban találhatók.
| Operátor | Operator_Name | Leírás | Példa |
|---|---|---|---|
| && | Logikus ÉS | Igazat ad vissza, ha mindkét operandus (kifejezés) igaz, ellenkező esetben hamis értéket ad vissza. | let a = false; let b = true; console.log(a&&b); /false console.log(b&&true); //true console.log(b&&10); //10 which is also 'true' console.log(a&&'10'); //false |
| || | Logikus VAGY | Igazat ad vissza, ha valamelyik operandus (kifejezés) igaz, ellenkező esetben hamis értéket ad vissza. | let a = false; let b = true; console.log(a||b); //true console.log(b||true); //true console.log(b||10); //true console.log(a||'10'); //'10' which is also 'true' |
| ! | Logikus NEM | Egy operandus (kifejezés) inverz eredményét adja vissza. | let a = 20; let b = 30; console.log(!true); //false console.log(!false); //true console.log(!a); //false console.log(!b); /false console.log(!null); //true |
Bitenkénti operátorok
A bitenkénti operátorok az operandusokon hajtják végre a bitenkénti műveleteket. A bitenkénti operátorok a következők.
linux feladatkezelő
| Operátor | Operator_Name | Leírás | Példa |
|---|---|---|---|
| & | Bitenként ÉS | Egy logikai ÉS művelet eredményét adja vissza az egész argumentum minden bitjén. | let a = 2; let b = 3; let c = a & b; console.log(c); // <br> <strong>Output <strong> 2 </strong></strong> |
| | | Bitenkénti VAGY | Egy logikai VAGY művelet eredményét adja vissza az egész argumentum minden bitjén. | let a = 2; let b = 3; let c = a | b; console.log(c); // <br> <strong>Output</strong> 3 |
| ^ | Bitenkénti XOR | Egy logikai, kizárólagos VAGY művelet eredményét adja vissza az egész argumentum minden bitjén. | let a = 2; let b = 3; let c = a ^ b; console.log(c); // <strong>Output </strong> 1 |
| ~ | Bitenként NEM | Minden bitet invertál az operandusokban. | let a = 2; let c = ~ a; console.log(c); // <strong>Output</strong> -3 |
| >> | Bitenkénti jobb eltolás | A bal oldali operandus értéke a jobb oldali operandusban megadott bitek számával jobbra kerül. | let a = 2; let b = 3; let c = a >> b; console.log(c); // <strong>Output </strong> 0 |
| << | Bitenkénti bal eltolás | A bal oldali operandus értéke balra kerül a jobb oldali operandusban megadott számú bittel. Az új bitek nullákkal vannak feltöltve a jobb oldalon. | let a = 2; let b = 3; let c = a << b; console.log(c); // <strong>Output </strong> 16 |
| >>> | Bitenkénti jobb eltolás nullával | A bal oldali operandus értéke a jobb oldali operandusban megadott bitek számával jobbra kerül, a bal oldalon pedig nullákat adunk hozzá. | let a = 3; let b = 4; let c = a >>> b; console.log(c); // <strong>Output </strong> 0 |
Hozzárendelés operátorok
A hozzárendelési operátorok értéket rendelnek a változóhoz. A hozzárendelési operátor bal oldalát változónak, a hozzárendelési operátor jobb oldalát értéknek nevezzük. A változó adattípusának és értékének meg kell egyeznie, különben a fordító hibát fog kiütni. A hozzárendelési operátorok a következők.
| Operátor | Operator_Name | Leírás | Példa |
|---|---|---|---|
| = | Hozzárendelni | Értékeket rendel a jobb oldalról a bal oldali operandusra. | let a = 10; let b = 5; console.log('a=b:' +a); // <strong>Output </strong> 10 |
| += | Hozzáadás és hozzárendelés | Hozzáadja a bal oldali operandust a jobb oldali operandushoz, és az eredményt a bal oldali operandushoz rendeli. | let a = 10; let b = 5; let c = a += b; console.log(c); // <strong>Output </strong> 15 |
| -= | Kivonás és hozzárendelés | Kivonja a jobb oldali operandust a bal oldali operandusból, és az eredményt a bal oldali operandushoz rendeli. | let a = 10; let b = 5; let c = a -= b; console.log(c); // <strong>Output </strong> 5 |
| *= | Szorozza meg és rendelje hozzá | A bal oldali operandust megszorozza a jobb oldali operandusszal, és az eredményt a bal oldali operandushoz rendeli. | let a = 10; let b = 5; let c = a *= b; console.log(c); // <strong>Output </strong> 50 |
| /= | Oszd fel és rendelj hozzá | A bal oldali operandust felosztja a jobb oldali operandusszal, és az eredményt a bal oldali operandushoz rendeli. | let a = 10; let b = 5; let c = a /= b; console.log(c); // <strong>Output </strong> 2 |
| %= | Modulus és hozzárendelés | A bal oldali operandust felosztja a jobb oldali operandusszal, és az eredményt a bal oldali operandushoz rendeli. | let a = 16; let b = 5; let c = a %= b; console.log(c); // <strong>Output </strong> 1 |
Ternáris/feltételes operátor
A feltételes operátor három operandust vesz fel, és egy logikai értéket ad vissza a feltétel alapján, akár igaz, akár hamis. Működése hasonló az if-else utasításhoz. A feltételes operátor jobbról balra asszociativitással rendelkezik. A feltételes operátor szintaxisa alább látható.
expression ? expression-1 : expression-2;
Példa
let num = 16; let result = (num > 0) ? 'True':'False' console.log(result);
Kimenet:
True
Összefűzési operátor
Az összefűzési (+) operátor egy operátor, amely a két karakterlánc hozzáfűzésére szolgál. Összefűzési műveletben nem adhatunk szóközt a karakterláncok közé. Egy utasításban több karakterláncot is összefűzhetünk. A következő példa segít megérteni a TypeScript összefűzési operátorát.
javascript karakterlánc csere
Példa
let message = 'Welcome to ' + 'JavaTpoint'; console.log('Result of String Operator: ' +message);
Kimenet:
Result of String Operator: Welcome to JavaTpoint
Típus Operátorok
Operátorok gyűjteménye áll rendelkezésre, amelyek segíthetnek a TypeScript objektumokkal való munka során. Az olyan operátorok, mint a typeof, instanceof, in és delete a Type operátor példái. Ezen operátorok részletes magyarázata az alábbiakban található.
| Operator_Name | Leírás | Példa |
|---|---|---|
| ban ben | Arra használják, hogy ellenőrizzék, hogy egy objektumon van-e tulajdonság. | let Bike = {make: 'Honda', model: 'CLIQ', year: 2018}; console.log('make' in Bike); // <strong>Output:</strong> true |
| töröl | Az objektumok tulajdonságainak törlésére szolgál. | let Bike = { Company1: 'Honda', Company2: 'Hero', Company3: 'Royal Enfield' }; delete Bike.Company1; console.log(Bike); // <strong>Output:</strong> { Company2: 'Hero', Company3: 'Royal Enfield' } |
| típusú | Az operandus adattípusát adja vissza. | let message = 'Welcome to ' + 'JavaTpoint'; console.log(typeof message); // <strong>Output:</strong> String |
| Például az | Annak ellenőrzésére szolgál, hogy az objektum meghatározott típusú-e vagy sem. | let arr = [1, 2, 3]; console.log( arr instanceof Array ); // true console.log( arr instanceof String ); // false |