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.
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 | . |
[] |
|||
| nesne oluşturma | sağdan sola | new |
|
| 2 | fonksiyon çağrısı | soldan sağa | () |
| 3 | bir arttırma | mümkün değil | ++ |
| 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 | + |
| çı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
|
1 2 3 4 5 6 7 |
// 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ü
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
<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 -> 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 -> 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 -> 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 -> 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 -> 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 -> 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> |
Çıkarma İşlemi
|
1 2 3 4 5 |
// Değişken aşağıdaki gibi olduğunu varsayarak // bar = 5 bar -= 2 // 3 bar -= "foo" // NaN |
Çarpma İşlemi
|
1 2 3 4 5 |
// Değişken aşağıdaki gibi varsayıldığında // bar = 5 bar *= 2 // 10 bar *= "foo" // NaN |
Bölme İşlemi
|
1 2 3 4 5 6 |
// Değişken aşağıdaki gibi varsayıldığında // bar = 5 bar /= 2 // 2.5 bar /= "foo" // NaN bar /= 0 // Infinity |
Kalan İşlemi
|
1 2 3 4 5 6 |
// Değişken aşağıdaki gibi varsayıldığında // bar = 5 bar %= 2 // 1 bar %= "foo" // NaN bar %= 0 // NaN |
Üssalma İşlemi
|
1 2 3 4 5 |
// Değişken aşağıdaki gibi varsayıldığında // bar = 5 bar **= 2 // 25 bar **= "foo" // NaN |
Sola Kaydırma İşlemi
|
1 2 |
var bar = 5; // (00000000000000000000000000000101) bar <<= 2; // 20 (00000000000000000000000000010100) |
Sağa Kaydırma
|
1 2 3 4 5 |
var bar = 5; // (00000000000000000000000000000101) bar >>= 2; // 1 (00000000000000000000000000000001) var bar -5; // (-00000000000000000000000000000101) bar >>= 2; // -2 (-00000000000000000000000000000010) |
İşaretsiz Sağa Kaydırma
|
1 2 3 4 5 |
var bar = 5; // (00000000000000000000000000000101) bar >>>= 2; // 1 (00000000000000000000000000000001) var bar = -5; // (-00000000000000000000000000000101) bar >>>= 2; // 1073741822 (00111111111111111111111111111110) |
Bitsel AND(VE)
|
1 2 3 4 |
var bar = 5; // 5: 00000000000000000000000000000101 // 2: 00000000000000000000000000000010 bar &= 2; // 0 |
Bitsel XOR(ÖZEL VEYA)
|
1 2 3 4 5 6 |
var bar = 5; bar ^= 2; // 7 // 5: 00000000000000000000000000000101 // 2: 00000000000000000000000000000010 // ----------------------------------- // 7: 00000000000000000000000000000111 |
Bitsel OR(VEYA)
|
1 2 3 4 5 6 |
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: 2**3 sonuç:8) EcmaScript 7’de stardart olacak |
JavaScript Toplama Operatörü(+)
Kural:
|
1 |
x+y |
Örnek
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
// 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:
|
1 |
x-y |
Örnek:
|
1 2 3 |
5 - 3 // 2 3 - 5 // -2 "foo" - 3 // NaN |
JavaScript Bölme Operatörü (/)
Kural:
|
1 |
x/y |
Örnek:
|
1 2 3 4 5 6 7 |
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:
|
1 |
x*y |
Örnek:
|
1 2 3 4 5 |
2 * 2 // 4 -2 * 2 // -4 Infinity * 0 // NaN Infinity * Infinity // Infinity "foo" * 2 // NaN |
JavaScript Kalan Operatörü (%)
Kural:
|
1 |
x%y |
Örnek:
|
1 2 3 4 5 6 7 |
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:
|
1 |
x++ yada ++x |
Örnek:
|
1 2 3 4 5 6 7 |
// 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:
|
1 |
x-- yada --x |
Örnek:
|
1 2 3 4 5 6 7 |
// 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:
|
1 |
x**y |
Örnek:
|
1 2 3 4 5 6 7 8 9 |
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:
|
1 |
-x |
Örnek:
|
1 2 |
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:
|
1 |
+x |
Örnek:
|
1 2 3 4 5 6 |
+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ü
|
1 2 3 4 5 6 7 8 |
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ü
|
1 2 3 4 5 6 7 8 9 |
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ü
|
1 2 3 |
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 2 3 4 5 |
1 == 1 // true "1" == 1 // true 1 == '1' // true 0 == false // true 0 == null // false |
Örnek:
|
1 2 3 4 5 6 7 8 |
<script> var a=3; if(a==3){ alert("Sonuç Doğru"); }else{ alert("Sonuç Yanlış"); } </script> |
Örnek:
|
1 2 3 4 5 6 |
<script> var a=3; if(a=="3"){ alert("Sonuç Doğru"); } <script> |
Örnek:
|
1 2 3 4 5 6 7 8 |
<script> var a=3; if(a==7){ alert("Sonuç Doğru"); }else{ alert("Sonuç Yanlış"); } <script> |
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 3 4 5 |
1 != 2 // true 1 != "1" // false 1 != '1' // false 1 != true // false 0 != false // false |
Örnek:
|
1 2 3 4 5 6 7 |
<script> var a=3; var b=5; if(a!=7){ alert("a b değişkeninden farklıdır."); } <script> |
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.
|
1 2 |
3 === 3 // true 3 === '3' // false |
Örnek:
|
1 2 3 4 5 6 7 8 9 10 11 |
<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> |
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.
|
1 2 |
3 !== '3' // true 4 !== 3 // true |
Örnek:
|
1 2 3 4 5 6 7 8 9 10 11 |
<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> |
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.
|
1 |
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.
|
1 2 |
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.
|
1 |
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.
|
1 |
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 |
| 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
Add comment