జావాస్క్రిప్ట్ ఆపరేటర్లు మరియు దాని రకాలు ఏమిటి?

ఆపరేటర్

వివరణ

ఉదాహరణ

+

రెండు ఆపరేషన్లను జోడిస్తుంది

జావాలో ట్రిమ్ పద్ధతిని ఎలా ఉపయోగించాలి

10 + 20 = 30

-

మొదటి ఒపెరాండ్‌ను మొదటి నుండి తీసివేస్తుంది

30 - 20 = 10

/

హారం ద్వారా లెక్కింపును విభజించండి

10/20 = 2

*

రెండు ఒపెరాండ్లను గుణించండి

5 * 5 = 25

%

పూర్ణాంక విభజన యొక్క మిగిలిన భాగాలను అవుట్పుట్ చేస్తుంది

20% 10 = 0

++

పూర్ణాంక విలువను ఒకటి పెంచుతుంది

var a = 20 a ++ ఇప్పుడు a = 21

-

పూర్ణాంక విలువను ఒకటి తగ్గిస్తుంది

var a = 20 a– ఇప్పుడు a = 19

ఆపరేటర్

వివరణ

ఉదాహరణ

==

రెండు ఒపెరాండ్‌లు సమానంగా ఉన్నాయా లేదా అని తనిఖీ చేస్తుంది. అవును అయితే, పరిస్థితి నిజం అవుతుంది.

20 == 30 = తప్పుడు

===

ఒకేలా (సమానమైన మరియు ఒకే రకమైన) కనుగొంటుంది

10 == 20 = తప్పుడు

! =

రెండు ఒపెరాండ్‌లు సమానంగా ఉన్నాయా లేదా అని తనిఖీ చేస్తుంది. విలువలు సమానంగా లేకపోతే, అప్పుడు పరిస్థితి నిజం అవుతుంది

20! = 30 = నిజం

! ==

ఇది రెండు విలువలు ఒకేలా ఉండవని సూచిస్తుంది

20! == 20 = తప్పుడు

>

SQL సర్వర్ ఉదాహరణలో సబ్‌స్ట్రింగ్

ఎడమ ఒపెరాండ్ విలువ కుడి ఒపెరాండ్ విలువ కంటే ఎక్కువగా ఉందో లేదో తనిఖీ చేస్తుంది

30> 10 = నిజం

> =

ఎడమ ఒపెరాండ్ యొక్క విలువ కుడి ఒపెరాండ్ విలువ కంటే ఎక్కువ లేదా సమానంగా ఉందో లేదో తనిఖీ చేస్తుంది

20> = 10 = నిజం

<

ఎడమ ఒపెరాండ్ విలువ కుడి ఒపెరాండ్ విలువ కంటే తక్కువగా ఉంటే ఇది తనిఖీ చేస్తుంది

ఇరవై<10 = false

<=

ఎడమ ఒపెరాండ్ యొక్క విలువ కుడి ఒపెరాండ్ విలువ కంటే తక్కువ లేదా సమానంగా ఉందో లేదో తనిఖీ చేస్తుంది

30<=10 = false

ఆపరేటర్

వివరణ

ఉదాహరణ

&

దాని పూర్ణాంక వాదనల యొక్క ప్రతి బిట్‌లో బూలియన్ మరియు ఆపరేషన్

(10 == 20 & 20 == 33) = తప్పుడు

|

ఇది దాని పూర్ణాంక వాదనల యొక్క ప్రతి బిట్‌లో బూలియన్ OR ఆపరేషన్ చేస్తుంది

(10 == 20 | 20 == 33) = తప్పుడు

^

ఈ ఆపరేటర్ బిట్‌వైస్ XOR ఆపరేషన్ చేస్తుంది

(10 == 20 ^ 20 == 33) = తప్పుడు

~

ఇది యూనిరీ ఆపరేటర్ మరియు ఒపెరాండ్‌లోని అన్ని బిట్‌లను రివర్స్ చేయడం ద్వారా పనిచేస్తుంది

(~ 10) = -10

<<

రెండవ ఒపెరాండ్‌లో పేర్కొన్న స్థలాల సంఖ్య ద్వారా దాని మొదటి ఒపెరాండ్‌లోని అన్ని బిట్‌లను ఎడమ వైపుకు కదిలిస్తుంది.

(10<<2) = 40

>>

ఎడమ ఒపెరాండ్ యొక్క విలువ కుడి ఒపెరాండ్ పేర్కొన్న బిట్ల సంఖ్య ద్వారా కుడివైపుకి కదులుతుంది.

(10 >> 2) = 2

>>>

ఈ ఆపరేటర్ >> ఆపరేటర్ మాదిరిగానే ఉంటుంది, ఎడమ వైపున మార్చబడిన బిట్స్ ఎల్లప్పుడూ సున్నాగా ఉంటాయి.

(10 >>> 2) = 2

ఆపరేటర్

వివరణ

ఉదాహరణ

&&

(10 == 20 && 20 == 33) = తప్పుడు

||

(10 == 20 || 20 == 33) = తప్పుడు

!

! (10 == 20) = నిజం

ఆపరేటర్

వివరణ

ఉదాహరణ

=

20 + 10 = 30

+ =

var a = 20 a + = 10 ఇప్పుడు a = 30

- =

var a = 30 a- = 10 ఇప్పుడు a = 20

* =

var a = 10 a * = 20 ఇప్పుడు a = 200

/ =

var a = 10 a / = 2 ఇప్పుడు a = 5

% =

var a = 10 a% = 2 ఇప్పుడు a = 0