Rust güçlü bir dildir, ancak nereden başlamalı? Başka bir dile alışkınsanız, Rust'ın bu tanıdık kavramlarla nasıl başa çıktığını bilmek isteyeceksiniz.
2015 yılında piyasaya sürülmesinden bu yana Rust, geliştiricilerin favori programlama dillerinden biri olarak popülerlik kazandı. Rust, dili arzu edilir kılan sezgisel ve özlü sözdizimi ile mükemmel performans ve güvenlik özellikleri sunar.
Rust, web uygulamaları, komut satırı araçları ve ağ hizmetleri dahil olmak üzere çeşitli programlar oluşturmak için uygundur. Rust, eşzamanlılık, tür çıkarımı ve daha fazlası gibi modern bir programlama dilinden bekleyeceğiniz birçok özelliği içerir.
Rust'a Başlarken
Rust, çoğu işletim sisteminde çalışan platformlar arası bir programlama dilidir. Rust'a başlamak için yetkiliye gidin Rust web sitesi ve işletim sisteminiz için tercih ettiğiniz sürümü kurun.
Rust'ı yükledikten sonra, Rust dosyalarında program yazmaya başlayabilirsiniz. .rs eklenti. Rust çok yönlüdür ve öğrenmesi kolaydır. Önceden programlama deneyiminiz varsa bunu basit bulacaksınız.
Rust'ta Değişkenler ve Sabitler
Rust son derece anlamlıdır ve değişkenleri bildirmenin birçok yolu vardır. kullanabilirsiniz izin vermek değişkenleri bildirmek için anahtar kelime.
Rust'ta değişkenleri şu şekilde bildirebilirsiniz:
izin vermek A: Sicim;
izin vermek B: i32;
izin vermek c: () = ();
bu A Ve B değişkenler sırasıyla bir dize ve bir tamsayıdır. bu C değişken, işlevler ve ifadeler için yer tutucu görevi gören bir Rust birim türüdür.
İsteğe bağlı veri türü bildiriminden sonra, eşittir işareti kullanarak değişkenleri değerlerle bildirebilir ve başlatabilirsiniz.
fnana(){
izin vermek yaş: Sicim = Sicim::itibaren("beş yaşında");
izin vermek yaş = 5; // izin yaşına eşdeğer: i32 = 5;
yazdır!("{}", yaş);
}
Program iki ilan ediyor yaş ile yazdırmadan önce değişkenler yazdır! makro. İlk yaş değişken veri türünü belirtir ve ikincisi belirtmez.
Bir değişkeni bildirirken veri türünü belirtmek zorunda değilsiniz. Rust derleyicisi, türü derleme zamanındaki değerin veri türünden çıkarır.
Ayrıca Rust'ta sabitleri şununla bildirebilirsiniz: sabit anahtar kelime, değişkenleri bildirmeye benzer şekilde:
sabit yaş: &str = "beş yaşında";
Sabit olarak bildirdiğiniz bir değişkenin değerini değiştiremezsiniz.
Rust, tek satırlık ve blok yorumlar için işlevsellik sağlar. Çift eğik çizgi kullanabilirsiniz (//) tek satırlık yorumlar için:
fnana() {
// Bu bir satır yorumudur
izin vermek x = 5; // Bu yorum "x" değişkeninin amacını açıklıyor
}
Çok satırlı yorumlar için (yorumları engelle), eğik çizgi ve ardından yıldız işareti (/*) ve bloğu bir yıldız işareti ve ardından eğik çizgi (*/):
fnana() {
/*
Bu, birden çok satıra yayılan bir blok yorumdur.
Genellikle daha büyük bir kod bloğunu tanımlamak için kullanılır.
*/
izin vermek x = 5;
}
Yorumlarınız kısa ve öz olmalıdır.
Rust'ta Diziler
Diziler, aynı veri türündeki öğelerin sabit boyutlu bir koleksiyonudur. Rust, varsayılan olarak yığındaki dizileri tahsis eder.
Rust'ta dizileri şu şekilde bildirebilirsiniz:
fnana() {
izin vermek sayılar = [1, 2, 3, 4, 5];
}
bu sayılar dizi beş öğe içerir. Dizindeki bir konumdaki değere dizinini kullanarak erişebilirsiniz:
fnana() {
izin vermek sayılar = [1, 2, 3, 4, 5];
izin vermek x = sayılar[3];
yazdır!("{}", X)
}
bu ana işlev yazdırır X dizinin dördüncü öğesine erişen değişken.
Rust'taki Vektörler
Rust, dizinin sınırlamalarını örtmek için vektörler sağlar. Vektörler dinamik olarak boyutlandırılır; gerektiği gibi büyüyebilir ve küçülebilirler.
Rust'ta vektörleri şu şekilde ilan edebilirsiniz:
fnana() {
izin vermek benim_vec'im: Vec<i32> = vec![1, 2, 3, 4, 5];
izin vermek x = benim_vec[3];
yazdır!("{}", X)
}
bu benim_vec vektör, 32 bitlik tam sayıların bir vektörüdür. bu X değişken, vektörün dördüncü öğesine erişir ve ana işlevi, değeri konsola yazdırır.
Rust'ın Koşullu İfadeleri
Koşullu ifadelerden biri Rust'ın kontrol yapıları programlarda karar verme için. kullanabilirsiniz eğer Ve başka programlarınızdaki kararları işlemek için anahtar kelimeler.
İşte bir eğer iki tam sayının eşitliğine dayalı olarak konsola bir dize yazdıran ifade.
fnana() {
izin vermek A: i32 = 12;
eğer bir == 12 {
yazdır!("a eşittir on iki");
}
}
bu ana işlev, dizeyi şu şekilde yazdırır: yazdır! değişken 12'ye eşit olduğu için makro.
kullanabilirsiniz başka olduğu durumları işlemek için anahtar kelime eğer ifade yanlış olarak değerlendirir:
fnana() {
izin vermek A: i32 = 12;
eğer bir == 123 {
yazdır!("a eşittir on iki");
} başka {
yazdır!("a on iki değildir");
}
}
Bu örnekte, başka ifade, a'nın değeri 123'e eşit olmadığı için çalışır.
Eşleşme bildirimlerini şu şekilde beyan edebilirsiniz: kibrit karmaşık koşullu ifadeler için anahtar kelime:
fnana() {
izin vermek yaş: i32 = 7;
kibrit yaş {
1 => yazdır!("bir"),
2 => yazdır!("iki"),
3 => yazdır!("üç"),
_ => yazdır!("sıfır"),
}
}
bu ana işlev eşleşir yaş vakalara göre değişken kibrit deyimi ve değerle eşleşen ifadeyi yürütür. Alt çizgi (_), değer için bir eşleşme varsa çalışan varsayılan ifadedir.
Rust'ta Döngüler
Rust, tekrarlanan görevler için döngüler sağlar. Rust'ta üç ana döngü türü vardır: döngü, sırasında, Ve için döngüler.
bu döngü anahtar sözcüğü, bir break anahtar sözcüğüyle karşılaşana kadar çalışan sonsuz bir döngü oluşturur:
fnana() {
döngü {
yazdır!("break deyimiyle karşılaşılıncaya kadar art arda yazdırılır.");
kırmak;
}
}
bu sırasında döngü, bir koşul doğru olarak değerlendirildiği sürece bir kod bloğunu tekrarlamak istediğinizde kullanışlıdır:
fnana() {
izin vermekmut saymak = 0;
sırasında saymak < 5 {
yazdır!("Sayı {}", saymak);
saymak += 1;
}
}
A için döngü, bir dizi gibi bir öğe koleksiyonu üzerinde yineleme yapmak için iyidir:
fnana() {
izin vermek sayılar = [1, 2, 3, 4, 5];
için öğe içinde sayılar.iter() {
yazdır!("Geçerli öğe {}", öğe);
}
}
Bu için döngü boyunca yinelenir sayılar dizi ve her öğeyi konsola yazdırır.
Rust İşlevlerini Bildirme ve Çağırma
Kullan fn anahtar kelime bir Rust işlevi bildirin, ardından işlev adı, bir parametre listesi ve bir dönüş türü (varsa).
Bir işlevi parametrelerle ve bir dönüş türüyle nasıl bildireceğiniz aşağıda açıklanmıştır:
fneklemek(A: i32, B: i32) -> i32 {
geri dönmek bir + b;
}
bu eklemek işlev iki 32 bitlik tamsayı alır ve iki parametrenin toplamı olan 32 bitlik bir tamsayı döndürür.
Bir işlevi kodunuzun herhangi bir yerinden çağırmak için, adı ve argümanları (varsa) belirtmeniz yeterlidir:
fnana() {
izin vermek sonuç = ekle(2, 3);
yazdır!("2 + 3 = {}", sonuç);
}
bu sonuç değişkeni çağırmanın sonucunu tutar eklemek işlev. bu ana işlevini kullanarak sonucu konsola yazdırır. yazdır! makro.
Rust'taki yapılar
Rust, ilgili değerleri gruplandıran özel veri türlerini tanımlamak için yapılar sağlar. Yapılar, belirli özelliklere sahip nesneler oluşturmak için planlardır.
Bir yapıyı şu şekilde ilan edebilirsiniz:
yapıKişi {
isim: Sicim,
yaş: u32,
erkek: bool,
}
bu Kişi struct'ın üç alanı vardır: bir String, işaretsiz 32 bitlik bir tamsayı ve bir boolean.
Bir yapı tanımladıktan sonra, programınızın diğer bölümlerinde bunun örneklerini oluşturabilirsiniz:
fnana() {
izin vermek kişi1 = Kişi {
isim: Sicim::itibaren("Candan Flynn"),
yaş: 16,
erkek: YANLIŞ,
};
}
bu kişi1 değişken, örneğinin bir örneğidir Kişi yapı Örneklemede, yapı alanlarına değerler atayabilirsiniz. Bir yapının istediğiniz kadar çok örneğini oluşturabilirsiniz.
Rust'ta OOP Kavramlarını Uygulayabilirsiniz
Rust esnektir ve yapılar gibi yerleşik veri yapılarıyla OOP kavramlarını Rust'ta uygulayabilirsiniz.
Yapıları sınıflara alternatif olarak kullanacaksınız. Rust'ın yapısıyla, tür için bir plan tanımlayabilir ve Rust'ın yapılar üzerinde sağladığı işlevlerle farklı OOP kavramlarını uygulayabilirsiniz.
