关于rust:rust学习用向量vectors存储值列表

向量使咱们能够在单个数据结构中存储多个值，该构造将所有值彼此相邻搁置在内存中。向量只能存储雷同类型的值。当咱们具备我的项目列表时，例如文件中的文本行或购物车中我的项目的价格时，它们很有用。

新建一个 vector

fn main() {let v: Vec<i32> = Vec::new();
    println!("{:?}", v)
}
D:\learn\cargo_learn>cargo run
   Compiling cargo_learn v0.1.0 (D:\learn\cargo_learn)
    Finished dev [unoptimized + debuginfo] target(s) in 1.06s
     Running `target\debug\cargo_learn.exe`
[]

能够看到其实 vector 就是一个数组，只不过有一个要求就是数组中的每一个元素必须具备雷同的类型，上面创立一个实在的实例：

fn main() {let v = vec![1, 2, 3];
    println!("{:?}", v);
}
D:\learn\cargo_learn>cargo run
   Compiling cargo_learn v0.1.0 (D:\learn\cargo_learn)
    Finished dev [unoptimized + debuginfo] target(s) in 0.52s
     Running `target\debug\cargo_learn.exe`
[1, 2, 3]

如果不必雷同类型的数据会怎么呢？

fn main() {let v = vec![1, 2.1, 3];
    println!("{:?}", v);
}

D:\learn\cargo_learn>cargo run
   Compiling cargo_learn v0.1.0 (D:\learn\cargo_learn)
error[E0308]: mismatched types
 --> src\main.rs:2:21
  |
2 |     let v = vec![1, 2.1, 3];
  |                     ^^^ expected integer, found floating-point number

error: aborting due to previous error

For more information about this error, try `rustc --explain E0308`.
error: could not compile `cargo_learn`.

To learn more, run the command again with --verbose.

更新一个向量
在 rust 中不论更新任何变量，其必须是可变的

fn main() {let mut v = Vec::new();

    v.push(5);
    v.push(6);
    v.push(7);
    v.push(8);
    println!("{:?}", v)
}
D:\learn\cargo_learn>cargo run
   Compiling cargo_learn v0.1.0 (D:\learn\cargo_learn)
    Finished dev [unoptimized + debuginfo] target(s) in 0.57s
     Running `target\debug\cargo_learn.exe`
[5, 6, 7, 8]

能够看出跟 js 中的数组没有任何区别，至多在应用 push 办法上~~

删除一个向量

与 rust 中的一般变量一样，向量也是一个变量，在超出其作用域之后会被主动清理，例如：

fn main() {
    {let v = vec![1, 2, 3, 4];

        // 在此能够用 v 做任何想做且能做的事件
    } // <- v 超出范围并在此处开释
}

读取向量中的元素

有两种形式获取向量中的元素：应用索引和应用 get 办法:

fn main() {let v = vec![1, 2, 3, 4, 5];

    let third: &i32 = &v[2];
    println!("第三个元素是：{}", third);

    match v.get(2) {Some(third) => println!("第三个元素是：{}", third),
        None => println!("第三个元素不存在"),
    }
}

D:\learn\cargo_learn>cargo run
   Compiling cargo_learn v0.1.0 (D:\learn\cargo_learn)
    Finished dev [unoptimized + debuginfo] target(s) in 0.52s
     Running `target\debug\cargo_learn.exe`
第三个元素是：3
第三个元素是：3

间接应用索引值的话，如果索引值超出了向量的长度范畴（0 ~ 长度 -1），会导致编译或者运行出错，应用 get 办法能够平安的获取元素与捕捉异样。

应用 get 办法能够简略一点，比方：

 let does_not_exist = v.get(100);

 println!("{:?}", does_not_exist);

此时，如果索引超出了向量能够被索引的范畴的话会返回None

有意思的是如果略微不留神仍旧会碰到所有权的景象：

fn main() {let mut v = vec![1, 2, 3, 4, 5];

    let first = &v[0];

    v.push(6);

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

D:\learn\cargo_learn>cargo run
   Compiling cargo_learn v0.1.0 (D:\learn\cargo_learn)
error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable
 --> src\main.rs:6:5
  |
4 |     let first = &v[0];
  |                  - immutable borrow occurs here
5 | 
6 |     v.push(6);
  |     ^^^^^^^^^ mutable borrow occurs here
7 | 
8 |     println!("The first element is: {}", first);
  |                                          ----- immutable borrow later used here

error: aborting due to previous error

For more information about this error, try `rustc --explain E0502`.
error: could not compile `cargo_learn`.

To learn more, run the command again with --verbose.

遍历向量中的值

1、一般遍历，并打印出向量中的所有值

fn main() {let v = vec![100, 32, 57];
    for i in &v {println!("{}", i);
    }
}

2、遍历并依照肯定规定扭转向量中的值

fn main() {let mut v = vec![100, 32, 57];
    for i in &mut v {*i += 50;}
}

要更改可变援用所援用的值，必须先应用解援用运算符（*）来获取 i 中的值，而后能力应用 + = 运算符。

应用枚举存储多种类型
在 rust 中枚举的变体是在雷同的枚举类型下定义的，因而当咱们须要在向量中存储不同类型的元素时，咱们能够定义和应用枚举！例如：

fn main() {#[derive(Debug)]
    enum SpreadsheetCell {Int(i32),
        Float(f64),
        Text(String),
    }

    let row = vec![SpreadsheetCell::Int(3),
        SpreadsheetCell::Text(String::from("blue")),
        SpreadsheetCell::Float(10.12),
    ];

    println!("{:?}", row)
}

D:\learn\cargo_learn>cargo run
   Compiling cargo_learn v0.1.0 (D:\learn\cargo_learn)
    Finished dev [unoptimized + debuginfo] target(s) in 0.63s
     Running `target\debug\cargo_learn.exe`
[Int(3), Text("blue"), Float(10.12)]

也能够了解为使其可行的起因是：将枚举当做了一种类型存储在向量中