无涯教程-Rust - 数据类型

Rust是一种静态类型的语言，Rust中的每个值都需要指定某种数据类型，编译器也可以根据分配给它的值自动推断变量的数据类型。

声明变量

使用 let 关键字声明一个变量。

fn main() {
   let company_string="LearnFk";  //字符串类型
   let rating_float=4.5;                 //浮点类型
   let is_growing_boolean=true;          //布尔类型
   let icon_char='♥';                    //unicode 字符类型

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

在上面的示例中，将从分配给它们的值中推断出变量的数据类型。如Rust将字符串数据类型分配给变量 company_string ，将浮点数据类型分配给 rating_float

println!宏带有两个参数-

特殊语法 {} ,它是占位符
变量名或常量

占位符将替换为变量的值，上面的代码片段的输出将是-

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

标量类型

标量类型表示单个值。如10，3.14，'c'，Rust具有四种主要的标量类型。

Integer 整数类型
Floating-point 浮点类型
Booleans 布尔类型
Characters 字符类型

我们将在后续部分中了解每种类型。

整数类型

整数是没有小数部分的数字，简而言之，整数数据类型用于表示整数。

整数可以进一步分为有符号和无符号，有符号整数可以存储负值和正值，无符号整数只能存储正值。

fn main() {
   let result=10;    //默认为 i32
   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);
}

输出将如下所示-

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

如果将 age 的值替换为浮点值，则以上代码将返回编译错误。

整数范围

每个有符号的值范围从-(2 ^(n-1)到2 ^(n-1)-1 的数字，其中n是位数，存储从-(2 ^ 7)到2 ^ 7 -1 的数字，在这里 n 替换为8。

每个无符号变体可以存储从 0 到 2 ^(n-1)的数字，如，u8可以存储从 0 到 2 ^ 7 的数字，该数字等于0到255。

整数溢出

当分配给整数变量的值超出数据类型的Rust定义范围时，将发生整数溢出。让我们通过一个示例来理解这一点-

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

   //0 到 255 只允许 u8
   let weight:u8=256;   //溢出值为0
   let height:u8=257;   //溢出值为 1
   let score:u8=258;    //溢出值为 2

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

无符号u8变量的有效范围是0到255，在上面的示例中，为变量分配的值大于255，在执行时，以上代码将返回警告- 警告-u8超出范围的值范围，溢出值将从0、1、2等开始，最终输出如下所示-

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

浮点类型

Rust中的浮动数据类型可以分为 f32 和 f64，f32类型是单精度浮点，而f64具有双精度，默认类型为f64，考虑以下示例，以了解有关float数据类型的更多信息。

fn main() {
   let result=10.00;        //默认为 f64
   let interest:f32=8.35;
   let cost:f64=15000.600;  //双精度
   
   println!("result value is {}",result);
   println!("interest is {}",interest);
   println!("cost is {}",cost);
}

输出将如下所示-

interest is 8.35
cost is 15000.6

自动类型转换

Rust不允许自动类型转换，考虑以下代码片段。整数值分配给浮点变量整数。

fn main() {
   let interest:f32=8;   //分配给浮点变量的整数
   println!("interest is {}",interest);
}

编译器将引发不匹配的类型错误，如下所示。

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)

数字分隔符

为了易于阅读数字，我们可以使用视觉分隔符_下划线分隔数字，那50，000可以写成50_000。在下面的示例中显示。

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

输出如下-

float value 11000.555001
int value 50000

布尔类型

布尔类型有两个可能的值– true或false，使用bool关键字声明一个布尔变量。

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

上面的代码输出将是-

Is Rust Programming Fun ? true

字符类型

Rust中的字符数据类型支持数字，字母，Unicode和特殊字符，使用 char 关键字声明字符数据类型的变量， Rust的char类型表示Unicode值，这意味着它可以表示的不仅仅是ASCII， Unicode标量值的范围从 U + 0000 到 U + D7FF 和 U + E000 到 U + 10FFFF (含)。

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