# Operatörler (Operators)

Açıklama	Operatör
Son Ek	ifade++ ifade-- () [] ?[] . ?. !
Ön Ek	-ifade !ifade ~ifade ++ifade --ifade await ifade
Çarpımsal	* / % ~/
Toplama Çıkarma İşlemi	+ -
Kaydırma İşlemi	<< >> >>>
Bit Düzeyinde AND	&
Bit Düzeyinde XOR	^
Bit Düzeyinde OR	\|
İlişkisel ve Tip Test İşlemleri	>= > <= < as is is!
Eşitlik	== !=
Mantıksal AND	&&
Mantıksal OR	\|\|
if null	??
Koşul	ifade1 ? ifade2 : ifade3
Cascade	.. ?..
Atama	= *= /= += -= &= ^= vs.

> **Uyarı** > > Yukarıdaki tablo, sadece yardımcı bir rehber olarak kullanılmalıdır. Operatör önceliği ve birlikteliği, dilin gramerinde bulunan gerçekliğin bir yaklaşımıdır. Dart'ın operatör ilişkilerinin yetkili davranışını dil spesifikasyonundaki gramerde bulabilirsiniz. Operatörleri kullandığınızda, ifadeler oluşturursunuz. İşte operatör ifadelerine örnekler: ```dart a++ a + b a = b a == b c ? a : b a is T ``` ### Operatör Önceliği Örneği ```dart // Operatör tablosunda her operatör, onu takip eden satırlardaki operatörlerden daha yüksek önceliğe sahiptir. // Parantezler okunabilirliği artırır. if ((n % i == 0) && (d % i == 0)) ... // Okunması zor, ancak eşdeğer. if (n % i == 0 && d % i == 0) ... ``` ### Aritmetik Operatörler

Operatör	Anlamı
+	Ekleme
-	Çıkarma
*	Çarpma
/	Bölme
~/	Bölme, Tam Sayı Sonucu Döndürür
%	Mod Alma

Örnek: ```dart assert(2 + 3 == 5); assert(2 - 3 == -1); assert(2 * 3 == 6); assert(5 / 2 == 2.5); // Sonuç bir double assert(5 ~/ 2 == 2); // Sonuç bir int assert(5 % 2 == 1); // Kalan assert('5/2 = ${5 ~/ 2} r ${5 % 2}' == '5/2 = 2 r 1'); ``` Ayrıca, artırma ve azaltma operatörlerini de destekler:

Operatör	Anlamı
++var	var = var + 1 (ifade değeri var + 1)
var++	var = var + 1 (ifade değeri var)
--var	var = var - 1 (ifade değeri var - 1)
var--	var = var - 1 (ifade değeri var)

Örnek: ```dart int a; int b; a = 0; b = ++a; // a artırılır, sonra b değeri atanır. assert(a == b); // 1 == 1 a = 0; b = a++; // b değeri atanır, sonra a artırılır. assert(a != b); // 1 != 0 a = 0; b = --a; // a azaltılır, sonra b değeri atanır. assert(a == b); // -1 == -1 a = 0; b = a--; // b değeri atanır, sonra a azaltılır. assert(a != b); // -1 != 0 ``` ### Eşitlik ve İlişkisel Operatörler

Operatör	Anlamı
==	Eşittir
!=	Eşit değil
>	Büyüktür
<	Küçüktür
>=	Büyüktür veya eşittir
<=	Küçüktür veya eşittir

İki nesnenin x ve y, aynı şeyi temsil edip etmediğini test etmek için == operatörünü kullanın. (İki nesnenin tam olarak aynı nesne olup olmadığını bilmek istemeniz durumunda, sadece `identical()` fonksiyonunu kullanın.) İşte == operatörünün nasıl çalıştığı: 1. x veya y null ise, her ikisi de null ise true döndürür, sadece biri null ise false döndürür. 2. x üzerinde y ile çağrılan == yönteminin sonucunu döndürür. İşte eşitlik ve ilişkisel operatörleri kullanma örnekleri: ```dart assert(2 == 2); assert(2 != 3); assert(3 > 2); assert(2 < 3); assert(3 >= 3); assert(2 <= 3); ``` ### Tip Test Operatörleri as, is ve is! operatörleri, tipleri çalışma zamanında kontrol etmek için kullanışlıdır.

Opeartör	Anlamı
as	Tip dönüşümü (ayrıca kütüphane öneklerini belirtmek için de kullanılır)
is	Nesnenin belirtilen tipe sahip olup olmadığı doğru ise
is!	Nesnenin belirtilen tipe sahip olmadığı doğru ise

Eğer nesnenin tipinin `T` tipi olduğundan eminseniz, objeyi bu tipe dönüştürmek için as operatörünü kullanın. Örnek: ```dart (calisan as Kisi).firstName = 'Bayram'; ``` Eğer nesnenin tipinin T tipi olup olmadığını bilmiyorsanız, objeyi kullanmadan önce tipi kontrol etmek için is T'yi kullanın. ```dart if (calisan is Kisi) { // Tip kontrolü calisan.firstName = 'Bayram'; } ``` > **Not** > > Kod eşdeğer değildir. Eğer `calisan` null ise veya `Kisi` değilse, ilk örnek bir istisna fırlatır; ikinci örnek ise hiçbir şey yapmaz. ### Atama Operatörleri Zaten gördüğünüz gibi, = operatörü ile değer atayabilirsiniz. Atanacak değişken null ise, ??= operatörünü kullanarak sadece atama yapabilirsiniz. ```dart // Bir değer atayın a = value; // b null ise b'ye değer atayın; aksi takdirde b aynı kalır b ??= value; ``` Zaten gördüğünüz gibi, = operatörü ile değer atayabilirsiniz. Atanacak değişken null ise, ??= operatörünü kullanarak sadece atama yapabilirsiniz.


=	*=	%=	>>>=	^=
+=	/=	<<=	&=	\|=
-=	~/=	>>=

İşte bileşik atama operatörlerinin nasıl çalıştığı:


Bir operatör op için:	a op= b	a = a op b
Örneğin:	a += b	a = a + b

Aşağıdaki örnek, atama ve bileşik atama operatörlerini kullanır: ```dart var a = 2; // = kullanarak değer atama a *= 3; // Atama ve çarpma: a = a * 3 assert(a == 6); ``` ### Mantıksal Operatörler Mantıksal operatörleri kullanarak boolean ifadelerini tersine çevirebilir veya birleştirebilirsiniz.

Opeartör	Anlamı
!ifade	Takip eden ifadeyi tersine çevirir (false'u true'ya veya tam tersi)
\|\|	Mantıksal OR (VEYA)
&&	Mantıksal AND (VE)

İşte mantıksal operatörleri kullanmanın bir örneği: ```dart if (!tamamlandi && (col == 0 || col == 3)) { // ...Bir şey yap... } ``` ### Bitwise (Bit Düzeyi) ve Kaydırma Operatörleri Dart'ta sayıların bitlerini manipüle edebilirsiniz. Genellikle bu bitwise ve kaydırma operatörlerini tamsayılarla kullanırsınız.

Operatör	Anlamı
&	AND
\|	OR
^	XOR
~ifade	Bit düzeyinde (0'ları 1 yapar; 1'leri 0 yapar)
<<	Sola kaydırma
>>	Sağa kaydırma
>>>	İşaretsiz sağa kaydırma

> **Not** > > Büyük veya negatif operandlara sahip bitwise operasyonların davranışı platformlar arasında farklılık gösterebilir. İşte bitwise ve kaydırma operatörlerini kullanmanın bir örneği: ```dart final deger = 0x22; final maske = 0x0f; assert((deger & maske) == 0x02); // VE (AND) assert((deger & ~maske) == 0x20); // VE DEĞİL (AND NOT) assert((deger | maske) == 0x2f); // VEYA (OR) assert((deger ^ maske) == 0x2d); // XOR assert((deger << 4) == 0x220); // Sola kaydırma assert((deger >> 4) == 0x02); // Sağa kaydırma // Web üzerinde farklı davranan bir örnekte sağa kaydırma // çünkü operand değeri 32 bit olarak maskeleyince değişir: assert((-deger >> 4) == -0x03); assert((deger >>> 4) == 0x02); // İşaretsiz sağa kaydırma assert((-deger >>> 4) > 0); // İşaretsiz sağa kaydırma ``` ### Koşullu İfadeler Dart dilinde, aksi takdirde if-else ifadeleri gerektirebilecek ifadeleri kısa bir şekilde değerlendirmenizi sağlayan iki operatör bulunmaktadır: * `kosul ? ifade1 : ifade2` Eğer condition doğruysa, ifade1'i değerlendirir (ve değerini döndürür); aksi takdirde, ifade2'yi değerlendirir ve değerini döndürür. * `ifade1 ?? ifade2` Eğer ifade1 değeri null değilse, değerini döndürür; aksi takdirde, ifade2'yi değerlendirir ve değerini döndürür. ```dart var gorunurluk = gorunurMu ? 'görünür' : 'gizli'; // Eğer boolean ifade null kontrolü yapıyorsa, ?? operatörünü kullanmayı düşünün. String playerName(String? isim) => isim ?? 'Misafir'; ``` ### Cascade Notasyonu Cascade (.., ?..) notasyonları, aynı nesne üzerinde bir dizi işlem yapmanıza olanak tanır. Örnek olarak: ```dart var boya = Paint() ..color = Colors.black ..strokeCap = StrokeCap.round ..strokeWidth = 5.0; ``` Yukarıdaki örnek, aşağıdaki kodla eşdeğerdir: ```dart var boya = Paint(); boya.color = Colors.black; boya.strokeCap = StrokeCap.round; boya.strokeWidth = 5.0; ``` Eğer cascade'in çalıştığı nesne null olabilirse, ilk işlem için bir null kontrolü cascade'i kullanın (?..). ```dart querySelector('#confirm') // Bir nesne al. ?..text = 'Onayla' // Üyelerini kullan. ..classes.add('önemli') ..onClick.listen((e) => window.alert('Onaylandı!')) ..scrollIntoView(); ``` Cascade kullanarak iç içe cascade'ler oluşturabilirsiniz. ```dart final adresDefteri = (AddressBookBuilder() ..name = 'Bayram' ..email = 'info@bayramalacam.com' ..phone = (PhoneNumberBuilder() ..number = '+90 5xx xxx xxxx' ..label = 'cep') .build()) .build(); ``` Cascade'inizi bir işlevin gerçek bir nesne döndürdüğünden emin olun. Aksi takdirde, cascade void üzerine kurulamaz. > **Not** > > Cascade notasyonu, kesin olarak "çift nokta" notasyonu olarak adlandırılmaz. Bu, sadece Dart dilinin bir parçasıdır. ### Diğer Operatörler Diğer operatörleri de başka örneklerde gördünüz:

Operatör	Adı	Anlamı
`()`	Fonksiyon uygulama	Bir fonksiyon çağrısını temsil eder.
`[]`	Parantez erişimi	Overridable [] operatörüne çağrıyı temsil eder; örneğin: fooList[1], fooList'e int 1'i iletilir ve 1. indeksteki elemana erişir.
`?[]`	Koşullu parantez erişimi	[], ancak en sol operand null olabilir; örneğin: fooList?[1], fooList null değilse 1. indeksteki elemana erişir; aksi takdirde ifade null olarak değerlendirilir.
`.`	Üye erişimi	Bir ifadenin özelliğine atıfta bulunur; örneğin: foo.bar, foo ifadesinden bar özelliğini seçer.
`?.`	Koşullu üye erişimi	En sol operand null olabilir; örneğin: foo?.bar, foo null değilse foo'nun bar özelliğini seçer; aksi takdirde foo?.bar ifadesinin değeri null olur.
`!`	Null olmayan güvence operatörü	Bir ifadeyi altında yatan non-nullable türüne dönüştürür; dönüşüm başarısız olursa çalışma zamanında bir istisna fırlatır; örneğin: foo!.bar, foo'nun null olmadığını ve bar özelliğini seçer, ancak foo null ise çalışma zamanında bir istisna fırlatılır.

--- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://dart.bayramalacam.com/sozdizimi-temelleri-syntax-basics/operatorler-operators.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.