Operaattori on symboli, joka toimii arvolla tai tiedolla. Se edustaa tiettyä toimintoa tietojen käsittelyssä. Tietoa, jolla operaattorit toimivat, kutsutaan operandiksi. Sitä voidaan käyttää yhden tai useamman arvon kanssa yhden arvon tuottamiseksi. Kaikki tavalliset JavaScript-operaattorit ovat saatavilla TypeScript-ohjelman kanssa.
Esimerkki
10 + 10 = 20;
Yllä olevassa esimerkissä arvot '10' ja '20' tunnetaan operandina, kun taas '+' ja '=' tunnetaan operaattoreina.
Operaattorit TypeScriptissä
TypeScriptissä operaattori voidaan luokitella seuraaviin tavoihin.
- Aritmeettiset operaattorit
- Vertailu (relaatio)operaattorit
- Loogiset operaattorit
- Bittikohtaiset operaattorit
- Tehtäväoperaattorit
- Kolmiosainen/ehdollinen operaattori
- Yhdistelmäoperaattori
- Tyyppi Operaattori
Aritmeettiset operaattorit
Aritmeettiset operaattorit ottavat numeerisia arvoja operandikseen, suorittavat toiminnon ja palauttavat sitten yhden numeerisen arvon. Yleisimmät aritmeettiset operaattorit ovat yhteenlasku(+), vähennyslasku(-), kertolasku(*) ja jako(/).
| Operaattori | Operaattorin_nimi | Kuvaus | Esimerkki |
|---|---|---|---|
| + | Lisäys | Se palauttaa arvojen lisäyksen. | let a = 20; let b = 30; let c = a + b; console.log( c ); // <strong>Output</strong> 30 |
| - | Vähennyslasku | Se palauttaa arvojen eron. | let a = 30; let b = 20; let c = a - b; console.log( c ); // <strong>Output</strong> 10 |
| * | Kertominen | Se palauttaa arvojen tulon. | let a = 30; let b = 20; let c = a * b; console.log( c ); // <strong>Output</strong> 600 |
| / | Division | Se suorittaa jakotoiminnon ja palauttaa osamäärän. | let a = 100; let b = 20; let c = a / b; console.log( c ); // <strong>Output</strong> 5 |
| % | Modulus | Se suorittaa jakotoiminnon ja palauttaa loput. | let a = 95; let b = 20; let c = a % b; console.log( c ); // <strong>Output</strong> 15 |
| ++ | Lisäys | Sitä käytetään lisäämään muuttujan arvoa yhdellä. | let a = 55; a++; console.log( a ); // <strong>Output</strong> 56 |
| -- | Vähennys | Sitä käytetään pienentämään muuttujan arvoa yhdellä. | let a = 55; a--; console.log( a ); // <strong>Output</strong> 54 |
Vertailu (relaatio)operaattorit
Vertailuoperaattoreita käytetään kahden operandin vertaamiseen. Nämä operaattorit palauttavat Boolen arvon tosi tai epätosi. Tärkeät vertailuoperaattorit on annettu alla.
| Operaattori | Operaattorin_nimi | Kuvaus | Esimerkki |
|---|---|---|---|
| == | On yhtä suuri kuin | Se tarkistaa, ovatko kahden operandin arvot samat vai eivät. | let a = 10; let b = 20; console.log(a==b); //false console.log(a==10); //true console.log(10=='10'); //true |
| === | Identtinen (samanlainen ja samantyyppinen) | Se tarkistaa, ovatko kahden operandin tyyppi ja arvot samat vai eivät. | let a = 10; let b = 20; console.log(a===b); //false console.log(a===10); //true console.log(10==='10'); //false |
| != | Ei yhtä suuri kuin | Se tarkistaa, ovatko kahden operandin arvot samat vai eivät. | let a = 10; let b = 20; console.log(a!=b); //true console.log(a!=10); //false console.log(10!='10'); //false |
| !== | Ei identtinen | Se tarkistaa, ovatko kahden operandin tyyppi ja arvot samat vai eivät. | let a = 10; let b = 20; console.log(a!==b); //true console.log(a!==10); /false console.log(10!=='10'); //true |
| > | Suurempi kuin | Se tarkistaa, onko vasemman operandin arvo suurempi kuin oikean operandin arvo vai ei. | let a = 30; let b = 20; console.log(a>b); //true console.log(a>30); //false console.log(20> 20'); //false |
| >= | Suurempi tai yhtä suuri kuin | Se tarkistaa, onko vasemman operandin arvo suurempi tai yhtä suuri kuin oikean operandin arvo vai ei. | let a = 20; let b = 20; console.log(a>=b); //true console.log(a>=30); //false console.log(20>='20'); //true |
| < | Vähemmän kuin | Se tarkistaa, onko vasemman operandin arvo pienempi kuin oikean operandin arvo vai ei. | let a = 10; let b = 20; console.log(a <b); true console.log(a<10); false console.log(10<'10'); false< pre></b);> |
| <=< td> | Pienempi kuin tai yhtä suuri kuin | Se tarkistaa, onko vasemman operandin arvo pienempi tai yhtä suuri kuin oikean operandin arvo vai ei. | let a = 10; let b = 20; console.log(a<=b); true console.log(a<="10);" console.log(10<="10" ); true< pre></=b);> |
Loogiset operaattorit
Loogisia operaattoreita käytetään yhdistämään kaksi tai useampia ehtoja yhdeksi lausekkeeksi ja palauttamaan Boolen tulos tosi tai epätosi. Loogiset operaattorit on annettu alla.
| Operaattori | Operaattorin_nimi | Kuvaus | Esimerkki |
|---|---|---|---|
| && | Looginen JA | Se palauttaa tosi, jos molemmat operandit (lauseke) ovat tosi, muussa tapauksessa palauttaa epätosi. | 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 |
| || | Looginen TAI | Se palauttaa tosi, jos jokin operandi(lauseke) on tosi, muussa tapauksessa palauttaa epätosi. | 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' |
| ! | Loogista EI | Se palauttaa operandin (lausekkeen) käänteisen tuloksen. | 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 |
Bittikohtaiset operaattorit
Bittikohtaiset operaattorit suorittavat bittikohtaiset operaatiot operandeille. Bittikohtaiset operaattorit ovat seuraavat.
| Operaattori | Operaattorin_nimi | Kuvaus | Esimerkki |
|---|---|---|---|
| & | Bitittain JA | Se palauttaa Boolen AND-operaation tuloksen jokaiselle kokonaislukuargumenttinsa bitille. | let a = 2; let b = 3; let c = a & b; console.log(c); // <br> <strong>Output <strong> 2 </strong></strong> |
| | | Bittikohtaisesti TAI | Se palauttaa Boolen TAI-operaation tuloksen jokaiselle kokonaislukuargumenttinsa bitille. | let a = 2; let b = 3; let c = a | b; console.log(c); // <br> <strong>Output</strong> 3 |
| ^ | Bitittainen XOR | Se palauttaa Boolen Exclusive OR -operaation tuloksen jokaiselle kokonaislukuargumenttinsa bitille. | let a = 2; let b = 3; let c = a ^ b; console.log(c); // <strong>Output </strong> 1 |
| ~ | Bitittain EI | Se kääntää jokaisen bitin operandissa. | let a = 2; let c = ~ a; console.log(c); // <strong>Output</strong> -3 |
| >> | Bitwise Right Shift | Vasemman operandin arvoa siirretään oikealle oikealle operandille määritetyllä bittimäärällä. | let a = 2; let b = 3; let c = a >> b; console.log(c); // <strong>Output </strong> 0 |
| << | Bittisuuntainen vasen vaihto | Vasemman operandin arvoa siirretään vasemmalle oikeanpuoleisessa operandissa määritetyllä bittimäärällä. Uudet bitit on täytetty nolilla oikealla puolella. | let a = 2; let b = 3; let c = a << b; console.log(c); // <strong>Output </strong> 16 |
| >>> | Bittisuuntainen oikea siirto nollalla | Vasemman operandin arvoa siirretään oikealle oikealle operandissa määritetyllä bittimäärällä ja nollia lisätään vasemmalle puolelle. | let a = 3; let b = 4; let c = a >>> b; console.log(c); // <strong>Output </strong> 0 |
Tehtäväoperaattorit
Määritysoperaattoreita käytetään arvon määrittämiseen muuttujalle. Osoitusoperaattorin vasenta puolta kutsutaan muuttujaksi ja osoitusoperaattorin oikeaa puolta arvoksi. Muuttujan ja arvon tietotyypin on oltava sama, muuten kääntäjä antaa virheen. Tehtäväoperaattorit ovat seuraavat.
| Operaattori | Operaattorin_nimi | Kuvaus | Esimerkki |
|---|---|---|---|
| = | Määritä | Se määrittää arvot oikealta vasemmalle puolelle. | let a = 10; let b = 5; console.log('a=b:' +a); // <strong>Output </strong> 10 |
| += | Lisää ja määritä | Se lisää vasemman operandin oikean operaandin kanssa ja osoittaa tuloksen vasemman puolen operandille. | let a = 10; let b = 5; let c = a += b; console.log(c); // <strong>Output </strong> 15 |
| -= | Vähennä ja määritä | Se vähentää oikean operandin vasemmasta operaandista ja osoittaa tuloksen vasemman puolen operandille. | let a = 10; let b = 5; let c = a -= b; console.log(c); // <strong>Output </strong> 5 |
| *= | Kerro ja anna | Se kertoo vasemman operandin oikealla operandilla ja osoittaa tuloksen vasemman puolen operandille. | let a = 10; let b = 5; let c = a *= b; console.log(c); // <strong>Output </strong> 50 |
| /= | Jaa ja anna | Se jakaa vasemman operandin oikeaan operandiin ja osoittaa tuloksen vasemman puolen operandille. | let a = 10; let b = 5; let c = a /= b; console.log(c); // <strong>Output </strong> 2 |
| %= | Moduuli ja tehtävä | Se jakaa vasemman operandin oikeaan operandiin ja osoittaa tuloksen vasemman puolen operandille. | let a = 16; let b = 5; let c = a %= b; console.log(c); // <strong>Output </strong> 1 |
Kolmiosainen/ehdollinen operaattori
Ehdollinen operaattori ottaa kolme operandia ja palauttaa Boolen arvon ehdon perusteella, onko se tosi vai epätosi. Sen toiminta on samanlainen kuin if-else-lause. Ehdollinen operaattori on assosiatiivisuus oikealta vasemmalle. Ehdollisen operaattorin syntaksi on annettu alla.
expression ? expression-1 : expression-2;
Esimerkki
let num = 16; let result = (num > 0) ? 'True':'False' console.log(result);
Lähtö:
True
Yhdistelmäoperaattori
Kytkentäoperaattori (+) on operaattori, jota käytetään kahden merkkijonon liittämiseen. Ketjutusoperaatiossa emme voi lisätä välilyöntiä merkkijonojen väliin. Voimme ketjuttaa useita merkkijonoja yhdessä lauseessa. Seuraava esimerkki auttaa meitä ymmärtämään TypeScriptin ketjutusoperaattorin.
Esimerkki
let message = 'Welcome to ' + 'JavaTpoint'; console.log('Result of String Operator: ' +message);
Lähtö:
Result of String Operator: Welcome to JavaTpoint
Tyyppi Operaattorit
Saatavilla on kokoelma operaattoreita, jotka voivat auttaa sinua työskentelemään TypeScriptin objektien kanssa. Operaattorit, kuten typeof, instanceof, in ja delete, ovat esimerkkejä Type-operaattorista. Näiden operaattoreiden yksityiskohtainen selitys on annettu alla.
| Operaattorin_nimi | Kuvaus | Esimerkki |
|---|---|---|
| sisään | Sitä käytetään kohteen ominaisuuden olemassaolon tarkistamiseen. | let Bike = {make: 'Honda', model: 'CLIQ', year: 2018}; console.log('make' in Bike); // <strong>Output:</strong> true |
| poistaa | Sitä käytetään ominaisuuksien poistamiseen objekteista. | let Bike = { Company1: 'Honda', Company2: 'Hero', Company3: 'Royal Enfield' }; delete Bike.Company1; console.log(Bike); // <strong>Output:</strong> { Company2: 'Hero', Company3: 'Royal Enfield' } |
| tyyppi | Se palauttaa operandin tietotyypin. | let message = 'Welcome to ' + 'JavaTpoint'; console.log(typeof message); // <strong>Output:</strong> String |
| esiintymä | Sitä käytetään tarkistamaan, onko objekti tiettyä tyyppiä vai ei. | let arr = [1, 2, 3]; console.log( arr instanceof Array ); // true console.log( arr instanceof String ); // false |