Wie kann ich eine Funktion mit einer variablen Anzahl von Argumenten erstellen?

Question

Wie kann ich eine Funktion mit einer variablen Anzahl von Argumenten in Rust erstellen?

Gefallen Sie diesen Java-Code:

void foo(String... args) { 
    for (String arg : args) { 
     System.out.println(arg); 
    } 
} 

Answer 1

In der Regel können Sie nicht - Rust nicht unterstützt variadische Funktionen, außer wenn mit C-Code interoperabel, die varargs verwendet.

In dies Fall, da alle Ihre Argumente vom gleichen Typ sind, können Sie eine Scheibe annehmen:

fn foo(args: &[&str]) { 
    for arg in args { 
     println!("{}", arg); 
    } 
} 

fn main() { 
    foo(&["hello", "world", "I", "am", "arguments"]); 
} 

(Playground)

Darüber hinaus können Sie explizit optionale Argumente akzeptieren:

fn foo(name: &str, age: Option<u8>) { 
    match age { 
     Some(age) => println!("{} is {}.", name, age), 
     None  => println!("Who knows how old {} is?", name), 
    } 
} 

fn main() { 
    foo("Sally", Some(27)); 
    foo("Bill", None); 
} 

(Playground)

Wenn Sie viele Argumente, optional oder nicht akzeptieren müssen, können Sie einen Builder implementieren:

struct Arguments<'a> { 
    name: &'a str, 
    age: Option<u8>, 
} 

impl<'a> Arguments<'a> { 
    fn new(name: &'a str) -> Arguments<'a> { 
     Arguments { 
      name: name, 
      age: None 
     } 
    } 

    fn age(self, age: u8) -> Self { 
     Arguments { 
      age: Some(age), 
      ..self 
     } 
    } 
} 

fn foo(arg: Arguments) { 
    match arg.age { 
     Some(age) => println!("{} is {}.", arg.name, age), 
     None  => println!("Who knows how old {} is?", arg.name), 
    } 
} 

fn main() { 
    foo(Arguments::new("Sally").age(27)); 
    foo(Arguments::new("Bill")); 
} 

(Playground)

Answer 2

fn variable_func<T>(_vargs: &[T]) {} 

fn main() { 
    variable_func(&[1]); 
    variable_func(&[1, 2]); 
    variable_func(&["A", "B", "C"]); 
}