我们现在回过头来看看，一些基础知识。
因为理解了前面的重要概念：所有权，借用，生命周期。
我们现在看基础知识就很简单了。
先看变量定义：
let a = true;//rust不要求显式定义类型，编译器女王自动会根据上下文和用途，来自动定义类型，这里 //是：bool
let b: bool = true;//如果显式定义类型，则通过：分号+类型
?
let (x, y) = (1, 2);
?
let mut z = 5;
z = 6;
在rust，这些变量定义叫变量绑定。
为什么这样说？因为rust的变量，默认是不可变的。
如果，要变成可变变量，要用关键字：mut。
那如果是常量呢？
看代码：
常量(const)：
const N: i32 = 5;
静态变量(static)：
static N: i32 = 5;
常量与静态变量的区别是：
1.常量const在内存没有固定地址，而静态变量static的地址是固定的。
2.静态变量一般用在全局变量，一般写在代码最上方，在函数体外，常量可以定义在函数内。
3.一般最好用const来定义常量，因为它地址不是固定的，可以让编译器优化。
布尔值(bool)：
let x = true;
let y: bool = false;
?
// ?? no TRUE, FALSE, 1, 0
字符（char）：
let x = ‘x‘;
let y = ‘??‘;
?
// ?? no "x", only single quotes
布尔值，类型关键字：bool，值：true 或者false,注意是小写。
字符类型，用的是单引号。因为rust是从底层支持unicode,所以char占位4 byte。
数组（arrays）：
let a = [1, 2, 3]; // a[0] = 1, a[1] = 2, a[2] = 3
let mut b = [1, 2, 3];
?
let c: [i32; 0] = []; //[Type; NO of elements] -> [] /empty array
let d: [i32; 3] = [1, 2, 3];
?
let e = ["my value"; 3]; //["my value", "my value", "my value"];
?
println!("{:?}", a); //[1, 2, 3]
println!("{:#?}", a);
数组主要用来存放相同类型的数据，它的长度是固定的，也是默认不可变的（长度和内容都不可变）。如果，用mut来定义，它的长度也是不可变的，但数组内的数据可以变。
如果我想缓存一些不同类型的数据，怎么办？
用元组（tuples）：
let a = (1, 1.5, true, ‘a‘, "Hello, world!");
// a.0 = 1, a.1 = 1.5, a.2 = true, a.3 = ‘a‘, a.4 = "Hello, world!"
?
let b: (i32, f64) = (1, 1.5);
?
let (c, d) = b; // c = 1, d = 1.5
let (e, _, _, _, f) = a; //e = 1, f = "Hello, world!", _ indicates not interested of that item
?
let g = (0,); //single-element tuple
?
let h = (b, (2, 4), 5); //((1, 1.5), (2, 4), 5)
?
println!("{:?}", a); //(1, 1.5, true, ‘a‘, "Hello, world!")
元组主要用来存放不同类型的数据，它的长度是固定的，也是默认不可变的（长度和内容都不可变）。如果，用mut来定义，它的长度也是不可变的，数组内的数据可以变，但变化的值与之前的值的类型要保持一致。
切片（slice）：
let a: [i32; 4] = [1, 2, 3, 4];//Parent Array
?
let b: &[i32] = &a; //Slicing whole array
let c = &a[0..4]; // From 0th position to 4th(excluding)
let d = &a[..]; //Slicing whole array
?
let e = &a[1..3]; //[2, 3]
let f = &a[1..]; //[2, 3, 4]
let g = &a[..3]; //[1, 2, 3]
切片，要rust中来说，就是其他数据结构（主要是数组）的可变长度的引用或视图。
字符串（str）：
let a = "Hello, world."; //a: &‘static str
let b: &str = "你好, 世界!";
在rust,str类型准确来说，是字符串切片。是最基本的字符串类型。
我们来看看下面两种写法是一样的：
let hello = "Hello, world!";
?
// with an explicit type annotation
let hello: &‘static str = "Hello, world!";
我们看到，hello变量的生命周期注解是：‘static，说明它的生命周期是跟整个程序的生命周期一样。
它是借用类型:&str，说明它是从字符串 "Hello, world!"，借用过来的。
当然它还有一种写法：
let hello = String::from("Hello, world!");
let mut hello = String::from("Hello, ");
?
hello.push(‘w‘);
hello.push_str("orld!");
这里直接用方法： String::from() 来构建。
一般来说，
如果你相拥有所有权（ownership）,就用String定义；
如果想直接借用(没有所有权，有借就要有还)，就用&str;
注意：
以上，希望对你有用。
如果遇到什么问题，欢迎加入：rust新手群，在这里我可以提供一些简单的帮助，加微信：360369487，注明：博客园+rust
[易学易懂系列|rustlang语言|零基础|快速入门|（6）]
原文：https://www.cnblogs.com/gyc567/p/11925859.html