CHANGELOG

2021.7.7 create the project
chapter 1
///关于变量
fn main()
{
    let x = 13;//由rust本身进行推断
    let mut x = 13;//当使用 mut 为关键字时,变量x为可变的
    println!("{}",x);

    let x:f64 = 3.14159;//给出声明和定义
    println!("{}");

    let x；//很少使用
    x = 0;
    println("{}",x);
}

///关于基本类型:
  bool型；true false;
  无符号整型：u８~u128;
  有符号整型：i８~i128;
  指针大小的整型：usize isize;
  浮点数：f32 f64;
  元组：t = (value,value,...) 取值时t.0 t.1 ...;
  数组：相同类型数据元素的固定长度集合,[T,N]中，
  　　　T是元素的类型，
  　　　N是编译时已知的固定长度
  
  str:
fn main()
{
    let a1 = 12; //默认i32
    let a2 = 12u8; //
    let b1 = 4.3; //默认f64
    let b2 = 4.3f32; //
    let br = true; //
    let t = (13,false); //元组
    let sentence = "hello world!"; //
    let nums: [i32;3] = [1,2,3];//println!("{:?},nums); ->[1,2,3]
                                //println!("{}",nums[1]); -> 2

    fn zhuanhuan() ///关键字　as 起作用
    {
    　 　let a = 13u8;
        let b = 7u32;
        let c = a as u32 + b;
        println!("{}", c);

        let t = true;
        println!("{}", t as u8);
}
} 

///关于常量
  起名遵循全大写蛇形命名法(SCREAMING_SNAKE_CASE)
｛
    const PI: f32 = 3.14159;

    fn main() 
    {
        println!("make an apple {} from scratch.",PI);
    }
｝

///关于函数(类似于ｃ语言)
    //函数名遵循蛇形命名法(snake_case)
    {
        fn add(x:i32,y:i32) -> i32
        {
            return x+y;
        }
        fn main()
        {
            println!("{}",add(42,13));
        }
    }
    //通过元组来实现多个返回值
    {
        fn swap(x: i32, y: i32) -> (i32, i32) 
        {
            return (y, x);
        }

        fn main()
        {
            let result = swap(123, 321);
            println!("{} {}", result.0, result.1);

            let (a, b) = swap(result.0, result.1);
            println!("{} {}", a, b);
        }
    }
    //通过返回空的元组来返回空值，即()
    {
        fn make_nothing1() -> () 
        {
        return ();
        }

        fn make_nothing2() 
        {
        }

        fn main()
        {
            let a = make_nothing1();
            let b = make_nothing2();

            println!("The value of a: {:?}", a);
            println!("The value of b: {:?}", b);  
        }
        //不论函数中是否规定返回值，最终输出结果都是()
    }

chapter 2 分支控制
///if/else if/else
  与ｃ语言相区别，判断条件不需要括号
  if x < 42{...}else if x == 42{...}

///循环
  //break和loop
{
    fn main()
    {
        let mut x = 0;
        loop
        {
            x += 1;
            if x == 42
            {
                break;
            }
        }
        println!("{}",x);
    }
}

  //while:向循环添加条件
{
    fn main()
    {
        let mut x = 0;
        while x != 42;
        {
            x += 1;
        }
    }
}

 ***//for:
           //.. 运算符创建一个可以生成包含起始数字、但不包含末尾数字的数字序列的迭代器。
           //..=运算符创建一个可以生成包含起始数字、且包含末尾数字的数字序列的迭代器。
{
    fn main()
    {
        for x in 0..5
        {
            println!("{}",x); -> 0 1 2 3 4 
        }
        for x in 0..=5
        {
            println!("{}",x); -> 0 1 2 3 4 5
        }
    }
}

  //match:类比于ｃ语言中的switch
{
    fn main()
    {
        let x = 42;

        match x
        {
            //匹配值
            0 => {println!("found zero");}
            1 | 2 => {println!("found 1 or 2");} 
            //匹配迭代器
            3..=9 => {println!("found 3 to 9");} 
            //将匹配数值绑定到变量
            matched_num @ 10..=100 => {println!(found {} number between 10 to 100!",matched_num);} 
            //默认匹配，在没有处理所有情况时，必须存在该匹配
            _ => {println!("found something else!")}
        }
    }
    //结果为　-> found 42 number between 10 to 100!
}
  
  //从循环中返回值
  　loop可以被中断以返回一个值。
{
    fn main()
    {
        let mut x = 0;
        let v = loop 
        {
            x += 1;
            if x == 13 
            {
                break "found the 13";
            }
        };
    println!("from loop: {}", v);
    }
}

  //从块表达式返回值
    if,match,函数，以及作用域块都有一种返回值的独特方式。
    如果if、match、函数或作用域块中的最后一条语句是不带;的表达式，Rust将把它作为一个值从块中返回（它返回一个可以放入新变量的值）
{    
    fn example() -> i32
    {
        let x = 42;
        // Rust的三元表达式
        let v = if x < 42 { -1 } else { 1 };
        println!("from if: {}", v);                              //->from if: 1

        let food = "hamburger";
        let result = match food 
        {
            "hotdog" => "is hotdog",
            // 注意，当它只是一个返回表达式时，大括号是可选的
            _ => "is not hotdog",
        };
        println!("identifying food: {}", result);                //->identifying food: is not hotdog

     ***let v = 
        {
            // 这个作用域块让我们得到一个不影响函数作用域的结果
            let a = 1;
            let b = 2;
            a + b
        };
        println!("from block: {}", v);                          //->from block: 3

        // 在最后从函数中返回值的惯用方法
        v + 4                                                   
    }

    fn main()
    {
        println!("from function: {}",example());               //->from function: 7
    }
}

chapter 3 基本数据结构类型
///结构体（名称：类型）
struct SeaCreature{
                    animal_type:String,
                    age:i32
                  }

***///方法调用
   方法（method）是与特定数据类型关联的函数
   静态方法 — 属于某个类型，调用时使用 :: 运算符
   实例方法 — 属于某个类型的实例，调用时使用 . 运算符
fn main() 
{
    let s = String::from("Hello world!");// 使用静态方法来创建一个String实例
    println!("{} is {} characters long.", s, s.len());// 使用实例来调用方法
}