Rust é uma linguagem de programação em nível de sistema projetada para ser segura, simultânea e eficiente. Inspirado em linguagens como C++, Rust e Haskell, o Rust é caracterizado pela digitação estática, segurança de memória, simultaneidade e alto desempenho.
Padrão é uma característica na biblioteca padrão do Rust que define um valor padrão para um tipo. No Rust, cada tipo possui um valor padrão, que pode ser obtido através do traço Default. O valor padrão do Rust é o valor zero, ou seja, se um tipo não define seu valor padrão, então seu valor padrão é 0 ou nulo.
Uso básico
Use o traço padrão para obter o valor padrão de um tipo
No Rust, você pode usar o traço Padrão para obter um valor padrão para um tipo. Por exemplo, o código a seguir demonstra como obter o valor padrão de um tipo inteiro:
fn main() {
let x: i32 = Default::default();
println!("The default value of i32 is {}", x);
}
复制代码A saída é:
The default value of i32 is 0
复制代码Valores padrão para tipos personalizados
No Rust, você pode implementar o trait Padrão para tipos personalizados para definir valores padrão para eles. Por exemplo, o código a seguir demonstra como implementar o atributo Default para um tipo struct:
#[derive(Default)]
struct Point {
x: i32,
y: i32,
}
fn main() {
let p: Point = Default::default();
println!("The default value of Point is ({}, {})", p.x, p.y);
}
复制代码A saída é:
The default value of Point is (0, 0)
复制代码Usando genéricos para obter o valor padrão de um tipo
No Rust, os genéricos podem ser usados para obter valores padrão de tipos arbitrários. Por exemplo, o código a seguir demonstra como usar genéricos para obter um valor padrão do tipo String:
fn main() {
let s: String = Default::default();
println!("The default value of String is '{}'", s);
}
复制代码A saída é:
The default value of String is ''
复制代码Use o tipo de opção para obter o valor padrão
No Rust, o tipo Option é um tipo enumerado que pode representar a presença ou ausência de um valor. Se uma variável for do tipo Option, seu valor padrão será None. Por exemplo, o código a seguir demonstra como obter o valor padrão de um tipo de opção:
fn main() {
let opt: Option<i32> = Default::default();
println!("The default value of Option<i32> is {:?}", opt);
}
复制代码A saída é:
The default value of Option<i32> is None
复制代码Use o tipo de matriz para obter o valor padrão
No Rust, o valor padrão de um tipo de array é um array de valores zero. Por exemplo, o código a seguir demonstra como obter o valor padrão de um tipo de matriz:
fn main() {
let arr: [i32; 3] = Default::default();
println!("The default value of [i32; 3] is {:?}", arr);
}
复制代码A saída é:
The default value of [i32; 3] is [0, 0, 0]
复制代码Use o tipo de tupla para obter o valor padrão
No Rust, o valor padrão para um tipo de tupla é uma tupla que consiste no valor padrão para cada elemento. Por exemplo, o código a seguir demonstra como obter o valor padrão de um tipo de tupla:
fn main() {
let tup: (i32, bool, String) = Default::default();
println!("The default value of (i32, bool, String) is {:?}", tup);
}
复制代码A saída é:
The default value of (i32, bool, String) is (0, false, '')
复制代码Use o tipo enum para obter o valor padrão
No Rust, o valor padrão de um tipo de enumeração é seu primeiro membro. Por exemplo, o código a seguir demonstra como obter o valor padrão de um tipo enum:
enum Color {
Red,
Green,
Blue,
}
fn main() {
let color: Color = Default::default();
println!("The default value of Color is {:?}", color);
}
复制代码A saída é:
The default value of Color is Red
复制代码使用结构体获取默认值
在 Rust 中，结构体类型的默认值是由每个字段的默认值组成的结构体。例如，以下代码演示了如何获取一个结构体类型的默认值：
struct Person {
name: String,
age: i32,
is_male: bool,
}
impl Default for Person {
fn default() -> Self {
Self {
name: String::default(),
age: i32::default(),
is_male: bool::default(),
}
}
}
fn main() {
let p: Person = Default::default();
println!("The default value of Person is {:?}", p);
}
复制代码输出结果为：
The default value of Person is Person { name: '', age: 0, is_male: false }
复制代码进阶用法
使用 Default trait 实现结构体的默认值
在 Rust 中，可以为结构体类型实现 Default trait，以便为它们定义默认值。例如，以下代码演示了如何为一个结构体类型实现 Default trait：
#[derive(Default)]
struct Point {
x: i32,
y: i32,
}
fn main() {
let p: Point = Default::default();
println!("The default value of Point is ({}, {})", p.x, p.y);
}
复制代码输出结果为：
The default value of Point is (0, 0)
复制代码使用 Default trait 实现枚举类型的默认值
在 Rust 中，可以为枚举类型实现 Default trait，以便为它们定义默认值。例如，以下代码演示了如何为一个枚举类型实现 Default trait：
enum Color {
Red,
Green,
Blue,
}
impl Default for Color {
fn default() -> Self {
Color::Red
}
}
fn main() {
let color: Color = Default::default();
println!("The default value of Color is {:?}", color);
}
复制代码输出结果为：
The default value of Color is Red
复制代码使用 Default trait 实现元组类型的默认值
在 Rust 中，可以为元组类型实现 Default trait，以便为它们定义默认值。例如，以下代码演示了如何为一个元组类型实现 Default trait：
impl Default for (i32, bool, String) {
fn default() -> Self {
(0, false, String::default())
}
}
fn main() {
let tup: (i32, bool, String) = Default::default();
println!("The default value of (i32, bool, String) is {:?}", tup);
}
复制代码输出结果为：
The default value of (i32, bool, String) is (0, false, '')
复制代码使用 Default trait 实现泛型类型的默认值
在 Rust 中，可以为泛型类型实现 Default trait，以便为它们定义默认值。例如，以下代码演示了如何为一个泛型类型实现 Default trait：
struct Pair<T> {
x: T,
y: T,
}
impl<T: Default> Default for Pair<T> {
fn default() -> Self {
Self {
x: T::default(),
y: T::default(),
}
}
}
fn main() {
let pair: Pair<i32> = Default::default();
println!("The default value of Pair<i32> is ({}, {})", pair.x, pair.y);
}
复制代码输出结果为：
The default value of Pair<i32> is (0, 0)
复制代码最佳实践
在 Rust 中，使用 Default trait 可以方便地获取类型的默认值。以下是一些最佳实践：
为自定义类型实现 Default trait
为自定义类型实现 Default trait 可以方便地为它们定义默认值。例如，以下代码演示了如何为一个结构体类型实现 Default trait：
#[derive(Default)]
struct Point {
x: i32,
y: i32,
}
fn main() {
let p: Point = Default::default();
println!("The default value of Point is ({}, {})", p.x, p.y);
}
复制代码输出结果为：
The default value of Point is (0, 0)
复制代码使用泛型获取类型的默认值
在 Rust 中，可以使用泛型来获取任意类型的默认值。例如，以下代码演示了如何使用泛型获取一个字符串类型的默认值：
fn main() {
let s: String = Default::default();
println!("The default value of String is '{}'", s);
}
复制代码输出结果为：
The default value of String is ''
复制代码使用 Option 类型获取默认值
在 Rust 中，Option 类型是一个枚举类型，它可以表示一个值的存在或不存在。如果一个变量的类型是 Option 类型，则它的默认值是 None。例如，以下代码演示了如何获取一个 Option 类型的默认值：
fn main() {
let opt: Option<i32> = Default::default();
println!("The default value of Option<i32> is {:?}", opt);
}
复制代码输出结果为：
The default value of Option<i32> is None
复制代码Implemente o traço padrão para tipos genéricos
Implementar o atributo Default para tipos genéricos é uma forma conveniente de definir valores default para eles. Por exemplo, o código a seguir demonstra como implementar o atributo Default para um tipo genérico:
struct Pair<T> {
x: T,
y: T,
}
impl<T: Default> Default for Pair<T> {
fn default() -> Self {
Self {
x: T::default(),
y: T::default(),
}
}
}
fn main() {
let pair: Pair<i32> = Default::default();
println!("The default value of Pair<i32> is ({}, {})", pair.x, pair.y);
}
复制代码A saída é:
The default value of Pair<i32> is (0, 0)
复制代码para concluir
No Rust, o traço Padrão é uma maneira prática de obter o valor padrão de um tipo. O uso do traço Padrão pode simplificar o código e melhorar a legibilidade e a capacidade de manutenção do código. Ao mesmo tempo, a implementação do traço Padrão para tipos personalizados facilita a definição de valores padrão para eles. Ao usar o traço Padrão, você pode opcionalmente implementar o traço Padrão para tipos genéricos a fim de definir valores padrão para eles.