Syntax Rust match语句是否需要逗号？

为什么这个代码可以工作？匹配语句中的逗号只是一种约定吗

for (index, character) in argv[1].chars().enumerate() {
match character {
    'a' | 'A' => {println!("{}: 'A'", index)}
    'e' | 'E' => {println!("{}: 'E'", index)}
    'i' | 'I' => {println!("{}: 'I'", index)}
    'o' | 'O' => {println!("{}: 'O'", index)}
    'u' | 'U' => {println!("{}: 'U'", index)}
     _        => {
                     let consonant: Vec<_> = character.to_uppercase().collect();
                     println!("{}: {:?} is not a vowel", index, consonant[0])
                 }
}

argv[1]中的（索引、字符）的

。chars（）.enumerate（）{
匹配字符{
'a'|'a'=>{println！（“{}:'a'，索引）}
'e'|'e'=>{println！（“{}:'e'，索引）}
'i'|'i'=>{println！（“{}:'i'”，索引）}
'o'|'o'=>{println！（“{}:'o'，索引）}
‘u’|‘u’=>{println！（“{}：‘u’”，索引）}
_        => {
让辅音：Vec=character.to_大写（）.collect（）；
println！（“{}:{：？}不是元音”，索引，辅音[0]）
}
}

Rust match语句是否需要逗号

不，你自己的代码证明了这一点

为什么这个代码可以工作

因为语言的设计者决定它应该

匹配臂可以具有后跟逗号的表达式，也可以具有不带逗号的块

匹配语句中的逗号只是一种约定吗

for (index, character) in argv[1].chars().enumerate() {
match character {
    'a' | 'A' => {println!("{}: 'A'", index)}
    'e' | 'E' => {println!("{}: 'E'", index)}
    'i' | 'I' => {println!("{}: 'I'", index)}
    'o' | 'O' => {println!("{}: 'O'", index)}
    'u' | 'U' => {println!("{}: 'U'", index)}
     _        => {
                     let consonant: Vec<_> = character.to_uppercase().collect();
                     println!("{}: {:?} is not a vowel", index, consonant[0])
                 }
}

否。使用大括号时，rustfmt会删除逗号。否则，它们是必需的

rustfmt如何放置您的代码：

for (index, character) in argv[1].chars().enumerate() {
    match character {
        'a' | 'A' => println!("{}: 'A'", index),
        'e' | 'E' => println!("{}: 'E'", index),
        'i' | 'I' => println!("{}: 'I'", index),
        'o' | 'O' => println!("{}: 'O'", index),
        'u' | 'U' => println!("{}: 'U'", index),
        _ => {
            let consonant: Vec<_> = character.to_uppercase().collect();
            println!("{}: {:?} is not a vowel", index, consonant[0])
        }
    }
}

argv[1]中的（索引、字符）的

。chars（）.enumerate（）{
匹配字符{
'a'|'a'=>println！（“{}:'a'”，索引），
'e'|'e'=>println！（“{}:'e'”，索引），
'i'|'i'=>println！（“{}:'i'”，索引），
'o'|'o'=>println！（“{}:'o'”，索引），
‘u’|‘u’=>println！（“{}：‘u’”，索引），
_ => {
让辅音：Vec=character.to_大写（）.collect（）；
println！（“{}:{：？}不是元音”，索引，辅音[0]）
}
}
}

让我们看看：

MatchArms：
（MatchArm=>（块表达式，？表达式）*
MatchArm=>（块表达式|表达式），？

我们在这里可以看到，在

=>

的右侧总是有一个表达式，但我们区分了两种类型的表达式：BlockExpression和expression。在BlockExpression之后，逗号是可选的（由

表示？

），但在正常表达式之后需要逗号，但最后一个匹配臂除外：在那里，逗号始终是可选的

什么是BlockExpression？它基本上定义为两个大括号

{}

，带有语句列表和可选的尾部表达式

因此：如果：

• 这是最后一支比赛手臂，或
• 如果臂的右侧是块表达式（两个大括号之间的填充

  {}

  ）。

---

不幸的是，编译器与引用不太一致。例如：

match true {
    false => if true {
        "hi"
    } else {
        "no"
    }
    true => ""
};

请注意，第一个匹配臂的右侧不是一个块表达式，而是一个if-else表达式。因此，对于编译器来说，规则似乎是：如果右侧以右括号结尾，则逗号是可选的

---

至于什么是惯用语：

• 如果右侧以右括号结尾}，请省略逗号
• 如果不是：使用逗号，即使它是最后一个匹配的手臂