函数

fn <函数名> ( <参数> ) <函数体>

Rust 函数名称的命名风格是小写字母以下划线分割

Rust 中定义函数如果需要具备参数必须声明参数名称和类型

函数体的语句和表达式

Rust 中可以在一个用 {} 包括的块里编写一个较为复杂的表达式：

fn main() {

 let x = 5;

 let y = {

 let x = 3;

x + 1

 };

    println!("x 的值为 : {}", x);

    println!("y 的值为 : {}", y);

}

运行结果：

x 的值为 : 5

y 的值为 : 4

很显然，这段程序中包含了一个表达式块：

{    let x = 3;    x + 1};

而且在块中可以使用函数语句，最后一个步骤是表达式，此表达式的结果值是整个表达式块所代表的值。这种表达式块叫做函数体表达式。

注意：x + 1 之后没有分号，否则它将变成一条语句！

要么 x+1没有分号 表示返回x+1 要么 return x+1；带分号 两个意思一样   即  x+1 等同于 return x+1；

函数返回值

在参数声明之后用 -> 来声明函数返回值的类型

在函数体中，随时都可以以 return 关键字结束函数运行并返回一个类型合适的值

条件语句

格式如下

fn test_if() {

    let a = 5;

    if a < 5 {

        println!("a < 5")

    }else if a > 5{

        println!("a > 5")

    }else{

        println!("a = 5")

    }

}

Rust 中的条件表达式必须是 bool 类型：这个和其他高级语言不太一样

如python a=10 if a 是一个正确的语句，但是在rust是语法错误

在 Rust 中我们可以使用 if-else 结构实现类似于三元条件运算表达式 (A ? B : C) 的效果：

fn main() {

 let a = 3;

 let number = if a > 0 { 1 } else { -1 };

    println!("number 为 {}", number);

}

循环语句

支持 while for loop 三种循环语句

Rust 语言有原生的无限循环结构 —— loop：

fn xh() {

    fn f1() {

        let a = [10, 20, 30, 40, 50];

        for i in a.iter() {

            println!("值为 : {}", i);

        }

    }

    fn f2() {

        let a = [10, 20, 30, 40, 50];

            for i in 0..a.len() {

                println!("a[{}] = {}", i, a[i]);

            }

    }

    fn f3() {

        let s = ['R', 'U', 'N', 'O', 'O', 'B'];

        let mut i = 0;

        loop {

            let ch = s[i];

            if ch == 'O' {

                break;

            }

            println!("\'{}\'", ch);

            i += 1;

        }

    }

    fn f4() {

        let mut number = 1;

        while number != 4 {

            println!("{}", number);

            number += 1;

        }

        println!("EXIT");

    }

    f1();

    f2();

    f3();

    f4();

}

所有权

所有权有以下三条规则

Rust 中的每个值都有一个变量，称为其所有者。

一次只能有一个所有者。

当所有者不在程序运行范围时，该值将被删除。

这三条规则是所有权概念的基础。

变量与数据交互的方式

变量与数据交互方式主要有移动（Move）和克隆（Clone）两种

当变量超出范围时，Rust 自动调用释放资源函数并清理该变量的堆内存。

移动

"基本数据"类型的数据，不需要存储到堆中，仅在栈中的数据的"移动"方式是直接复制，这不会花费更长的时间或更多的存储空间。"基本数据"类型有这些：

所有整数类型，例如 i32 、 u32 、 i64 等。

布尔类型 bool，值为 true 或 false 。

所有浮点类型，f32 和 f64。

字符类型 char。

仅包含以上类型数据的元组（Tuples）。

举例一

let x = 5;

let y = x;

这个程序将值 5 绑定到变量 x，然后将 x 的值复制并赋值给变量 y。现在栈中将有两个值 5。

举例二

let s1 = String::from("hello");

let s2 = s1;

println!("{}, world!", s1); // 错误！s1 已经失效

但是 s1 和 s2 都被释放的话堆区中的 "hello" 被释放两次，这是不被系统允许的。

为了确保安全，在给 s2 赋值时 s1 已经无效了。没错，在把 s1 的值赋给 s2 以后 s1 将不可以再被使用。下面这段程序是错的：

克隆

Rust会尽可能地降低程序的运行成本，所以默认情况下，长度较大的数据存放在堆中，且采用移动的方式进行数据交互。

但如果需要将数据单纯的复制一份以供他用，可以使用数据的第二种交互方式——克隆。

fn main() {

 let s1 = String::from("hello");

 let s2 = s1.clone();

    println!("s1 = {}, s2 = {}", s1, s2);

}

涉及函数的所有权机制

函数参数

将变量当作参数传入函数，那么它和移动的效果是一样的。

fn main() {

 let s = String::from("hello");

 // s 被声明有效

    takes_ownership(s);

 // s 的值被当作参数传入函数

 // 所以可以当作 s 已经被移动，从这里开始已经无效

 let x = 5;

 // x 被声明有效

    makes_copy(x);

 // x 的值被当作参数传入函数

 // 但 x 是基本类型，依然有效

 // 在这里依然可以使用 x 却不能使用 s

} // 函数结束, x 无效, 然后是 s. 但 s 已被移动, 所以不用被释放

fn takes_ownership(some_string: String) {

 // 一个 String 参数 some_string 传入，有效

    println!("{}", some_string);

} // 函数结束, 参数 some_string 在这里释放

fn makes_copy(some_integer: i32) {

 // 一个 i32 参数 some_integer 传入，有效

    println!("{}", some_integer);

} // 函数结束, 参数 some_integer 是基本类型, 无需释放

函数返回值

被当作函数返回值的变量所有权将会被移动出函数并返回到调用函数的地方，而不会直接被无效释放。

fn main() {

    let s1 = gives_ownership();

    // gives_ownership 移动它的返回值到 s1

    let s2 = String::from("hello");

    // s2 被声明有效

    let s3 = takes_and_gives_back(s2);

    // s2 被当作参数移动, s3 获得返回值所有权

} // s3 无效被释放, s2 被移动, s1 无效被释放.

fn gives_ownership() -> String {

    let some_string = String::from("hello");

    // some_string 被声明有效

    return some_string;

    // some_string 被当作返回值移动出函数

}

fn takes_and_gives_back(a_string: String) -> String { 

    // a_string 被声明有效

    a_string  // a_string 被当作返回值移出函数

}

引用与租借

如果你熟悉指针的概念，你可以把它看作一种指针。

引用不会获得值的所有权。

引用只能租借（Borrow）值的所有权。

引用本身也是一个类型并具有一个值，这个值记录的是别的值所在的位置，但引用不具有所指值的所有权：

fn main() {

    let s1 = String::from("hello");

    let s2 = &s1;

    let s3 = s1;

    println!("{}", s2);

}

这段程序不正确：因为 s2 租借的 s1 已经将所有权移动到 s3，所以 s2 将无法继续租借使用 s1 的所有权。如果需要使用 s2 使用该值，必须重新租借：

fn main() {

 let s1 = String::from("hello");

 let mut s2 = &s1;

 let s3 = s1;

s2 = &s3; // 重新从 s3 租借所有权

    println!("{}", s2);

}

既然引用不具有所有权，即使它租借了所有权，它也只享有使用权（这跟租房子是一个道理）。

fn main() {

    let s1 = String::from("run");

    let s2 = &s1;

    println!("{}", s2);

    s2.push_str("oob"); // 错误，禁止修改租借的值

    println!("{}", s2);

}

如果尝试利用租借来的权利来修改数据会被阻止：

这段程序中 s2 尝试修改 s1 的值被阻止，租借的所有权不能修改所有者的值。

当然，也存在一种可变的租借方式，就像你租一个房子，如果物业规定房主可以修改房子结构，房主在租借时也在合同中声明赋予你这种权利，你是可以重新装修房子的：

fn main() {

    let mut s1 = String::from("run");

    // s1 是可变的

    let s2 = &mut s1;

    // s2 是可变的引用

    s2.push_str("oob");

    println!("{}", s2);

}

这段程序就没有问题了。我们用 &mut 修饰可变的引用类型。

可变引用与不可变引用相比除了权限不同以外，可变引用不允许多重引用，但不可变引用可以：

let mut s = String::from("hello");

let r1 = &mut s;

let r2 = &mut s;

println!("{}, {}", r1, r2);

这段程序不正确，因为多重可变引用了 s。

Rust 对可变引用的这种设计主要出于对并发状态下发生数据访问碰撞的考虑，在编译阶段就避免了这种事情的发生。

由于发生数据访问碰撞的必要条件之一是数据被至少一个使用者写且同时被至少一个其他使用者读或写，所以在一个值被可变引用时不允许再次被任何引用。

垂悬引用

这是一个换了个名字的概念，如果放在有指针概念的编程语言里它就指的是那种没有实际指向一个真正能访问的数据的指针（注意，不一定是空指针，还有可能是已经释放的资源）。它们就像失去悬挂物体的绳子，所以叫"垂悬引用"。

"垂悬引用"在 Rust 语言里不允许出现，如果有，编译器会发现它。

下面是一个垂悬的典型案例：

实例

fn main() {

 let reference_to_nothing = dangle();

}

fn dangle() -> &String {

 let s = String::from("hello");

 &s

}

很显然，伴随着 dangle 函数的结束，其局部变量的值本身没有被当作返回值，被释放了。但它的引用却被返回，这个引用所指向的值已经不能确定的存在，故不允许其出现。

rust内存管理

Rust 区别与其他高级语言的重要特征，在于其内存管理的两个特点：

（1）变量超出作用域会自动释放。对于简单值类型的栈内存（如int，struct）超出作用域后自动释放，这个逻辑在各个语言都有实现。而对于 new 出来的堆内存，在c/c++中是要手动释放的，在java和dotnet中要委托垃圾回收释放或手动写 dispose 语句释放。而垃圾回收不是实时的，会影响性能。而释放语句总会有懒人忘记写的。而 Rust 对栈内存和堆内存一视同仁，超出作用域一律自动释放。Rust 的这个特点在兼顾性能的情况下、有效的减少了代码量和内存泄漏隐患。

（2） “所有权” ：某段内存只能被最后的变量名所有，前面声明过的变量都作废，这有效的避免被多个变量释放的问题，而且该操作是在编译期就可以检查到的，这策略可在编译期就能有效的避免空指针问题。

这部分对于所有权的设定，看起来很奇怪，其实本质上就是在语言层面禁止了同一个可变数据会有多个变量引用的情况，一旦作为参数传递了，就会发生所有权的移动（Move）或借用（Borrow）。赋值给另一个变更也就自动放弃了所有权。从根本上杜绝了并发情景下的数据共享冲突。