Bu dil temellerini öğrenerek Rust programlama kariyerinize başlayın.

Kontrol yapıları, programlarınızdaki yürütme akışını kontrol etmenize izin veren bir programlama yapısıdır. Kontrol yapıları, yalnızca belirli koşullar karşılandığında çalıştırılacak yönergeleri belirtmenize izin verir.

Rust'ın kontrol yapıları, program akışını yönetmek için çok önemlidir ve karmaşık görevleri daha küçük, yeniden kullanılabilir bileşenlere basitleştirirken verimli kod yürütülmesini sağlar.

Rust Koşullu İfadeler

Koşullu ifadeler, koşullara dayalı olarak kod çalıştırmanıza izin veren yapılardır. Programın yürütülmesi, koşulun şu şekilde değerlendirilip değerlendirilmemesine bağlı olduğundan, koşullu ifadeler karar vermede kullanışlıdır. doğru veya YANLIŞ. pas sağlar eğer, başka, Ve kibrit karar vermek için açıklamalar.

Rust programlarında, eğer ifade, belirli bir koşulun doğru olarak değerlendirilip değerlendirilmediğini test eder. Varsa, program ilişkili kod bloğunu çalıştırır. Koşul yanlış olarak değerlendirilirse, program bu kod bloğunu atlar ve bir sonraki ifadeye geçer veya başka varsa ifade bloğu.

instagram viewer

bu kibrit deyimi, bir programın değerleri bir dizi örüntüyle eşleştirmesine ve eşleşen örüntüye dayalı olarak kod yürütmesine izin veren güçlü bir kontrol akışı yapısıdır.

Rust if İfadeleri

ilan edeceksin eğer ile Rust programlarınızdaki ifadeler eğer ardından bir koşul gelen anahtar kelime:

eğer durum {
// koşul doğruysa çalıştırılacak kod
}

İşte Rust programlarınızda bir if ifadesini nasıl kullanabileceğinize dair bir örnek:

fnana() {
izin vermek x = 15;
eğer x > 10 {
yazdır!("x 10'dan büyüktür");
 }
}

bu X değişken 32 bitlik bir tamsayı tutar ve if ifadesi, onu yazdıran kod bloğunu çalıştırmadan önce x değerinin ondan büyük olup olmadığını kontrol eder.

Rust'ın diğer Beyanları

Şunu kullanacaksınız: başka tahmin ettiğinizde bir kod bloğunu çalıştırmak için anahtar kelime eğer ifade yanlış olarak değerlendirilecektir.

eğer durum {
// koşul doğruysa çalıştırılacak kod
} başka {
// koşul yanlışsa çalıştırılacak kod
}

İşte bir örnek X 10'dan büyük değil, eğer ifade değerlendirir YANLIŞ, ve bir başka deyim çalışır.

fnana(){
izin vermek x = 5;
eğer x > 10 {
yazdır!("x 10'dan büyüktür");
 } başka {
yazdır!("x 10'dan büyük değil");
 }
}

O zamandan beri X 5'tir ve 5, 10'dan büyük değilse, program eğer engeller ve yürütür başka engellemek.

Rust'ın maç Açıklamaları

Şunu kullanacaksınız: kibrit bir dizi kalıbı kontrol etmek ve kalıp eşleşmelerine dayalı olarak kod yürütmek için karmaşık karar verme için anahtar kelime. Eşleşme ifadeleri şuna benzer: C#'ta anahtar ifadeleri, Git ve C++.

Rust eşleşme bildiriminin yapısı şöyledir:

kibrit değer {
 model1 => {
// değer desen1 ile eşleşirse yürütülecek kod
 },
 desen2 => {
// değer desen2 ile eşleşirse yürütülecek kod
 },
// vesaire.
}

Eşleşme ifadelerini programlarınızda şu şekilde kullanabilirsiniz:

izin vermek derece = 'B';
kibrit seviye {
'A' => yazdır!("Harika iş!"),
'B' => yazdır!("Aferin."),
'C' => yazdır!("Daha iyisini yapabilirsin."),
 _ => yazdır!("Bu geçerli bir not değil."),
}

bu seviye değişken bir karakterdir ve kibrit ifade, => operatöründen sonra kodu çalıştırmadan önce hangi karakterin derece değişkeninin değerini değerlendirdiğini kontrol eder. Diğer kalıplarla (varsayılan kalıp) eşleşmeyen değerleri eşleştirmek için alt çizgi (_) kalıbını kullanabilirsiniz.

Rust'ta Döngüler

Döngüler, aşağıdakiler gibi tekrarlanan görevler için kullanılan temel bir yapıdır: ağ kazıma ve diğer otomatik eylemler. Rust, aşağıdakiler de dahil olmak üzere farklı döngü türleri sağlar: sırasında döngüler, için döngüler ve döngü döngü.

Rust'ın while Döngüleri

While döngüleri, belirli bir koşul doğru olarak değerlendirildiği sürece bir kod bloğunu tekrar eder. Koşulu belirtmeden önce, Rust'ta while döngülerini şu şekilde belirteceksiniz: sırasında anahtar kelime.

sırasında durum {
// yürütülecek kod
}

Koşul, döngünün devamını belirleyen bir boole ifadesi olmalıdır. Koşul yanlış olarak değerlendirildiğinde, döngüden çıkılır.

Birden beşe kadar sayıları yazdıran bir Rust while döngüsü örneği.

fnana() {
izin vermekmut ben = 1;
sırasında ben <= 5 {
yazdır!("{}", Ben);
 ben += 1;
 }
}

içindeki while döngüsü ana işlevi, değeri artırırken birden beşe kadar olan sayılar arasında gezinir. Ben kadar birer birer değişir Ben değişken, döngünün sona erdiği yerde beşten büyüktür.

döngü döngü

bu döngü anahtar sözcüğü, siz bir çıkış bildirene kadar sonsuz bir döngü oluşturur. kırmak anahtar kelime.

döngü {
// yürütülecek kod
eğer durum {
kırmak;
 }
}

içindeki kod döngü blok, döngü bir hatayla karşılaşana kadar yürütmeye devam edecektir. kırmak anahtar kelime.

İşte kullanmanın bir örneği döngü belirtmeden önce birden beşe kadar sayıları yazdırmak için döngü kırmak çıkış için anahtar kelime.

fnana() {
izin vermekmut ben = 1;
döngü {
yazdır!("{}", Ben);
 ben += 1;
eğer ben > 5 {
kırmak;
 }
 }
}

bu ana fonksiyon döngüyü yürütür ve eğer ifadesi artırır Ben değişken. bu eğer ifade, döngü sonlandırmasını belirtir. Ben değişken beşi aşıyor.

Döngüler için Rust

Rust'ta, for döngüleri bir değer aralığında veya bir değer koleksiyonunda yinelenir. Şunu kullanacaksınız: için etki edeceği aralığı veya koleksiyonu belirtmeden önce bir for döngüsü başlatmak için anahtar kelime.

için değişken içinde menzil {
// yürütülecek kod
}

bu menzil bir değer dizisi olarak değerlendiren bir ifadedir ve değişken, dizideki her değeri sırayla alan bir değişkendir. Kod bloğu, dizideki her değer için bir kez yürütülür.

İşte birden ona kadar değişen değerleri basan bir for döngüsü örneği.

fnana() {
için Ben içinde1..=10 {
yazdır!("{}", Ben);
 }
}

Döngü, 1'den 10'a kadar olan değerler arasında yinelenir. Her yinelemede, (i) değişkeni bir sonraki değeri tutar; yazdır! makro daha sonra yazdırılır.

kullanabilirsiniz devam etmek for döngülerindeki değerleri atlamak için anahtar kelime. Bir aralıkta çalışırken çift sayıları şu şekilde atlayabilirsiniz:

fnana() {
için sayı içinde1..=10 {
eğer sayı % 2 == 0 {
devam etmek; // çift sayıları atla
 }
yazdır!("{}", sayı); // tek sayıları yazdır
 }
}

bu eğer deyimi kullanır devam etmek döngünün ikiye bölünebilen sayıları atlamasını belirtmek için anahtar kelime.

Ek olarak, ile bir for döngüsünden çıkabilirsiniz. kırmak anahtar kelime. ile karşılaşıldığında döngü sona erer. kırmak anahtar kelime.

fnana() {
için sayı içinde1..=10 {
eğer sayı == 5 {
kırmak; // sayı 5'e eşit olduğunda döngüden çık
 }
yazdır!("{}", sayı); // 1'den 4'e kadar sayıları yazdır
 }
}

bu eğer ifade, döngünün şu durumlarda sonlanması gerektiğini belirtir: Ben değişken beşe eşittir.

Dile hakim olmak için Rust'ın Kontrol Yapılarını Veri Türleriyle Kullanın

Rust, yerleşik ve özel veri türleri üzerindeki işlemler için bu esnek kontrol yapılarını sağlar. Diziler, vektörler, yapı ve numaralandırmalar gibi bileşik ve bileşik veri yapıları üzerinde işlem yapmak için bu kontrol yapılarını kullanabilirsiniz.

Rust ayrıca yapılar sağlar. Yapılar, ilgili değerleri tek bir nesnede gruplayan veri yapılarıdır. Nesne yönelimli dillerdeki sınıflara benzerler ve üzerlerinde yöntemler bile tanımlayabilirsiniz.