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

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`

操作符

运算符（操作符）定义了对于数据的的处理。被运算符所作用的数据被称为运算数。

算数运算法

加 +
减 -
乘 *
除 /
取余 %

操作运算符

> 大于
<小于
>= 大于等于
<= 小于等于
== 等于
!= 不等于

逻辑运算符

&& 与
|| 或
! 非

位运算符

& （按位与）
|（按位或）
^（按位异或）
!（按位非）
<<（左移）
>>（右移）
>>>（无符号右移）