u32,this type declaration indicates that the value it’s associated with should be an unsigned integer (signed integer types start with i, instead of u) that takes up 32 bits of space. 

Additionally, the isize and usize types depend on the kind of computer your program is running on: 64 bits if you’re on a 64-bit architecture and 32 bits if you’re on a 32-bit architecture.

Let’s say that you have a u8, which can hold values between zero and 255. What happens if you try to change it to 256? This is called “integer overflow,” and Rust has some interesting rules around this behavior. When compiling in debug mode, Rust checks for this kind of issue and will cause your program to panic, which is the term Rust uses when a program exits with an error. 

In release builds, Rust does not check for overflow, and instead will do something called “two’s complement wrapping.” In short, 256 becomes 0, 257 becomes 1, etc. Relying on overflow is considered an error, even if this behavior happens. If you want this behavior explicitly, the standard library has a type, Wrapping, that provides it explicitly.

fn main() {
    let x = 64.0 ; //f64
    let y: f32 = 32.0; //f32
    println!("64:{},32:{}",x,y);
}

The f32 type is a single-precision float, and f64 has double precision.

fn main() {
    // addition
    let _sum = 5 + 10;

    // subtraction
    let _difference = 95.5 - 4.3;

    // multiplication
    let _product = 4 * 30;

    // division
    let _quotient = 56.7 / 32.2; //1.7608695652173911 小数点后16位
    let _ff32 = 7f32 / 3f32;   //2.3333333  7位小数

    // remainder
    let _remainder = 13 % 5;  //3
    println!{"32位除法:{}",_ff32}
    println!{"默认64位除法：{}",_quotient};
    println!{"求余：{}",_remainder};
}

fn main() {
    let _t = true;
    let _f: bool = false; // with explicit type annotation
}

fn main() {
    let _a = 'z';
    let _b = 'ℤ';
    let _c = 'Z';
}

 Rust’s char type represents a Unicode Scalar Value, which means it can represent a lot more than just ASCII. Accented letters; Chinese, Japanese, and Korean characters; emoji; and zero-width spaces are all valid char values in Rust. Unicode Scalar Values range from U+0000 to U+D7FF and U+E000 to U+10FFFF inclusive. However, a “character” isn’t really a concept in Unicode, so your human intuition for what a “character” is may not match up with what a char is in Rust.

fn main() {
    let _tup: (i32, f64, u8) = (500, 6.4, 1);
    let _aa = (1,2.3,"wa ka ka ");
    let (_x,_y,_z) = _aa;
    println!("The value of z is:{}",_z)
}

This program first creates a tuple and binds it to the variable tup. It then uses a pattern with let to take tup and turn it into three separate variables, x, y, and z. This is called destructuring, because it breaks the single tuple into three parts. 

 In addition to destructuring through pattern matching, we can access a tuple element directly by using a period (.) followed by the index of the value we want to access. 

fn main() {
    let _x: (i32, f64, u8) = (500, 6.4, 1);
    let _five_hundred = _x.0;
    let _six_point_four =_x.1;
    let _one = _x.2;
    println!("第三个元素:{}",_one);
}

fn main() {
    let _a = [1, 2, 3, 4, 5];
}

fn main() {
    let _a = [1, 2, 3, 4, 5];
    let _months = ["January", "February", "March", "April", "May", "June", "July",
              "August", "September", "October", "November", "December"];
}

fn main() {
    let _b: [i32; 5] = [1, 2, 3, 4, 5];
}

fn main() {
    let _b: [i32; 5] = [1, 2, 3, 4, 5];
    let _c1 = _b[0];
    let _c2 = _b[1];
}

fn main() {
    let a = [1, 2, 3, 4, 5];
    let index = 10;

    let element = a[index];

    println!("The value of element is: {}", element);
}

[root@itoracle src]# cargo build
   Compiling datatype v0.1.0 (/usr/local/automng/src/rust/test/datatype)                                                 
    Finished dev [unoptimized + debuginfo] target(s) in 1.39s                                                            
[root@itoracle src]# cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.01s                                                            
     Running `/usr/local/automng/src/rust/test/datatype/target/debug/datatype`
thread 'main' panicked at 'index out of bounds: the len is 5 but the index is 10', src/main.rs:5:19
note: Run with `RUST_BACKTRACE=1` for a backtrace.

pub fn test_for(){
    let aa = [1,2,3,4,5];
    let mut index = 0;
    for bb in aa.iter() {
        println!("{}:{}",index,bb);
        index = index +1;
    }
}

pub fn test_for2(){
    let aa = [1,2,3,4,5];
    for (index,&bb) in aa.iter().enumerate() {
        println!("{}:{}",index,bb);
    }
}

pub fn test() {

    let buffer = [0; 1024];
    for (idx, &val) in buffer.iter().enumerate(){
        println!("{}:{}",idx,val);
    }
}

......
......
......
1015:0
1016:0
1017:0
1018:0
1019:0
1020:0
1021:0
1022:0
1023:0

fn data02(){
    println!("-------显式类型转换-------");
    let a = 1;
    let b = a as f64;
    let c = b * 2.0;
    println!("c={}",c);  //c=2
    println!("-------------------------------------------------------");
}

let guess: u32 = "42".parse().expect("Not a number!");