6- Dart String Özellikleri ve Metodları

var cumle = "Dart Öğreniyorum";
var yeniCumle = cumle.lenght;
print(yeniCumle);

//Boş mu? sonucunu true yada false olarak döndürür.

var cumle = "Dart Öğreniyorum";
var cumleBosmu= cumle.isEmpty;
print(cumleBosmu); 

//Sonuç: false olarak çıktımızı alırız çünkü cumle değişkenimizin içerisinde 
//Dart Öğreniyorum yazıyor ve sonuç olarak içerisi dolu yani içerisi 
//boşmu sorusunun cevabı false olarak gelir. 

//Dolu mu? sonucunu true yada false olarak döndürür.

var cumle = "Dart Öğreniyorum";
var cumeVarmi= cumle.isNotEmpty;
print(cumleVarmi); 

//Sonuç: true olarak çıktımızı alırız çünkü cumle değişkenimizin içerisinde 
//Dart Öğreniyorum yazıyor ve sonuç olarak dolu yani boş değil mi(dolu mu) sorusunun cevabı 
//true değeri gelir.

//Metnin içerisinde kelime yada bir karakter olup olmadığının 
//sonucunu true yada false olarak döndürür.
 
var cumle = "Dart Öğreniyorum";
var harfVarmi= cumle.contains('D');
print(harfVarmi); 

// Sonuç: true

var cumle = "Dart Öğreniyorum";
var harfVarmi= cumle.contains('D',1);
print(harfVarmi); 

// Sonuç: false olarak gelir. Dikkat ederseniz 1 nci index ve sonrasında yok. 
//D ise 0 ncı indexte.
// Yanına yazdığımız sayı kaçıncı indexten aramaya başlayacağını belirtiyor.

var cumle = "Dart Öğreniyorum";
var harfVarmi= cumle.contains(RegExp(r'[a,z]'));
print(harfVarmi); 

// Sonuç: true olarak gelir. RegExp() desen sorgulamaları için kullandığımız bir metod. 
//Birden fazla karakteri bu şekilde sorgulayabiliriz. RegExp() detaylı bir konu, 
//bunu ayrı bir yazımızda detaylı olarak inceleyeceğiz.

//replaceAll(' bulunacakdeğer ' , ' yerinekonulacakdeğer '); 
// tüm karakterleri sırasıyla arar.

String cumle = "Mehmet Eser";
String yeniCumle = cumle.replaceAll('e','a');
print (yeniCumle);

//Sonuç: e karakterini a ile değiştirecektir. 
//Mahmat Esar sonucunu üretir.

//replaceAll(' bulunacakdeğer ' , ' yerinekonulacakdeğer '); 
//İlk bulduğu karakteri değiştirir. 
//Sonrasına karışmaz.

String cumle = "Mehmet Eser";
String yeniCumle = cumle.replaceFirst('e','a');
print (yeniCumle);

//Sonuç: İlk karaktere bakar varsa  e karakterini a ile değiştirecektir. 
//Mahmet Eser olarak sonuç üretecektir.

String cumle = "Mehmet Eser";
String yeniCumle = cumle.replaceFirst('e','a' 4);
print (yeniCumle);

//Sonuç: Belirttiğimiz indexe bakacak ve Mehmat Eser sonucunu üretecektir.

//replaceAll(' başlangıçindexi' , ' bitişindexi ' , ' yazılacakdeğer ' ); 

String cumle = "Mehmet Eser";
String yeniCumle = cumle.replaceRange('1','6','ahmut');
print (yeniCumle);

//Sonuç: Mahmut Eser olacaktır.

//replaceAll(' değişecekdeğer' , (m) => yapılacakişlem ); 

//Değişecek olan değer m ye aktarılıyor, bizde bu fonksiyon ile 
//yerine bir işlem yapıp yeni değerini koyabiliriz. 
//Ancak bu bulduğu ilk değer için geçerli. 
//Eğer örneğin tüm e harfleri için işlem yapmasını istiyorsak 
//replaceAllMapped kullanmamız gerekir. 
//Basit bir örnek yapalım;

var cumle = " Mehmet Eser";
var yeniCumle = cumle.replaceFirstMapped('e' , (m) => 'a');
print (yeniCumle); 

//Sonuç: Mahmet Eser olacaktır.

//Bulduğu sonuca göre index numarasını döndürür, eğer bulamazsa -1 döndürür.

var cumle = "Mehmet";
var yeniCumle = cumle.indexOf('e');
print (yeniCumle);

//Sonuç: 1 nci indexte bulacağı için sonuç 1 dönder. 
//Eğer hiç olmasaydı -1 dönecekti.

//Bu metod sondan başa doğru aramaya başlar. 
//Bulduğu sonuca göre index numarasını döndürür, 
//eğer bulamazsa -1 döndürür.

var cumle = "Mehmet";
var yeniCumle = cumle.lastIndexOf('e');
print (yeniCumle);

//Sonuç: Sondan 1 nci indexte buldu ancak baştan sayıp 
//bize 4 ncü indexte olduğu sonucunu üretti.

//padLeft(değer); verilen değer kadar soldan sağa kayar. padRight(değer); 
//verilen değer kadar sağında bulunan ifade okadar uzaklaşır.

var cumle = "Mehmet Eser";
var yeniCumle = cumle.padLeft('20');
print (yeniCumle);

//Sonuç: ..........Mehmet Eser, sol tarafatan 20 değerinde boşluk bıraktı.

var cumle = "Mehmet Eser";
var yeniCumle = cumle.padRight('20') + "dışarı çıktı" ;
print (yeniCumle);

//Sonuç:Mehmet Eser...........dışarı çıktı, 
//sağ tarafa yeni eklediğimiz metinsel ifade 
//20 değerinde sağa kaydı.

//Bir metni belirtmiş olduğumuz patern ile böler. Bir liste içerisine atar. 
//Belirttiğimiz patterni almaz.

String cumle = "Ben bugün okula gittim";
List<String> 
yeniCumle =cumle.split(" ");
print(yeniCumle);

//Sonuç: [Ben, bugün, okula, gittim] görüldüğü üzere boşluk karakterinle 
//ayırmasını istedik ve oda bize her bir boşluk karakterine kadar olan 
//kelimeyi aldı ve diziye attı.
 
String cumle = "www.yazilimdili.net";
List<String> 
yeniCumle =cumle.split(".");
print(yeniCumle);

//Sonuç: [www, yazilimdili, net] görüldüğü üzere nokta karakterinle 
//ayırmasını istedik ve oda bize her bir nokta karakterine kadar olan
// kelimeyi aldı ve diziye attı.

String cumle = "eşşek";
List<String> 
yeniCumle =cumle.split("");
print(yeniCumle);

//Sonuç: [e, ş, ş, e, k] burada hiç bir karakter kullanmadık 
//ve kelimeyi bize harf harf bölüm diziye attı.

//Bu metod metinsel bir ifadenin içinden index numaralarına göre 
//belli bir alanı almamıza yarar.

var cumle = "Mehmet";
var yeniCumle = cumle.substring(3,6);
print (yeniCumle);
//Sonuç: met sonucunu üretir. 

var cumle = "Mehmet";
var yeniCumle = cumle.substring(1);
print (yeniCumle);

//Sonuç: ehmet sonucunu üretir. Görüldüğü üzere ilk indeximizi belirttik 
//ve diğerini belirtmedik. Bu şekilde belirttiğimiz indexten sonuna kadar aldı. 

//Bu metod metni küçük harfe çevirir.

var cumle = "MEHMET";
var yeniCumle = cumle.toLowerCase();
print (yeniCumle);

//Sonuç: mehmet sonucunu üretir.

//Bu metod metni büyük harfe çevirir.

var cumle = "mehmet";
var yeniCumle = cumle.toUpperCase();
print (yeniCumle);

//Sonuç: MEHMET sonucunu üretir.

trim(); //Bu metod string bir ifadenin başından ve sonundan boşluk karakterlerini siler.
trimLeft(); //Sadece solundaki boşluk karakterlerini siler.
trimRight(); //Sadece sağındaki boşluk karakterlerini siler.

var cumle = "    mehmet eser   ";
var yeniCumle = cumle.trim();
print (yeniCumle);

//Sonuç: Başından ve sonundan boşluk karakterlerini siler ve mehmet eser sonucunu üretir.

//Bu metod bize metinsel ifadenin en başında yada belirttiğimiz indexte 
//sorguladığımız karakterin olup olmadığı sonucunu true yada false olarak döndürür. 
//contains() metodu ile ile benzerlik gösterse de 
//contains() metodu tüm metinsel ifadeyi arar.
//Burada ise ilk karaktere bakar yada belirttiğimiz indexe bakar.

var cumle = "mehmet eser ";
var yeniCumle = cumle.startsWith('h');
print (yeniCumle);

//Sonuç: false dönecektir. Çünkü ilk karakter m harfidir. 
//Eğer m diye aratsaydık sonuç true dönecekti yada 
//startsWith('h',2); yazsaydık yine true dönecekti. 
//2 nci indeximiz h olduğu için.

//Bu metod startsWith() metodu ile aynı mantıkta çalışmaktadır. 
//startsWith() ilk karaktere bakıyor bu ise son karaktere bakıyor.

//Bu metod karşılaştırma yapar. Bir değeri belirttiğimiz değer ile karşılaştırır 
//ve büyük, eşit, küçüklük durumuna göre 1, 0, -1 döndürür. 
//String ifadelerde ise alfabetik sıraya göre işlem yapar.

var x = 5;

print (x.compareTo(2)); 

//Sonuç: 1 döner

print (x.compareTo(5)); 

//Sonuç: 0 döner

print (x.compareTo(8)); 

//Sonuç: -1 döner

var metin = "eser";

print(metin.compareTo("esat")); 

// Sonuç: 1 döner

print(metin.compareTo("eser")); 

// Sonuç: 0 döner

print(metin.compareTo("esma")); 

// Sonuç: -1 döner