Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- // Bu bir satırlık yorumdur. Bir satırlık yorum böyle görünür
- /*
- ÇOK SATIRLI YORUM
- Rust Mozilla Research tarafından geliştirilmesi desteklenen bir dildir.
- Alt Seviye dil kontrolleri üzerine üst seviyenin kolaylığını ve veri
- güvenliğini ekler
- */
- /// Dökümantasyon yorumu böyle yazılr. Markdown notasyonları desteklenir.
- /// # Örnekler Başlığı
- /// ```
- /// fn main() {
- /// println!("Hello world!");
- /// }
- /// ```
- //////////////////////
- // Dilin Temelleri //
- ////////////////////
- // Fonksiyonlar
- // i32: 32 bit işaretli (+ / -) tamsayı
- // i8, i16, i64 de var
- // u işaretsizler (u8, u16, u32, u64)
- // Deüişken büyüklükler için isize, usize
- // Tür kendiliğinden algınalabilir
- // Deklare etmek istersek değişken adı : boşluk tür şeklinde
- // Örnek: let tamsayi: i32 = 35;
- // Örnek2: let tamsayi2 = 40;
- fn ikisini_topla(x: i32, y: i32) -> i32 {
- // Ruby, perl gibi son satır özellikle belirtmeksizin return edilir.
- // return eden fonksonlarda -> bulunur ve onu tür bilgisi izler
- x + y
- }
- // Her Rust programı muhakkak bir main fonksiyonu içerir
- fn main() {
- // Sayılar üzerine //
- // Immutable(Değiştirilemez) Binding (Bağlama/Bağlantı) oluşturma
- let x: i32 = 214;
- // float ve integer için son ek biçiminde tanımlama
- let y = 42i32;
- let f = 3.14f64;
- // Tür çıkarımı
- // Çoğunlukla rust derleyicisi bir değişkenin türünü belirleyebilir.
- // Yani görülebilir biçimde açık bir belirtim şekline mecbur değilsiniz.
- // ama öğretici boyunca açık belirtme şekli daha sık kullanılacak.
- let implicit_x = 1453;
- let implicit_f = 1.37;
- println!("{} ve {}", implicit_x, implicit_f);
- // Aritmetik bir işlemi değişkene Bağlama
- println!("İkisini topla fonksiyonunun döndüğü değer: {}", ikisini_topla(5, 4));
- let sum = x + y + 19;
- println!("sum değişkeninin değeri: {}", sum);
- // Değiştirlebilir Binding
- let mut mutable = 1;
- mutable += 2;
- println!("mutable değişkeninin değeri: {}", mutable);
- // Karakter Dizileri yani String //
- // Birebir string binding oluşturma
- let xs: &str = "merhaba genç!";
- // Yazdırma
- println!("Float değerimiz: {}, String Değerimiz: {}", f, xs);
- // Heap üzerinde bellek alanı ayrılmış string
- let s: String = "merhaba dünya.".to_string();
- // Bir string dilimi(string slice) string değişkeninin değiştirilemez görüntüsüdür.
- // Aşağıdaki temel olarak bir değiştirilemez ve stringi işaret eden işaretçi grubudur,
- // yani aslında string içeriğini barındırmaz, sabit olarak ayrılmış ya da bir nesne taşıyan
- // string önbelliğinnin başlangıcından bitimine kadar kısmına işaret eden işaretçidir.
- let s_slice: &str = &s;
- println!("{} {}", s, s_slice);
- // Vektörler ve Diziler //
- // Sabit Büyüklükte Bir Dizi
- let four_ints: [i32; 4] = [1, 2, 3, 4];
- println!("İlk dizimiz: {:?}", four_ints);
- // Değiştirlebilir büyüklükte bir dizi yani Vektör
- let mut vector: Vec<i32> = vec![1, 2, 3, 4];
- vector.push(5);
- println!("Öge eklenmiş vektörümüz: {:?}", vector);
- // Bir dilim (slice) bir vektör ya da dizinin değiştirilemez görüntüsüdür.
- // String dilimlerine benze bir mantıktadır.
- // Belli bir aralığı almak için: let dizi_dilim = &dizi[1..4] gibi
- let slice: &[i32] = &vector;
- // bir şeyi debug biçimlendirmesinde ekrana yazdırmak için: {:?}
- println!("Slice: {:?}", slice);
- // Tuple Değiken Tipi //
- // Bir tuple sabit büyüklükteki bir dizidir anca farklı türde değerler içerebilir.
- let tuple: (i32, &str, f64) = (1881, "samsun", 3.14);
- // Tanımlama şablonu örneği
- let (a, b, c) = tuple;
- println!("{} {} {}", a, b, c);
- // İndeks
- println!("tuple değişkeninin ilk itemi: {}", tuple.0);
- println!("tuple değişkeninin ikinci itemi: {}", tuple.1);
- println!("tuple değişkeninin içüncü itemi: {}", tuple.2);
- /////////////
- // Türler //
- ////////////
- // Struct ve Evet! Rust dilinde class yok :O
- // Koordinat bizim oluşturduğumuz bir struct
- // Tanımlamalar main fonksiyonu bitiminde başlıyor
- let origin: Koordinat = Koordinat { x: 0, y: 0};
- println!("origin değişkeni: x {} noktasında ve y {} noktasında.", origin.x, origin.y);
- let recipe: Cikolata = Cikolata(12.4, 3.14);
- println!("Çikolata: Kakao miktar: {} gr & Süt miktar {} gr", recipe.0, recipe.1);
- // Enumaratör
- // Alıştığımız C usulü
- enum Yonler {
- Sol,
- Sag,
- Yukari,
- Asagi,
- }
- let _up = Yonler::Yukari; // bir değişkeni tanımlar kullanmazsak başında _ olmalı yoksa derlenmez
- let _down = Yonler::Asagi;
- let _left = Yonler::Sol;
- let _right = Yonler::Sag;
- //Alan ile Enumaratör
- enum OptionalInteger {
- BirInteger(i32),
- Nothing,
- }
- let _four = OptionalInteger::BirInteger(4);
- let _nothing = OptionalInteger::Nothing;
- // ve Generics //
- let bir_foo = Foo { bar: 1923 };
- println!("bir_foo değişkenindeki bar değeri: {}", bir_foo.get_bar());
- let baska_bir_foo = Foo { bar: 1919 };
- println!("{:?}", baska_bir_foo.frobnicate());
- // Detaylı Olarak Şablon Eşleşmesi (Pattern Matching)
- let bar = FooBar {x: 23, y: OptionalI32::AnI32(1920) };
- match bar {
- FooBar { x: 0, y: OptionalI32::AnI32(0) } =>
- println!("Sayılar 0!"),
- FooBar { x: n, y: OptionalI32::AnI32(m) } if n == m =>
- println!("Sayılar aynı"),
- FooBar { x: n, y: OptionalI32::AnI32(m) } =>
- println!("Farklı sayılar: {} {}", n, m),
- FooBar { x: _, y: OptionalI32::Nothing } =>
- println!("İkinci sayı Nothing!"),
- }
- // Akış Denetimi //
- // Döngü ve iterasyon
- let dizi = [3, 5, 8];
- for i in dizi.iter() {
- println!("{}", i);
- }
- // Range
- for i in 0..40 {
- print!("{}", i);
- }
- println!("\n");
- // if / else
- if 5 > 0 {
- println!("Mantıklı");
- }else {
- println!("Yok artık!");
- }
- let deger = 1914;
- // bir ifadeymişçesine if
- let degisken = if deger == 1914 {"birinci"} else {"ikinci"};
- println!("{}: {}", degisken, deger);
- // while döngüsü
- let mut sayac = 0;
- while sayac < 10 {
- println!("{}", sayac);
- sayac += 1;
- }
- // sonsuz döngü
- let enfazla = 10;
- let mut digersayac = 0;
- loop {
- println!("Biri break ile durdurmadıkça döner durur!");
- if digersayac == enfazla {
- break;
- }
- digersayac += 1;
- }
- /////////////////////////////////////////////
- // Bellek Güvenliği & İşaretçiler(pointer) //
- ////////////////////////////////////////////
- // Sahiplenme: Bir işaretçiyi(pointer) bir seferde sadece BIR TEK nesne sahiplenir
- let mut benim: Box<i32> = Box::new(1914);
- *benim = 1916; // bu bir dereference örneğidir
- // Burada, `simdi_benim` `benim` değişkeninin sahipliğini alır. Başka bir ifadeyle, `mine` taşındı.
- let mut simdi_benim = benim;
- *simdi_benim += 3;
- println!("{}", simdi_benim); // 1919 dönecek
- // println!("{}", mine); // bu kesinlikle derlenmez çünkü artık işaretçiye `simdi_benim` sahip
- // Reference(referans :) ) başka bir dataya referans eden değiştirilemez bir işaretçidir
- // Bir referans değer aldığında bir bunu ödünç alındı(barrowed) olarak adlandırırız
- // Değer değiştirilemez biçimde ödünç alındığında Değiştirilemez ve Taşınamaz
- // Bir ödünç alma bulunduğu scope sona erdiğinde sona erer
- let mut _oylebirdegisken = 2017;
- _oylebirdegisken = 2013;
- let referans_degisken: &i32 = &_oylebirdegisken;
- println!("{}", _oylebirdegisken); // İlkel tiplerde ayrı bir referans pointer olmadığından oylebirdegisken kullanılabilir
- println!("{}", *referans_degisken);
- // Artık oylebirdegisken = 15; // derlenmez çünkü oylebirdegisken ödünç alındı
- // *referans_degisken = 666; // bu da derlenmeyecektir çünkü referans_değişken değiştirlemez bir referans
- // Değiştirilebilir Referans
- // Değer değiştirilebilir olarak ödünç alındığında (borrowed) tümüyle erişilmezdir.
- let mut oylebirdegisken2 = 1945;
- let referans_degisken2: &mut i32 = &mut oylebirdegisken2;
- *referans_degisken2 += 2; // '*' işareti ile değiştirilebilir olarak ödünç alınmış oylebirdegisken2 işaret edilir
- println!("{}", *referans_degisken2); // 1947, // eğer yerinde oylebirdegisken2 olursa derlenmeyecek
- // referans_degisken2 &mut i32 tipinde, öyle bir i32 yi referans gösterir değeri değil
- // oylebirdegisken2 = 2023; // derlenmez çünkü oylebirdegisken2 ödünç alındı.
- }
- // Aynı enum farklı adla public erişiminde BURADA (OptionalInteger)
- pub enum OptionalI32 {
- AnI32(i32),
- Nothing,
- }
- // STRUCT TANIMLARI BURADA //
- struct Koordinat {
- x: i32,
- y: i32,
- }
- struct Cikolata(f64, f64); // Bir tuple struct örneği
- struct Foo<T> {
- bar: T,
- }
- // Method
- impl<T> Foo<T> {
- // Methodlar belirtilmesi gereken bir self parametresi alırlar.
- // mesela bir getter gibi düşünelim
- fn get_bar(self) -> T {
- self.bar
- }
- }
- // Trait | Diğer dillerdeki Interface gibi düşünebilirsiniz
- trait Frobnicate<T> {
- fn frobnicate(self) -> Option<T>;
- }
- impl<T> Frobnicate<T> for Foo<T> {
- fn frobnicate(self) -> Option<T> {
- Some(self.bar)
- }
- }
- // Şablon Eşleşmesi Yeni bir Struct
- struct FooBar {
- x: i32,
- y: OptionalI32,
- }
- // STRUCT TANIMLARI BURADA BİTTİ //
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement