Rust'ta İşlevleri Anlamak

İşlevler, kodun yeniden kullanılabilirliği için bir temel oluşturdukları ve modüler programlamayı kolaylaştırdıkları için temel programlama yapılarıdır. İşlevler, belirli görevleri gerçekleştiren bağımsız kod bloklarıdır. Argüman biçiminde girdi alabilir ve bir değer döndürebilirler.

Rust, kod organizasyonu, kapsülleme ve kodun yeniden kullanılabilirliği için işlevler sağlar.

Rust'ta İşlev Tanımlama

Rust fonksiyonları çok benzer başka herhangi bir programlama dilinde işlevler, anlamanız gereken küçük farklılıklar olsa da.

Rust programlarınız için işlevleri tanımlayacaksınız. fn anahtar sözcük ve ardından işlev adı, isteğe bağlı bağımsız değişkenler ve isteğe bağlı bir dönüş veri tipi.

// bağımsız değişken almayan ve bir değer döndürmeyen işlev
fn işlev_adı() {
// burada işlev gövdesi
}

İşte herhangi bir bağımsız değişken almayan veya herhangi bir değer döndürmeyen basit bir Rust işlevi.

fn a_function(){
 x = olsun 3;
yazdır!("{}", X)
}

bir işlev değişkeni yazdıran basit bir Rust işlevidir X.

Rust İşlev İmzaları

İşlev imzaları, bir işlev gövdesi eklemeden işlevleri adlandırmanın ve bağımsız değişkenlerini ve dönüş türlerini açıklamanın bir yoludur. İşlev imzaları, Rust kitaplıklarının API'lerini belgelemek için kullanışlıdır.

İşte bir örnek Rust işlevi imzası:

fn adı()
fn selam (isim: &str)

bu isim işlevi, minimal bir işlev imzasıdır, oysa selamlaşmak imza, işlevin tek bir bağımsız değişken alacağını belirtir, isim, türünde dize (&str).

Argümanlar ve Dönen Değerlerle Fonksiyon Bildirme

Rust işlevleri birçok bağımsız değişken alabilir ve sınır açıkça tanımlanmamıştır. Bağımsız değişkenli işlevler, diğer işlevlerden ve kod bölümlerinden değerler alabildiğinden genellikle daha esnektir.

Bağımsız değişkenleri alan bir Rust işlevinin tipik modeli şöyledir:

fn işlev_adı (arg: tip, bağımsız değişken2: tip) {
// burada işlev gövdesi
}

İşlev bağımsız değişken türü, yerleşik bir Rust türü veya programınızdan özel bir tür olabilir.

İki tamsayıyı bağımsız değişken olarak alan basit bir işlev örneği:

fn ek_sayılar (x: i32, y: i32) {
yazdır!("{}", x + y);
}

bu sayı_ekle işlev iki 32 bit tamsayı alır ve tamsayıların toplamını yazdırır.

Rust işlevleri birden çok değer döndürebilir; dönüş tür(ler)ini belirtmeniz ve işlevden türün değerlerini döndürmeniz gerekir.

fn işlev_adı (arg: tip, bağımsız değişken2: tip) -> (tip, tip) {
// burada işlev gövdesi
geri dönmek argüman, argüman2
}

İşte argüman olarak bir dizge ve 32 bitlik bir tamsayı alan ve argümanları bir demet olarak döndüren bir işlev.

fn string_and_integer (s: Dizgi, n: i32) -> (Dize, i32) {
geri dönmek (s, n);
}

bu string_and_integer işlev bir dize ve 32 bitlik bir tamsayı alır ve bunları bir demet olarak döndürür. Rust işlevinden yalnızca tek bir değer döndürebilirsiniz.

dışında bırakabilirsiniz geri dönmek Bir işlevden son ifadeyi döndürürken, kodu daha özlü hale getirmek için anahtar kelime.

fn string_and_integer (s: Dizgi, n: i32) -> (Dize, i32) {
geri dönmek (s, n);
}
// fonksiyonlar eşdeğerdir
fn str_and_int (s: Dizgi, n: i32) -> (Dize, i32) {
 (s, n)
}

Bu iki işlev, her ikisi de bir dize ve tamsayı alıp bu bağımsız değişkenleri bir demet olarak döndürdüğü için aynı davranışa sahiptir.

Rust İşlevlerini Çağırma

Bir işlevi diğerinden, adını ve ardından ona iletmek istediğiniz değerleri parantez içinde yazarak çağırabilirsiniz:

fn add_numbers (x: i32, y: i32) -> i32 {
 x + y
}
fn ana() {
 sonuç = add_numbers(3, 5);
yazdır!("Sonuç: {}", sonuç); // Çıktı: Sonuç 8
}

bu ana fonksiyon çağrıları sayı_ekle, iki tam sayı geçirerek. Fonksiyonun sonucunu bir değişkene atar, sonuç.

Rust Yapılar İçin Fonksiyon Tanımlayabilirsiniz

İşlevleri Rust yapıları içinde bildirebilirsiniz. Bunlar, ona erişebilen ve onu değiştirebilen yapı için yöntemler haline gelir.

Rust tamamen nesne yönelimli değildir, ancak ilgili verileri gruplandırmak için yapılar sağlar. Yapıları ve yöntemleri kullanarak Rust'ta OOP kavramlarını uygulamak için çalışabilirsiniz.