JavaScript Operatörler ve İşlem Önceliği

avaScript programlama dilinde operatörler aşağıdaki gibi gruplandırılabilir. JavaScriptte ikili(binary) , tekli (unary) ve bunlara ek olarak üçlü (ternary) operatörler bulunmaktadır. Operatörlerin ve ifadelerin öncelik sıralamaları da bu konu içinde değerlerlendirilir.

Operatörleri anlatmadan önce operatörlerin işlem öncelik sıralamaları için aşağıdaki tabloyu incelemenizi öneririm. Aşağıdaki tablo yüksek öncelik sırasından düşük öncelik sırasına doğru listelenmiştir.

İçindekiler

JavaScript İşlem Öncelikleri

JavaScript Operatörlerin işlem öncelik sırası aşağıdaki listede sıralandığı gibidir. Eşit önceliğe sahip operatörlerde işleme sırası, “işleme yönünde belirtilen şekildedir.

Öncelik	Operatör tipi	İşleme yönü	Operatör(ler)
1	üye elemanlara erişme	soldan sağa	`.`
	üye elemanlara erişme	soldan sağa	`[]`
	nesne oluşturma	sağdan sola	`new`
2	fonksiyon çağrısı	soldan sağa	`()`
3	bir arttırma	mümkün değil	`++`
3	bir azaltma	mümkün değil	`--`
4	mantıksal değil	sağdan sola	`!`
	bitsel değil	sağdan sola	`~`
	tek operandlı +	sağdan sola	`+`
	işaret değiştirme	sağdan sola	`-`
	typeof	sağdan sola	`typeof`
	void	sağdan sola	`void`
	delete	sağdan sola	`delete`
5	çarpma	soldan sağa	`*`
	bölme	soldan sağa	`/`
	mod alma	soldan sağa	`%`
6	toplama	soldan sağa	`+`
6	çıkarma	soldan sağa	`-`
7	bitsel kaydırma	soldan sağa	<<
			`>>`
			`>>>`
8	büyüklük-küçüklük karşılaştırması	soldan sağa	`<`
			`<=`
			`>`
			`>=`
	in	soldan sağa	`in`
	instanceof	soldan sağa	`instanceof`
9	eşitlik karşılaştırması	soldan sağa	`==`
			`!=`
			`===`
			`!==`
10	bitsel ve	soldan sağa	`&`
11	bitsel xor	soldan sağa	`^`
12	bitsel veya	soldan sağa	`\|`
13	mantıksal ve	soldan sağa	`&&`
14	mantıksal veya	soldan sağa	`\|\|`
15	koşul	sağdan sola	`?:`
16	atama	sağdan sola	`=`
			`+=`
			`-=`
			`*=`
			`/=`
			`%=`
			`<<=`
			`>>=`
			`>>>=`
			`&=`
			`^=`
			`\|=`
17	virgül	soldan sağa	`,`

JavaScript Atama Operatörleri

Bir atama operatörü, sağ tarafındaki değere bağlı olarak sol tarafındaki değişkene değer ataması yapar. Basit atama operatörü eşittir(=) sağ tarfındaki değeri sol tarafındaki değişkene atamak için kullanır.

Örneğin x=y şeklinde yapılan bir atama işleminde y değişkeni içindeki değeri x değişkenine atama yapmak için kullanılmıştır.

Aşağıdaki tabloda atama operatörlerinin bileşik ve kısaltılmış kullanımları gösterilmiştir.

Bileşik Atama Operatörleri

Adı	Kısa Kullanım	Kullanımı
Atama	`x = y`	`x = y`
Ekleme İşlemi	`x += y`	`x = x + y`
Çıkarma İşlemi	`x -= y`	`x = x - y`
İşlemi	`x *= y`	`x = x * y`
Bölme İşlemi	`x /= y`	`x = x / y`
Kalan İşlemi	`x %= y`	`x = x % y`
Üssel Atama İşlemi	`x **= y`	`x = x ** y`
Sola Kaydırma	`x <<= y`	`x = x << y`
Sağa Kaydırma	`x >>= y`	`x = x >> y`
İşaretsiz Sağa Kaydırma	`x >>>= y`	`x = x >>> y`
Bitsel AND	`x &= y`	`x = x & y`
Bitsel XOR	`x ^= y`	`x = x ^ y`
Bitsel OR	`x \|= y`	`x = x \| y`

Örnek Kullanım

Atama İşlemi


// Değişkenlerin değeri aşağıdaki gibi olduğunu varsayarak
// x = 5
// y = 10
// z = 25

x = y // x  10 olur
x = y = z // x, y ve z artık 25 değerindedir

// Değişkenlerin değeri aşağıdaki gibi olduğunu varsayarak

// x = 5

// y = 10

// z = 25

x = y // x 10 olur

x = y = z // x, y ve z artık 25 değerindedir

Arttırma Operatörü


<span class="token comment" spellcheck="true">// Değişken değerleri aşağıdaki gibi olduğunu varsayalım</span>
<span class="token comment" spellcheck="true">//  foo = "foo"</span>
<span class="token comment" spellcheck="true">//  bar = 5</span>
<span class="token comment" spellcheck="true">//  baz = true</span>


<span class="token comment" spellcheck="true">// Number + Number -&gt; toplama</span>
bar <span class="token operator">+</span><span class="token operator">=</span> <span class="token number">2</span> <span class="token comment" spellcheck="true">// 7</span>

<span class="token comment" spellcheck="true">// Boolean + Number -&gt; toplama</span>
baz <span class="token operator">+</span><span class="token operator">=</span> <span class="token number">1</span> <span class="token comment" spellcheck="true">// 2</span>

<span class="token comment" spellcheck="true">// Boolean + Boolean -&gt; toplama</span>
baz <span class="token operator">+</span><span class="token operator">=</span> <span class="token keyword">false</span> <span class="token comment" spellcheck="true">// 1</span>

<span class="token comment" spellcheck="true">// Number + String -&gt; birleştirme</span>
bar <span class="token operator">+</span><span class="token operator">=</span> <span class="token string">"foo"</span> <span class="token comment" spellcheck="true">// "5foo"</span>

<span class="token comment" spellcheck="true">// String + Boolean -&gt; birleştirme</span>
foo <span class="token operator">+</span><span class="token operator">=</span> <span class="token keyword">false</span> <span class="token comment" spellcheck="true">// "foofalse"</span>

<span class="token comment" spellcheck="true">// String + String -&gt; birleştirme</span>
foo <span class="token operator">+</span><span class="token operator">=</span> <span class="token string">"bar"</span> <span class="token comment" spellcheck="true">// "foobar"</span>

// Değişken değerleri aşağıdaki gibi olduğunu varsayalım

// foo = "foo"

// bar = 5

// baz = true

// Number + Number -> toplama

bar += 2 // 7

// Boolean + Number -> toplama

baz += 1 // 2

// Boolean + Boolean -> toplama

baz += false // 1

// Number + String -> birleştirme

bar += "foo" // "5foo"

// String + Boolean -> birleştirme

foo += false // "foofalse"

// String + String -> birleştirme

foo += "bar" // "foobar"

Çıkarma İşlemi


// Değişken aşağıdaki gibi olduğunu varsayarak
// bar = 5

bar -= 2 // 3
bar -= "foo" // NaN

// Değişken aşağıdaki gibi olduğunu varsayarak

// bar = 5

bar -= 2 // 3

bar -= "foo" // NaN

Çarpma İşlemi


// Değişken aşağıdaki gibi varsayıldığında
// bar = 5

bar *= 2 // 10
bar *= "foo" // NaN

// Değişken aşağıdaki gibi varsayıldığında

// bar = 5

bar *= 2 // 10

bar *= "foo" // NaN

Bölme İşlemi


// Değişken aşağıdaki gibi varsayıldığında
// bar = 5

bar /= 2 // 2.5
bar /= "foo" // NaN
bar /= 0 // Infinity

// Değişken aşağıdaki gibi varsayıldığında

// bar = 5

bar /= 2 // 2.5

bar /= "foo" // NaN

bar /= 0 // Infinity

Kalan İşlemi


// Değişken aşağıdaki gibi varsayıldığında
// bar = 5

bar %= 2 // 1
bar %= "foo" // NaN
bar %= 0 // NaN

// Değişken aşağıdaki gibi varsayıldığında

// bar = 5

bar %= 2 // 1

bar %= "foo" // NaN

bar %= 0 // NaN

Üssalma İşlemi


// Değişken aşağıdaki gibi varsayıldığında
// bar = 5

bar **= 2 // 25
bar **= "foo" // NaN

// Değişken aşağıdaki gibi varsayıldığında

// bar = 5

bar **= 2 // 25

bar **= "foo" // NaN

Sola Kaydırma İşlemi


var bar = 5; // (00000000000000000000000000000101)
bar <<= 2; // 20 (00000000000000000000000000010100)

var bar = 5; // (00000000000000000000000000000101)

bar <<= 2; // 20 (00000000000000000000000000010100)

Sağa Kaydırma


var bar = 5; // (00000000000000000000000000000101)
bar >>= 2; // 1 (00000000000000000000000000000001)

var bar -5; // (-00000000000000000000000000000101)
bar >>= 2; // -2 (-00000000000000000000000000000010)

var bar = 5; // (00000000000000000000000000000101)

bar >>= 2; // 1 (00000000000000000000000000000001)

var bar -5; // (-00000000000000000000000000000101)

bar >>= 2; // -2 (-00000000000000000000000000000010)

İşaretsiz Sağa Kaydırma


var bar = 5; // (00000000000000000000000000000101)
bar >>>= 2; // 1 (00000000000000000000000000000001)

var bar = -5; // (-00000000000000000000000000000101)
bar >>>= 2; // 1073741822 (00111111111111111111111111111110)

var bar = 5; // (00000000000000000000000000000101)

bar >>>= 2; // 1 (00000000000000000000000000000001)

var bar = -5; // (-00000000000000000000000000000101)

bar >>>= 2; // 1073741822 (00111111111111111111111111111110)

Bitsel AND(VE)


var bar = 5;
// 5: 00000000000000000000000000000101
// 2: 00000000000000000000000000000010
bar &= 2; // 0

var bar = 5;

// 5: 00000000000000000000000000000101

// 2: 00000000000000000000000000000010

bar &= 2; // 0

Bitsel XOR(ÖZEL VEYA)


var bar = 5;
bar ^= 2; // 7
// 5: 00000000000000000000000000000101
// 2: 00000000000000000000000000000010
// -----------------------------------
// 7: 00000000000000000000000000000111

var bar = 5;

bar ^= 2; // 7

// 5: 00000000000000000000000000000101

// 2: 00000000000000000000000000000010

// -----------------------------------

// 7: 00000000000000000000000000000111

Bitsel OR(VEYA)


var bar = 5;
bar |= 2; // 7
// 5: 00000000000000000000000000000101
// 2: 00000000000000000000000000000010
// -----------------------------------
// 7: 00000000000000000000000000000111

var bar = 5;

bar |= 2; // 7

// 5: 00000000000000000000000000000101

// 2: 00000000000000000000000000000010

// -----------------------------------

// 7: 00000000000000000000000000000111

JavaScript Aritmetik Operatörler

Aritmetik operatörler aldığı sayısal değeri operatör sembolüne göre işleyip geriye tek bir değer döndürürler. Standart aritmetik operatörler arttırma(+), eksiltme(-), çarpma(*), bölme(/) sembolleridir.

Standart aritmetik operatörlere (+, -, * /) ek olarak, JavaScript’te aşağıdaki tabloda listelenen aritmetik operatörlerde mevcuttur.

Aritmetik Operatörler

Operatör	Tanımı
Kalan(%)	İkili bölme işlemindeki tamsayılı bölmede kalan değeri getirir.
Arttırma(++)	Belirtilen değeri bir arttırmak için kullanılır.
Azaltma(–)	Belirtilen değeri bir azaltmak için kullanılır.
Toplama (+)	Belirtilen değerleri toplar. Farklı tipte değerler ise toplama için otomatik tür dönüşümü yapar.
Fark (-)	Önüne eklendiği sayısal değerin tersini alır. İki değeri bir birinden çıkarmak içinde bu operatör kullanılır.
*Çarpma ()**	Matematiksel çarpma işlemi yapar.
Bölme (/)	Matematiksel bölme işlemi yapar.
Üsalma ()**	Üsalma işlemi için tanımlanmış operatör. (Örn: 23** sonuç:8) EcmaScript 7’de stardart olacak

JavaScript Toplama Operatörü(+)

Kural:

x+y

x+y

Örnek


// Number + Number -> toplar
1 + 2 // 3

// Boolean + Number -> toplar
true + 1 // 2

// Boolean + Boolean -> toplar
false + false // 0

// Number + String -> birleştirir
5 + "foo" // "5foo"

// String + Boolean -> birleştirir
"foo" + false // "foofalse"

// String + String -> birleştirir
"foo" + "bar" // "foobar"

// Number + Number -> toplar

1 + 2 // 3

// Boolean + Number -> toplar

true + 1 // 2

// Boolean + Boolean -> toplar

false + false // 0

// Number + String -> birleştirir

5 + "foo" // "5foo"

// String + Boolean -> birleştirir

"foo" + false // "foofalse"

// String + String -> birleştirir

"foo" + "bar" // "foobar"

JavaScript Çıkarma Operatörü (-)

Kural:

x-y

x-y

Örnek:


5 - 3 // 2
3 - 5 // -2
"foo" - 3 // NaN

5 - 3 // 2

3 - 5 // -2

"foo" - 3 // NaN

JavaScript Bölme Operatörü (/)

Kural:

x/y

x/y

Örnek:


1 / 2 // 0.5

1.0 / 2.0 // 0.5

2.0 / 0 // Infinity
2.0 / 0.0 // Infinity
2.0 / -0.0 // -Infinity

1 / 2 // 0.5

1.0 / 2.0 // 0.5

2.0 / 0 // Infinity

2.0 / 0.0 // Infinity

2.0 / -0.0 // -Infinity

JavaScript Çarpma Operatörü (*)

Kural:

x*y

x*y

Örnek:


2 * 2 // 4
-2 * 2 // -4
Infinity * 0 // NaN
Infinity * Infinity // Infinity
"foo" * 2 // NaN

2 * 2 // 4

-2 * 2 // -4

Infinity * 0 // NaN

Infinity * Infinity // Infinity

"foo" * 2 // NaN

JavaScript Kalan Operatörü (%)

Kural:

x%y

x%y

Örnek:


12 % 5 // 2
-1 % 2 // -1
NaN % 2 // NaN
1 % 2 // 1
2 % 3 // 2
-4 % 2 // -0
5.5 % 2 // 1.5

12 % 5 // 2

-1 % 2 // -1

NaN % 2 // NaN

1 % 2 // 1

2 % 3 // 2

-4 % 2 // -0

5.5 % 2 // 1.5

JavaScript Artırma Operatörü (++)

Kural:


x++ yada ++x

x++ yada ++x

Örnek:


// Sonuna yazma 
var x = 3;
y = x++; // y = 3, x = 4

// Önüne yazma
var a = 2;
b = ++a; // a = 3, b = 3

// Sonuna yazma

var x = 3;

y = x++; // y = 3, x = 4

// Önüne yazma

var a = 2;

b = ++a; // a = 3, b = 3

JavaScript Azaltma Operatörü (–)

Kural:


x-- yada --x

x-- yada --x

Örnek:


// Sonuna yazma 
var x = 3;
y = x--; // y = 3, x = 2

// Önüne yazma
var a = 2;
b = --a; // a = 1, b = 1

// Sonuna yazma

var x = 3;

y = x--; // y = 3, x = 2

// Önüne yazma

var a = 2;

b = --a; // a = 1, b = 1

JavaScript Üsalma Operatörü (**)

Kural:


x**y

x**y

Örnek:


2 ** 3 // 8
3 ** 2 // 9
3 ** 2.5 // 15.588457268119896
10 ** -1 // 0.1
NaN ** 2 // NaN

2 ** 3 ** 2 // 512
2 ** (3 ** 2) // 512
(2 ** 3) ** 2 // 64

2 ** 3 // 8

3 ** 2 // 9

3 ** 2.5 // 15.588457268119896

10 ** -1 // 0.1

NaN ** 2 // NaN

2 ** 3 ** 2 // 512

2 ** (3 ** 2) // 512

(2 ** 3) ** 2 // 64

JavaScript Olumsuzlama Operatörü (-)

Kural:

-x

-x

Örnek:


var x = 3;
y = -x; // y = -3, x = 3

var x = 3;

y = -x; // y = -3, x = 3

JavaScript Tekil Artı Operatörü (+): bir değişkeni kolay yoldan sayısal değere dönüştürmek için kullanılır.

Kural:

+x

Örnek:


+3 // 3
+"3" // 3
+true // 1
+false // 0
+null // 0
+function(val){ return val } // NaN

+3 // 3

+"3" // 3

+true // 1

+false // 0

+null // 0

+function(val){ return val } // NaN

JavaScript Mantıksal Operatörler

Mantıksal operatörler genellikle boolean değerleri ile kullanılır. Bu yüzden boolean türünde değer döndürür.

Operatör	Kullanımı	Tanımı
Lojik VE ( && )	ifade1 && ifade2	İfade1 true değerine döndürülebiliyorsa ifade1, değilse ifade2 değerini döndürür.
Lojik VEYA ( \|\| )	ifade1 \|\| ifade2	ifade1 true değerine çevrilebiliyorsa ifade1, değilse ifade1 değerini döndürür.
Lojik DEĞİL ( ! )	!ifade	ifade true ise false, false ise true değerini döndürür.

JavaScriptte bir değer true olarak dönüştürülebilirse mantıksal işlemlerde true olarak kullanılır.

Aşağıdaki ifadeler mantıksal olarak dönüştürülürken false olarak dönüştürülmektedir.

null;
NaN;
0;
empty string (“”);
undefined

JavaScript Mantıksal Ve Operatörü


a1 = true && true   // t && t dönen değer true
a2 = true && false  // t && f dönen değer false
a3 = false && true  // f && t dönen değer false
a4 = false && (3 == 4) // f && f dönen değer false
a5 = "Kedi" && "Köpek"    // t && t dönen değer "Köpek"
a6 = false && "Kedi"    // f && t dönen değer false
a7 = "Kedi" && false    // t && f dönen değer false
a8 = "" && false       // dönen değer ""

a1 = true && true // t && t dönen değer true

a2 = true && false // t && f dönen değer false

a3 = false && true // f && t dönen değer false

a4 = false && (3 == 4) // f && f dönen değer false

a5 = "Kedi" && "Köpek" // t && t dönen değer "Köpek"

a6 = false && "Kedi" // f && t dönen değer false

a7 = "Kedi" && false // t && f dönen değer false

a8 = "" && false // dönen değer ""

JavaScript Mantıksal Veya Operatörü


o1 = true || true // t || t dönen değer true
o2 = false || true // f || t dönen değer true
o3 = true || false // t || f dönen değer true
o4 = false || (3 == 4) // f || f dönen değer false
o5 = "Kedi" || "Köpek" // t || t dönen değer "Kedi"
o6 = false || "Kedi" // f || t dönen değer "Kedi"
o7 = "Kedi" || false // t || f dönen değer "Kedi"
o8 = "" || false // dönen değer false
o9 = false || "" // dönen değer ""

o1 = true || true // t || t dönen değer true

o2 = false || true // f || t dönen değer true

o3 = true || false // t || f dönen değer true

o4 = false || (3 == 4) // f || f dönen değer false

o5 = "Kedi" || "Köpek" // t || t dönen değer "Kedi"

o6 = false || "Kedi" // f || t dönen değer "Kedi"

o7 = "Kedi" || false // t || f dönen değer "Kedi"

o8 = "" || false // dönen değer false

o9 = false || "" // dönen değer ""

JavaScript Mantıksal Değil Operatörü


n1 = !true // !t  dönen değeri false
n2 = !false // !f dönen değer true
n3 = !"Kedi" // !t dönen değer false

n1 = !true // !t dönen değeri false

n2 = !false // !f dönen değer true

n3 = !"Kedi" // !t dönen değer false

JavaScript Karşılaştırma Operatörleri

Karşılaştırma operatörleri, değişkenler veya değerler arasındaki eşitliği veya farkı saptamak için mantıksal işlemlerde kullanılır.

Eşitlik Operatörü(==)

JavaScript dilinin çalışma anında tür dönüşümü yapabilme özelliği vardır. Eşitlik operatörü ile eşitliğin iki tarafındaki değer türden bağımsız olarak aynı ise sonuç true değilse false olarak dönmektedir.


1 == 1 // true
"1" == 1 // true
1 == '1' // true
0 == false // true
0 == null // false

1 == 1 // true

"1" == 1 // true

1 == '1' // true

0 == false // true

0 == null // false

Örnek:


<script>
var a=3;
if(a==3){
alert("Sonuç Doğru");
}else{
alert("Sonuç Yanlış");
}
</script>

var a=3;

if(a==3){

alert("Sonuç Doğru");

}else{

alert("Sonuç Yanlış");

}

</script>

Örnek:


<script>
var a=3;
if(a=="3"){
alert("Sonuç Doğru");
}
<script>

var a=3;

if(a=="3"){

alert("Sonuç Doğru");

}

Örnek:


<script>
var a=3;
if(a==7){
alert("Sonuç Doğru");
}else{
alert("Sonuç Yanlış");
}
<script>

var a=3;

if(a==7){

alert("Sonuç Doğru");

}else{

alert("Sonuç Yanlış");

}

Eşitsizlik Operatörü(!=)

Karşılaştırması yapılan iki değer yada değişken arasında türden bağımsız olarak bir birinden farklı ise true değilse bir biri ile aynı ise false dönmektedir.


1 != 2 // true
1 != "1" // false
1 != '1' // false
1 != true // false
0 != false // false

1 != 2 // true

1 != "1" // false

1 != '1' // false

1 != true // false

0 != false // false

Örnek:


<script>
var a=3;
var b=5;
if(a!=7){
alert("a b değişkeninden farklıdır.");
}
<script>

var a=3;

var b=5;

if(a!=7){

alert("a b değişkeninden farklıdır.");

}

Tam Eşitlik Operatörü(===)

Karşılaştırması yapılan iki değer yada değişken hem tür hemde değer olarak bir biri ile aynı ise karşılaştırma sonucu true, tür yada değerlerden biri farklı ise false olarak dönmektedir.


3 === 3 // true
3 === '3' // false

3 === 3 // true

3 === '3' // false

Örnek:


<script>
var a=3;
var b="3";
if(a!=7){
alert("iki değişken tür ve değer olarak eşittir.");
}
else
{
alert("iki değişken tür ve değer olarak farklıdır.");
}
<script>

var a=3;

var b="3";

if(a!=7){

alert("iki değişken tür ve değer olarak eşittir.");

}

else

{

alert("iki değişken tür ve değer olarak farklıdır.");

}

Tam Eşitsizlik Operatörü (!==)

Karşılaştırılan veri hem tür hemde değer bakımından bir birinden farklı ise true, iki değerde hem tür hemde değer olarak eşitse false olarak dönmektedir.


3 !== '3' // true
4 !== 3 // true

3 !== '3' // true

4 !== 3 // true

Örnek:


<script>
var a=3;
var b=3;
if(a!=7){
alert("iki değişken tür ve değer olarak eşittir.");
}
else
{
alert("iki değişken tür ve değer olarak farklıdır.");
}
<script>

var a=3;

var b=3;

if(a!=7){

alert("iki değişken tür ve değer olarak eşittir.");

}

else

{

alert("iki değişken tür ve değer olarak farklıdır.");

}

Büyüktür Operatörü ( > )

Karşılaştırması yapılan iki değerden ilk değer ikinci değerden büyükse true, ikinci değer büyük yada eşitse false sonucunu üretmektedir.


4 > 3 // true

4 > 3 // true

Büyük Eşittir Operatörü ( >= )

Karşılaştırması yapılan iki değerden ilk değer ikinci değerden büyük yada eşitse true, ikinci değer büyükse false sonucunu üretmektedir.


4 >= 3 // true
3 >= 3 // true

4 >= 3 // true

3 >= 3 // true

Küçüktür Operatörü ( < )

Karşılaştırması yapılan iki değerden ilk değer ikinci değerden küçükse true, ikinci değer küçük yada eşitse false sonucunu üretmektedir.


3 < 4 // true

3 < 4 // true

Küçük Eşittir Operatörü ( <= )

Karşılaştırması yapılan iki değerden ilk değer ikinci değerden küçük yada eşitse true, ikinci değer küçükse false sonucunu üretmektedir.


3 <= 4 // true

3 <= 4 // true

Örnek Karşılaştırma Tablosu:

a=3 olduğunu varsayarak aşağıdaki karşılaştırma operatörleri ve karşılaştırma sonuçlarını gösterilmektedir.

==	Eşitlik	x == 8	false
		x == 3	true
		x == “3”	true
===	Tam eşitlik (değer ve tür eşitliği)	x === 3	true
===	Tam eşitlik (değer ve tür eşitliği)	x === “3”	false
!=	Eşitsizlik	x != 8	true
!==	Tam eşitsizlik (değer ve tür)	x !== 3	false
		x !== “3”	true
		x !== 8	true
>	Büyüktür	x > 10	false
<	Küçüktür	x < 10	true
>=	Büyük eşittir	x >= 10	false
<=	Küçük eşittir	x <= 10	true

Kaynak:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators

JavaScript Operatörler ve İşlem Önceliği

JavaScript İşlem Öncelikleri

JavaScript Atama Operatörleri

Örnek Kullanım

JavaScript Aritmetik Operatörler

JavaScript Mantıksal Operatörler

JavaScript Karşılaştırma Operatörleri

Eşitlik Operatörü(==)

Eşitsizlik Operatörü(!=)

Tam Eşitlik Operatörü(===)

Tam Eşitsizlik Operatörü (!==)

Büyüktür Operatörü ( > )

Büyük Eşittir Operatörü ( >= )

Küçüktür Operatörü ( < )

Küçük Eşittir Operatörü ( <= )

Örnek Karşılaştırma Tablosu:

1 Yorum

İptal Et

JavaScript İşlem Öncelikleri

JavaScript Atama Operatörleri

Örnek Kullanım

JavaScript Aritmetik Operatörler

JavaScript Mantıksal Operatörler

JavaScript Karşılaştırma Operatörleri

Eşitlik Operatörü(==)

Eşitsizlik Operatörü(!=)

Tam Eşitlik Operatörü(===)

Tam Eşitsizlik Operatörü (!==)

Büyüktür Operatörü ( > )

Büyük Eşittir Operatörü ( >= )

Küçüktür Operatörü ( < )

Küçük Eşittir Operatörü ( <= )

Örnek Karşılaştırma Tablosu:

Bunları da beğenebilirsiniz

1 Yorum