Rust - Loại dữ liệu

Hệ thống Loại biểu thị các loại giá trị khác nhau được ngôn ngữ hỗ trợ. Hệ thống Loại kiểm tra tính hợp lệ của các giá trị được cung cấp, trước khi chúng được chương trình lưu trữ hoặc thao tác. Điều này đảm bảo rằng mã hoạt động như mong đợi. Hệ thống Loại cũng cho phép gợi ý mã phong phú hơn và tài liệu tự động.

Rust là một ngôn ngữ được gõ tĩnh. Mọi giá trị trong Rust đều thuộc một kiểu dữ liệu nhất định. Trình biên dịch có thể tự động suy ra kiểu dữ liệu của biến dựa trên giá trị được gán cho nó.

Khai báo một biến

Sử dụng let từ khóa để khai báo một biến.

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);
}

Trong ví dụ trên, kiểu dữ liệu của các biến sẽ được suy ra từ các giá trị được gán cho chúng. Ví dụ: Rust sẽ gán kiểu dữ liệu chuỗi cho biến company_string , kiểu dữ liệu float cho rating_float , v.v.

Bản in ! macro có hai đối số -

• Cú pháp đặc biệt {} , là trình giữ chỗ
• Tên biến hoặc một hằng số

Phần giữ chỗ sẽ được thay thế bằng giá trị của biến

Đầu ra của đoạn mã trên sẽ là:

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

Các loại vô hướng

Kiểu vô hướng đại diện cho một giá trị duy nhất. Ví dụ: 10,3.14, 'c'. Rust có bốn kiểu vô hướng chính.

• Integer
• Floating-point
• Booleans
• Characters

Chúng ta sẽ tìm hiểu về từng loại trong các phần tiếp theo của chúng tôi.

Số nguyên

Một số nguyên là một số không có thành phần phân số. Nói một cách đơn giản, kiểu dữ liệu số nguyên được sử dụng để biểu diễn các số nguyên.

Số nguyên có thể được phân loại thêm là Đã ký và Chưa ký. Số nguyên có dấu có thể lưu trữ cả giá trị âm và giá trị dương. Các số nguyên không dấu chỉ có thể lưu trữ các giá trị dương. Mô tả chi tiết nếu các kiểu số nguyên được cung cấp bên dưới:

Sr.No.	Kích thước	Đã ký	Chưa ký
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	Vòm	isize	sử dụng

Kích thước của một số nguyên có thể là vòm . Điều này có nghĩa là kích thước của kiểu dữ liệu sẽ được lấy từ kiến trúc của máy. Một số nguyên có kích thước là vòm sẽ là 32 bit trên máy x86 và 64 bit trên máy x64. Một số nguyên vòm chủ yếu được sử dụng khi lập chỉ mục một số loại tập hợp.

Hình minh họa

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);
}

Đầu ra sẽ như dưới đây:

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

Đoạn mã trên sẽ trả về lỗi biên dịch nếu bạn thay thế giá trị của tuổi bằng giá trị dấu phẩy động.

Dải số nguyên

Mỗi biến thể có dấu có thể lưu trữ các số từ - (2 ^ (n-1) đến 2 ^ (n-1) -1 , trong đó n là số bit mà biến thể sử dụng. Ví dụ: i8 có thể lưu trữ các số từ - (2 ^ 7) thành 2 ^ 7 -1 - ở đây chúng tôi thay thế n bằng 8.

Mỗi biến thể không dấu có thể lưu trữ các số từ 0 đến (2 ^ n) -1 . Ví dụ: u8 có thể lưu trữ các số từ 0 đến 2 ^ 7 , tương đương với 0 đến 255.

Tràn số nguyên

Tràn số nguyên xảy ra khi giá trị được gán cho một biến số nguyên vượt quá phạm vi được xác định Rust cho kiểu dữ liệu. Hãy để chúng tôi hiểu điều này với một ví dụ -

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);
}

Phạm vi hợp lệ của biến u8 không dấu là 0 đến 255. Trong ví dụ trên, các biến được gán giá trị lớn hơn 255 (giới hạn trên cho một biến số nguyên trong Rust). Khi thực thi, đoạn mã trên sẽ trả về cảnh báo -warning − literal out of range for u8cho các biến cân nặng, chiều cao và điểm số. Các giá trị tràn sau 255 sẽ bắt đầu từ 0, 1, 2, v.v. Kết quả cuối cùng không có cảnh báo như hình dưới đây:

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

Phao nổi

Kiểu dữ liệu nổi trong Rust có thể được phân loại là f32 và f64. Loại f32 là phao chính xác đơn và f64 có độ chính xác gấp đôi. Loại mặc định là f64. Hãy xem xét ví dụ sau để hiểu thêm về kiểu dữ liệu 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);
}

Đầu ra sẽ như hình dưới đây -

interest is 8.35
cost is 15000.6

Đúc loại tự động

Không cho phép đúc kiểu tự động trong Rust. Hãy xem xét đoạn mã sau. Một giá trị số nguyên được gán cho biến floatinterest.

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

Trình biên dịch ném một mismatched types error như được đưa ra bên dưới.

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)

Dấu phân cách số

Để dễ đọc các số lớn, chúng ta có thể sử dụng dấu phân cách trực quan _ dấu gạch dưới để phân tách các chữ số. Đó là 50.000 có thể được viết là 50_000. Điều này được hiển thị trong ví dụ dưới đây.

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);
}

Đầu ra được đưa ra dưới đây -

float value 11000.555001
int value 50000

Boolean

Kiểu boolean có hai giá trị có thể có - đúng hoặc sai . Sử dụngbool từ khóa để khai báo một biến boolean.

Hình minh họa

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

Đầu ra của đoạn mã trên sẽ là:

Is Rust Programming Fun ? true

Tính cách

Kiểu dữ liệu ký tự trong Rust hỗ trợ số, bảng chữ cái, Unicode và các ký tự đặc biệt. Sử dụngchartừ khóa để khai báo một biến kiểu dữ liệu ký tự. Kiểu char của Rust đại diện cho Giá trị vô hướng Unicode, có nghĩa là nó có thể đại diện cho nhiều thứ hơn là chỉ ASCII. Giá trị vô hướng Unicode có phạm vi từU+0000 đến U+D7FF và U+E000 đến U+10FFFF bao gồm.

Chúng ta hãy xem xét một ví dụ để hiểu thêm về kiểu dữ liệu Ký tự.

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);
}

Đầu ra của đoạn mã trên sẽ là:

special character is @
alphabet is A
emoji is