Rust dilinde ilk bilinmesi gerekenler

Temele programlama kavramlarının Rust dilinde nasıl çalıştığını gösterdim. Videosu daha sonra gelecektir.

Eğer okumak isterseniz ayrıca: Neden Rust dili

fn main() {

println!("Hello, world!");

// Eğer değişkenleri ve fonksiyonları kullanmazsanız

/*

Rust static analiz aracı

size uyarı verecektir.

*/

// Değişkenler immutabledır.

let x:u32 = 5;

let a= 1+20;

let e=20-8;

let c=56*78;

let b=78./44.;

let y=55%7;

let st= "Burası str";

let ch:char='z';

let tup=(44,846.65,"Bu bir tuple");

let (_,_,xtup) = tup;

let tup_erisimi=(tup.1,tup.2,tup.0); // t.3 hata demektir.

let arr=[-2,-1,0,1,2];

// index 0 ile başlar.

let eleman1=arr[0];

let tup= (40,'h',"baklava");

let iki_boyut_tup=(965416,("ratgele",3635,3.14)); // rust çoğu zaman tipleri otomatik algılar

println!("{} {} {}",tup.2, tup.1, tup.0);

print!("arr= {:?}\n", arr);

println!("debug yapar gibi ekrana yazdırır: {:?}",iki_boyut_tup); // debug yapar gibi ekrana yazdırır.

println!("daha düzenli: {:#?}",iki_boyut_tup); // debug yapar gibi ekrana yazdırır. Ama daha düzenli olarak.

// varialbe slice

let xm=[4,7,1,5,8,2,55];

let ym=&xm[2..4]; // [2,4) 2 dahil 4 dahil değil

let ym2=&xm[2..=4]; // [2,4) 2 dahil 4 dahil değil

print!("ym2= {:?}\n", ym2);

// rust "let" ile tanımlanan değerler değişmez ama "const" de değildir.

let immutale=5;

println!("immutale= {}", immutale);

/* // sayı değiştirilemez

immutalbe = 6;

println!("x= {}", immutale); */

// mut kelimesi ile tanımlananların değerleri değiştirilebilir.

let mut mutabile = 5;

println!("mutabile= {}", mutabile);

mutabile = 6;

println!("mutabile= {}", mutabile);

// "let" <-> "const" farkı. const tanımlanırken alır. let değeri sonradan da alabilir.

// const veri tipi önceden verilmelidir.

let sonradan;

const yuzbin:u32 = 100_000;

sonradan = yuzbin;

// sonradan = 5000; // hata

// let böyle birşeye izin verir. Bu işleme shadowing deniyor.

// Her let dediğinizde derleyici aslında yeni bir değişken oluşturur.

let x4=1;

let x4=x4+1; // 2

let x4=x4*2; // 4

println!("x4= {}",x4);

// let buna izin veriyor.

let karakterler = " Rust "; println!("karakterler= {}",karakterler);

let karakterler = karakterler.len(); println!("karakterler= {}",karakterler);

let mut araba = " Rust "; println!("araba= {}",araba);

let araba = araba.len(); println!("araba= {}",araba);

/* // let buna izin vermiyor.

let mut araba = " Rust ";

araba = araba.len();

// ayrıca buda yok.

let x = (let y = 6);

*/

// Diğer veri tipleri

/*

<Length Signed  Unsigned/>

8-bit   i8   u8

16-bit  i16  u16

32-bit  i32  u32

64-bit  i64  u64

128-bit i128    u128(llvm destekliyor. Neden olmasın dimi)

arch    isize   usize (programın derlendiği işlemci mimarisine bağlı)

<Number literals Example/>

Decimal  98_222(alt çizgi konabilir. oldukça okunaklı)

Hex  0xff

Octal    0o77

Binary   0b1111_0000

Byte (u8 only)  b'A'

*/

//Rust unicode destekler.

let c = 'z';

let z = 'ℤ';

let heart_eyed_cat = '😻';

println!("heart_eyed_cat= {}",heart_eyed_cat);

// rust lifetime basit örneği.

let x = 5;

let y = {

let x = 3; // burada x=3

x + 1 // rust içinde return kelimesi yoktur. Son ifade dönüş yapar.

}; // içerideki x silinde ve yukarıdan gelen nedediyle x=5

println!("x= {}",x); // x=5

println!("y= {}",y); // y=4

// karar ifadeleri diğer dillerde olduğu gibi kullanılabilir.

let number = 6;

if number % 4 == 0 {

println!("number is divisible by 4");

} else if number % 3 == 0 {

println!("number is divisible by 3");

} else if number % 2 == 0 {

println!("number is divisible by 2");

} else {

println!("number is not divisible by 4, 3, or 2");

}

// fazladan atama işlemi yapabiliriz.

let number = 6;

let yazekrana = if number % 4 == 0 {

"number is divisible by 4"

} else if number % 3 == 0 {

"number is divisible by 3"

} else if number % 2 == 0 {

"number is divisible by 2"

}

/* else if number % 11 == 0

{

123 // diğerlerinden farklı tip olduğundan hata verir.

} */

else {

"number is not divisible by 4, 3, or 2"

}; // noktalı virgül zorunludur.

println!("yazekrana= {}",yazekrana); // tüm değişkenler string olsa dahi println!("{}", değişken) gerektiriyor.

/**

* for, while, loop <-> while(true)

* loop while(true) ile aynıdır.

* while diğer programlama dillerindekiyle aynıdır.

*/

let mut counter = 0;

let result = loop { // isterseniz sonucu sonra atayın ama bence böyle daha pratik.

counter += 1;

if counter == 10 {

break counter * 2;

}

};

let mut number = 3;

while number != 0 {

println!("{}!", number);

number = number - 1;

}

let a = [10, 20, 30, 40, 50];

for element in a.iter() {

println!("the value is: {}", element);

}

for number in (1..4).rev() { // rev() reverse manasına geliyor. reverse iterator.

println!("{}!", number);

}

}