另一种方法是声明一个带有可选参数的枚举作为变量，可以将其参数化以接受每个选项的正确类型。可以实现该函数以获取枚举变量的可变长度切片。它们可以是任意的顺序和长度。默认值在函数中作为初始赋值实现。

enum FooOptions<'a> {
    Height(f64),
    Weight(f64),
    Name(&'a str),
}
use FooOptions::*;

fn foo(args: &[FooOptions]) {
    let mut height   = 1.8;
    let mut weight   = 77.11;
    let mut name     = "unspecified".to_string();
    
    for opt in args {
        match opt {
            Height(h) => height = *h,
            Weight(w) => weight = *w,
            Name(n)   => name   =  n.to_string(),
        }
    }
    println!("  name: {}\nweight: {} kg\nheight: {} m", 
             name, weight, height);
}
    
fn main() { 

    foo( &[ Weight(90.0), Name("Bob") ] );

}

输出:

  name: Bob
weight: 90 kg
height: 1.8 m

Args本身也可以是可选的。

fn foo(args: Option<&[FooOptions]>) {
    let args = args.or(Some(&[])).unwrap();
    // ...
}

在前面答案的基础上，请记住，您可以创建与现有变量同名的新变量，这将隐藏之前的变量。如果你不打算使用Option<…>了。

fn add(a: Option<i32>, b: Option<i32>) -> i32 {
    let a = a.unwrap_or(1);
    let b = a.unwrap_or(2);
    a + b
}

不，目前还没有。我认为它很可能最终会实现，但目前在这个领域还没有活跃的工作。

这里采用的典型技术是使用具有不同名称和签名的函数或方法。

如果你使用Rust 1.12或更高版本，你至少可以让函数参数更容易使用Option和into():

fn add<T: Into<Option<u32>>>(a: u32, b: T) -> u32 {
    if let Some(b) = b.into() {
        a + b
    } else {
        a
    }
}

fn main() {
    assert_eq!(add(3, 4), 7);
    assert_eq!(add(8, None), 8);
}

另一种方法是声明一个带有可选参数的枚举作为变量，可以将其参数化以接受每个选项的正确类型。可以实现该函数以获取枚举变量的可变长度切片。它们可以是任意的顺序和长度。默认值在函数中作为初始赋值实现。

enum FooOptions<'a> {
    Height(f64),
    Weight(f64),
    Name(&'a str),
}
use FooOptions::*;

fn foo(args: &[FooOptions]) {
    let mut height   = 1.8;
    let mut weight   = 77.11;
    let mut name     = "unspecified".to_string();
    
    for opt in args {
        match opt {
            Height(h) => height = *h,
            Weight(w) => weight = *w,
            Name(n)   => name   =  n.to_string(),
        }
    }
    println!("  name: {}\nweight: {} kg\nheight: {} m", 
             name, weight, height);
}
    
fn main() { 

    foo( &[ Weight(90.0), Name("Bob") ] );

}

输出:

  name: Bob
weight: 90 kg
height: 1.8 m

Args本身也可以是可选的。

fn foo(args: Option<&[FooOptions]>) {
    let args = args.or(Some(&[])).unwrap();
    // ...
}

不，Rust不支持默认函数参数。你必须用不同的名字定义不同的方法。也没有函数重载，因为Rust使用函数名派生类型(函数重载要求相反)。

在结构初始化的情况下，你可以像这样使用结构更新语法:

use std::default::Default;

#[derive(Debug)]
pub struct Sample {
    a: u32,
    b: u32,
    c: u32,
}

impl Default for Sample {
    fn default() -> Self {
        Sample { a: 2, b: 4, c: 6}
    }
}

fn main() {
    let s = Sample { c: 23, ..Sample::default() };
    println!("{:?}", s);
}

[应要求，我交叉发布了一个重复问题的答案]