Karat - Jenis Data

Sistem Jenis mewakili berbagai jenis nilai yang didukung oleh bahasa. Sistem Jenis memeriksa validitas nilai yang diberikan, sebelum disimpan atau dimanipulasi oleh program. Ini memastikan bahwa kode berperilaku seperti yang diharapkan. Sistem Jenis lebih jauh memungkinkan untuk petunjuk kode yang lebih kaya dan dokumentasi otomatis juga.

Rust adalah bahasa yang diketik secara statis. Setiap nilai di Rust memiliki tipe data tertentu. Kompilator dapat secara otomatis menyimpulkan tipe data variabel berdasarkan nilai yang diberikan padanya.

Deklarasikan Variabel

Menggunakan let kata kunci untuk mendeklarasikan variabel.

fn main() {
   let company_string = "TutorialsPoint";  // string type
   let rating_float = 4.5;                 // float type
   let is_growing_boolean = true;          // boolean type
   let icon_char = '♥';                    //unicode character type

   println!("company name is:{}",company_string);
   println!("company rating on 5 is:{}",rating_float);
   println!("company is growing :{}",is_growing_boolean);
   println!("company icon is:{}",icon_char);
}

Dalam contoh di atas, tipe data variabel akan disimpulkan dari nilai yang diberikan padanya. Misalnya, Rust akan menetapkan tipe data string ke variabel company_string , tipe data float ke rating_float , dll.

Hasil cetak! makro membutuhkan dua argumen -

Sintaks khusus {} , yang merupakan placeholder
Nama variabel atau konstanta

Placeholder akan diganti dengan nilai variabel

Output dari potongan kode di atas akan menjadi -

company name is: TutorialsPoint
company rating on 5 is:4.5
company is growing: true
company icon is: ♥

Jenis Skalar

Jenis skalar mewakili satu nilai. Misalnya, 10,3.14, 'c'. Karat memiliki empat jenis skalar utama.

Integer
Floating-point
Booleans
Characters

Kami akan mempelajari tentang setiap jenis di bagian selanjutnya.

Bilangan bulat

Integer adalah bilangan tanpa komponen pecahan. Sederhananya, tipe data integer digunakan untuk merepresentasikan bilangan bulat.

Integer selanjutnya dapat diklasifikasikan sebagai Signed dan Unsigned. Bilangan bulat yang ditandatangani dapat menyimpan nilai negatif dan positif. Bilangan bulat tak bertanda tangan hanya dapat menyimpan nilai positif. Penjelasan rinci jika tipe integer diberikan di bawah -

Sr.No.	Ukuran	Tertanda	Tidak ditandatangani
1	8 bit	i8	u8
2	16 bit	i16	u16
3	32 bit	i32	u32
4	64 bit	i64	u64
5	128 bit	i128	u128
6	Lengkungan	isize	menggunakan

Ukuran bilangan bulat bisa berupa lengkungan . Ini berarti ukuran tipe data akan diturunkan dari arsitektur mesin. Bilangan bulat yang ukurannya arch adalah 32 bit pada mesin x86 dan 64 bit pada mesin x64. Bilangan bulat lengkung terutama digunakan saat mengindeks beberapa jenis koleksi.

Ilustrasi

fn main() {
   let result = 10;    // i32 by default
   let age:u32 = 20;
   let sum:i32 = 5-15;
   let mark:isize = 10;
   let count:usize = 30;
   println!("result value is {}",result);
   println!("sum is {} and age is {}",sum,age);
   println!("mark is {} and count is {}",mark,count);
}

Outputnya akan seperti yang diberikan di bawah ini -

result value is 10
sum is -10 and age is 20
mark is 10 and count is 30

Kode di atas akan mengembalikan kesalahan kompilasi jika Anda mengganti nilai usia dengan nilai titik mengambang.

Rentang Integer

Setiap varian bertanda tangan dapat menyimpan nomor dari - (2 ^ (n-1) hingga 2 ^ (n-1) -1 , di mana n adalah jumlah bit yang digunakan varian. Misalnya, i8 dapat menyimpan angka dari - (2 ^ 7) menjadi 2 ^ 7 -1 - di sini kita mengganti n dengan 8.

Setiap varian unsigned dapat menyimpan angka dari 0 hingga (2 ^ n) -1 . Misalnya, u8 dapat menyimpan angka dari 0 hingga 2 ^ 7 , yang sama dengan 0 hingga 255.

Integer Overflow

Kelebihan bilangan bulat terjadi ketika nilai yang ditetapkan ke variabel bilangan bulat melebihi rentang yang ditentukan Rust untuk tipe data. Mari kita pahami ini dengan sebuah contoh -

fn main() {
   let age:u8 = 255;

   // 0 to 255 only allowed for u8
   let weight:u8 = 256;   //overflow value is 0
   let height:u8 = 257;   //overflow value is 1
   let score:u8 = 258;    //overflow value is 2

   println!("age is {} ",age);
   println!("weight is {}",weight);
   println!("height is {}",height);
   println!("score is {}",score);
}

Rentang valid variabel unsigned u8 adalah 0 sampai 255. Dalam contoh di atas, variabel diberi nilai lebih besar dari 255 (batas atas untuk variabel integer di Rust). Saat dieksekusi, kode di atas akan mengembalikan peringatan -warning − literal out of range for u8untuk variabel berat, tinggi dan skor. Nilai overflow setelah 255 akan dimulai dari 0, 1, 2, dll. Output akhir tanpa peringatan seperti yang ditunjukkan di bawah ini -

age is 255
weight is 0
height is 1
score is 2

Mengapung

Tipe data float di Rust dapat diklasifikasikan sebagai f32 dan f64. Jenis f32 adalah float presisi tunggal, dan f64 memiliki presisi ganda. Jenis defaultnya adalah f64. Pertimbangkan contoh berikut untuk memahami lebih lanjut tentang tipe data float.

fn main() {
   let result = 10.00;        //f64 by default
   let interest:f32 = 8.35;
   let cost:f64 = 15000.600;  //double precision
   
   println!("result value is {}",result);
   println!("interest is {}",interest);
   println!("cost is {}",cost);
}

Outputnya akan seperti yang ditunjukkan di bawah ini -

interest is 8.35
cost is 15000.6

Pengecoran Jenis Otomatis

Pengecoran tipe otomatis tidak diperbolehkan di Rust. Perhatikan cuplikan kode berikut. Nilai integer diberikan ke variabel floatinterest.

fn main() {
   let interest:f32 = 8;   // integer assigned to float variable
   println!("interest is {}",interest);
}

Kompilator melempar file mismatched types error seperti yang diberikan di bawah ini.

error[E0308]: mismatched types
   --> main.rs:2:22
   |
 2 | let interest:f32=8;
   |    ^ expected f32, found integral variable
   |
   = note: expected type `f32`
      found type `{integer}`
error: aborting due to previous error(s)

Pemisah Nomor

Untuk memudahkan pembacaan angka besar, kita dapat menggunakan pemisah visual _ garis bawah untuk memisahkan digit. Itu 50.000 dapat ditulis sebagai 50_000. Ini ditunjukkan pada contoh di bawah ini.

fn main() {
   let float_with_separator = 11_000.555_001;
   println!("float value {}",float_with_separator);
   
   let int_with_separator = 50_000;
   println!("int value {}",int_with_separator);
}

Outputnya diberikan di bawah ini -

float value 11000.555001
int value 50000

Boolean

Jenis Boolean memiliki dua kemungkinan nilai - benar atau salah . Menggunakanbool kata kunci untuk mendeklarasikan variabel boolean.

Ilustrasi

fn main() {
   let isfun:bool = true;
   println!("Is Rust Programming Fun ? {}",isfun);
}

Output dari kode di atas akan menjadi -

Is Rust Programming Fun ? true

Karakter

Tipe data karakter di Rust mendukung angka, huruf, Unicode dan karakter khusus. Menggunakancharkata kunci untuk mendeklarasikan variabel tipe data karakter. Jenis karakter Rust mewakili Nilai Skalar Unicode, yang berarti dapat mewakili lebih dari sekadar ASCII. Nilai Skalar Unicode berkisar dariU+0000 untuk U+D7FF dan U+E000 untuk U+10FFFF inklusif.

Mari kita pertimbangkan contoh untuk memahami lebih lanjut tentang tipe data Karakter.

fn main() {
   let special_character = '@'; //default
   let alphabet:char = 'A';
   let emoji:char = '';
   
   println!("special character is {}",special_character);
   println!("alphabet is {}",alphabet);
   println!("emoji is {}",emoji);
}

Output dari kode di atas akan menjadi -

special character is @
alphabet is A
emoji is