Rust变量与数据类型
Rust 是一种静态类型的语言。 Rust 中的每个值都是某种数据类型。 编译器可以根据分配给它的值自动推断变量的数据类型。
let
使用let关键字声明变量
fn main() {
println!("Rust基础语法!");
let str_ = "String"; // string 类型
let f_ = 1.1; // float 类型
let bool_ = true; // boolean 类型
let char_ = 'a'; // unicode character
println!("string {}",str_);
println!("float {}",f_);
println!("boolean {}",bool_);
println!("icon {}",char_);
}
- Console
Rust基础语法!
string String
float 1.1
boolean true
icon a
println!
打印控制台方法
#[macro_export]
#[stable(feature = "rust1", since = "1.0.0")]
#[allow_internal_unstable(print_internals, format_args_nl)]
macro_rules! println {
() => ($crate::print!("\n"));
($($arg:tt)*) => ({
$crate::io::_print($crate::format_args_nl!($($arg)*));
})
}
- 一个参数是占位符 { },特别的语法
- 一个参数是变量或者常量
scalar Types
Rust有四种标量类型 整型、浮点型、布尔型、字符型
整型
整型是指没有小数部分的数字。也就是说,整型是用于表示整数的。整型可以进一步分为有符号(Signed)与无符号(Unsigned)的。可以存储正负值。
大小 | 有符号Signed | 无符号Unsigned | |
---|---|---|---|
8bit | i8 | u8 | |
16bit | i16 | u16 | |
32bit | i32 | u32 | |
64bit | i64 | u64 | |
128bit | i128 | u128 | |
arch | issize | Size |
案例
let result = 1; // 默认类型为i32
let u20:u32 = 20;
let i32:i32 = -15;
let s:isize = 10;
let count:usize = 30;
println!("result value is {}",result);
println!("u20 is {} i32 is {}",u20,i32);
println!("mark is {} and count is {}",s,count);
- Console
result value is 1
u20 is 20 i32 is -15
mark is 10 and count is 30
整型溢出
当分配给整型变量的值超出该整型在 Rust 中定义值的范围时,就会发生整型溢出
案例
let u1:u8 = 255;
// u8数据范围为0~255
let u2:u8 = 256; //溢出值为 1
let u3:u8 = 257; //溢出值为 2
let u4:u8 = 258; //溢出值为 3
println!("1 is {} ",u1);
println!("2 is {}",u2);
println!("3 is {}",u3);
println!("4 is {}",u4);
- Console
error: literal out of range for `u8`
--> src/main.rs:24:16
|
24 | let u2:u8 = 256; //溢出值为 1
| ^^^
|
= note: `#[deny(overflowing_literals)]` on by default
= note: the literal `256` does not fit into the type `u8` whose range is `0..=255`
error: literal out of range for `u8`
--> src/main.rs:25:16
|
25 | let u3:u8 = 257; //溢出值为 2
| ^^^
|
= note: the literal `257` does not fit into the type `u8` whose range is `0..=255`
error: literal out of range for `u8`
--> src/main.rs:26:16
|
26 | let u4:u8 = 258; //溢出值为 3
| ^^^
|
= note: the literal `258` does not fit into the type `u8` whose range is `0..=255`
error: could not compile `learning-02` due to 3 previous errors
- Rust的提示非常棒
浮点型
Rust 中的浮点型可被分为 f32 和 f64。f32 是单精度浮点型,f64 是双精度浮点型。默认浮点型为 f64。
案例
let f1 = 10.00; //默认为 f64 浮点型
let f2:f32 = 8.35;
let f3:f64 = 15000.600; //双精度浮点型
println!("f1 value is {}",f1);
println!("f2 is {}",f2);
println!("f3 is {}",f3);
- Console
f1 value is 10
f2 is 8.35
f3 is 15000.6
自动类型转换
Rust 中不支持自动类型转换
案例
let interest:f32 = 8; // 浮点型变量被赋予整型值
println!("interest is {}",interest);
- Console
error[E0308]: mismatched types
--> src/main.rs:41:23
|
41 | let interest:f32 = 8; // 浮点型变量被赋予整型值
| --- ^
| | |
| | expected `f32`, found integer
| | help: use a float literal: `8.0`
| expected due to this
布尔值
布尔型有两种可能的值 ——true 或是 false。使用 bool 关键字可以声明布尔型变量。
案例
let b:bool = true;
println!("boolean {}",b);
- Console
boolean true
字符型
Rust 中的字符型支持数字,字母,Unicode 和特殊字符。使用 char 关键字可以声明字符型变量。Rust 中的字符型用 Unicode 标量值储存,即 Rust 中的字符型可以表示比 ASCII 更多的字符。Unicode 标量值的范围包括从 U+0000 到 U+D7FF 和从 U+E000 到 U+10FFFF。
案例
let def_c = '@'; //默认为字符型
let c:char = 'Z';
let emoji:char = '😁';
- Console
character is @
alphabet is Z
emoji is 😁
类型转字符串
to_String()
案例
let x: u32 = 10;
let s: String = x.to_string();
println!("{}", s);
- Console
10
let变量
变量是程序可以操纵的命名存储
必须以字母或下划线开头。
变量的名称可以由字母,数字和下划线字符组成。
Rust区分大小写
不可变性
- 变量默认是不可变的,只读的。也就是说,变量的值在初始化后不可再被改变。比如
let var = 25_000;
println!("var is {} ",var);
var = 35_000;
println!("var changed is {}",var);
Console
--> src/main.rs:57:5
|
55 | let var = 25_000;
| ---
| |
| first assignment to `var`
| help: consider making this binding mutable: `mut var`
56 | println!("var is {} ",var);
57 | var = 35_000;
| ^^^^^^^^^^^^ cannot assign twice to immutable variable
- 可变性
- 在变量名前加上 mut 关键字可以使其可变。可变变量的值可以更改。
let mut var = 25_000;
println!("var is {} ",var);
var = 35_000;
println!("var changed is {}",var);
Console
var is 25000
var changed is 35000
const常量
常量一定要显式声明它的数据类型。以下是声明常量的语法:
- 而声明常量时一定要声明它的数据类型。
const VARIABLE_NAME:dataType = value;
- 使用 let 关键字声明的变量默认是不可变的。但是你可以选择使用 mut 关键字来使其可变。常量则
永远是不可变的
。 - 常量可以在任何范围内声明,包括全局范围。
案例
const VAR_NAME:char = 'A';
println!("VAR_NAME is {}",VAR_NAME);
- Console
VAR_NAME is A
shadowing 覆盖
Rust 支持不同数据类型的变量之间的覆盖(隐藏 shadowing)。
- 变量可以被覆盖,常量不行。
案例一
let salary = 100.00;
let salary = 1.50 ;
// 读取salary变量的值
println!("The value of salary is :{}",salary);
- Console
The value of salary is :1.5
案例二
const salary2 = 100.00;
let salary2 = 1.50 ;
// 读取salary变量的值
println!("The value of salary is :{}",salary2);
- Console
--> src/main.rs:68:11
|
68 | const salary2 = 100.00;
| ^^^^^^^ help: provide a type for the constant: `salary2: f64`
操作符
运算符(操作符)定义了对于数据的的处理。被运算符所作用的数据被称为运算数。
算数运算法
- 加 +
- 减 -
- 乘 *
- 除 /
- 取余 %
操作运算符
>
大于<
小于>=
大于等于<=
小于等于==
等于!=
不等于
逻辑运算符
&&
与||
或!
非
位运算符
- & (按位与)
- |(按位或)
- ^(按位异或)
- !(按位非)
- <<(左移)
- >>(右移)
- >>>(无符号右移)