为匹配运算符借用可能未初始化的变量答案

【问题标题】：borrow of possibly uninitialized variable for match operator为匹配运算符借用可能未初始化的变量
【发布时间】：2020-11-06 06:40:10
【问题描述】：

我正在设计一个库，可以将给定的字符串从乌克兰语音译成英语，因此我决定使用“匹配”运算符来定义检查多个条件的语句。但是我遇到了编译器错误，这是 Rust 的典型错误，但在我的情况下完全不可能（至少我是这么认为的）。


   --> src/lib.rs:188:21
    |
188 |  origin_mutated[i] = 'Y';
    |  ^^^^^^^^^^^^^^ use of possibly-uninitialized `origin_mutated`

error: aborting due to previous error

这是一个库的完整代码。如果我没有看到明显的问题（因为我怀疑它可能是编译器中的错误），请把我的鼻子撞到一个问题上

pub fn transliterate(mut origin: String) -> String {
    let counter: usize = origin.chars().count();
    let mut j: usize = 0;
    let mut i: usize = 0;
    let origin_vec: Vec<char> = origin.chars().collect();
    let mut origin_mutated: Vec<char>;
    if j <= counter{
        while j <= counter {
            match origin_vec[j] {
                'А' => {
                    origin_mutated[i] = 'A';
                    i+=1;
                    j+=1;
                    },
                'Б' => {
                    origin_mutated[i] = 'B';
                    j+=1;
                    i+=1;
                    },
                'В' => {
                    origin_mutated[i] = 'V';
                    i+=1;
                    j+=1;
                    },
                'Г' => {
                    origin_mutated[i] = 'H';
                    i+=1;
                    j+=1;
                    },
                'Ґ' => {
                    origin_mutated[i] = 'G';
                    i+=1;
                    j+=1;
                    },
                'Д' => {
                    origin_mutated[i] = 'D';
                    i+=1;
                    j+=1;
                    },
                'Е' => {
                    origin_mutated[i] = 'E';
                    i+=1;
                    j+=1;
                    },
                'Є' => {
                    origin_mutated[i] = 'Y';
                    i+=1;
                    j+=1;
                    origin_mutated[i] = 'e';
                    i+=1;
                    },
                'Ж' => {
                    origin_mutated[i] = 'Z';
                    i+=1;
                    j+=1;
                    origin_mutated[i] = 'h';
                    i+=1;
                    },
                'З' => {
                    origin_mutated[i] = 'Z';
                    i+=1;
                    j+=1;
                    },
                'И' => {
                    origin_mutated[i] = 'Y';
                    i+=1;
                    j+=1;
                    },
                'І' => {
                    origin_mutated[i] = 'I';
                    i+=1;
                    j+=1;
                    },
                'Ї' => {
                    origin_mutated[i] = 'Y';
                    i+=1;
                    j+=1;
                    origin_mutated[i] = 'i';
                    i+=1;
                    },
                'Й' => {
                    origin_mutated[i] = 'Y';
                    i+=1;
                    j+=1;
                    },
                'К' => {
                    origin_mutated[i] = 'K';
                    i+=1;
                    j+=1;
                    },
                'Л' => {
                    origin_mutated[i] = 'L';
                    i+=1;
                    j+=1;
                    },
                'М' => {
                    origin_mutated[i] = 'M';
                    i+=1;
                    j+=1;
                    },
                'Н' => {
                    origin_mutated[i] = 'N';
                    i+=1;
                    j+=1;
                    },
                'О' => {
                    origin_mutated[i] = 'O';
                    i==1;
                    j+=1;
                    },
                'П' => {
                    origin_mutated[i] = 'P';
                    i+=1;
                    j+=1;
                    },
                'Р' => {
                    origin_mutated[i] = 'R';
                    i==1;
                    j+=1;
                    },
                'С' => {
                    origin_mutated[i] = 'S';
                    i==1;
                    j+=1;
                    },
                'Т' => {
                    origin_mutated[i] = 'T';
                    i==1;
                    j+=1;
                    },
                'У' => {
                    origin_mutated[i] = 'U';
                    i+=1;
                    j+=1;
                    },
                'Ф' => {
                    origin_mutated[i] = 'F';
                    i==1;
                    j+=1;
                    },
                'Х' => {
                    origin_mutated[i] = 'K';
                    i+=1;
                    j==1;
                    origin_mutated[i] = 'h';
                    i+=1;
                    },
                'Ц' => {
                    origin_mutated[i] = 'T';
                    i+=1;
                    j+=1;
                    origin_mutated[i] = 's';
                    i+=1;
                    },
                'Ч' => {
                    origin_mutated[i] = 'C';
                    i+=1;
                    j+=1;
                    origin_mutated[i] = 'h';
                    i+=1;
                    },
                'Ш' => {
                    origin_mutated[i] = 'S';
                    i+=1;
                    j+=1;
                    origin_mutated[i] = 'h';
                    i+=1;
                    },
                'Щ' => {
                    origin_mutated[i] = 'S';
                    i+=1;
                    j==1;
                    origin_mutated[i] = 'h';
                    i+=1;
                    origin_mutated[i] = 'c';
                    i+=1;
                    origin_mutated[i] = 'h';
                    i+=1;
                    },
                'Ю' => {
                    origin_mutated[i] = 'Y';
                    i+=1;
                    j+=1;
                    origin_mutated[i] = 'u';
                    i+=1;
                    },
                'Я' => {
                    origin_mutated[i] = 'Y';
                    i+=1;
                    j+=1;
                    origin_mutated[i] = 'a';
                    i+=1;
                    },
                _ => {
                    j+=1;
                    }
                }
            }
        }
    else if j > counter{
        origin_mutated[i] = '\n'; 
    }
    else {
        origin = origin_mutated.into_iter().collect();
    }
    //origin = origin_mutated.into_iter().collect();
    (origin)
}

【问题讨论】：

用肉眼扫描，有几个==s 似乎已被+=s 取代。

标签： rust

【解决方案1】：

错误的原因是这一行没有创建 Vec：

let mut origin_mutated: Vec<char>;

它创建了一个变量，可以保存一个 Vec，但还不能，甚至不能保存一个零长度的变量。好像在说

let a: i32;

它没有价值。你可能是说

let mut origin_mutated: Vec<char> = Vec::new();

【讨论】：

【解决方案2】：

我不确定你的程序为什么不能编译，但即使它编译了，我认为当你尝试索引你的origin_mutated 向量时它可能会感到恐慌。原因是您的origin_mutated vec 的长度为 0，因此尝试对其进行索引会根据the docs 出现恐慌。

您不能对尚不存在的向量元素进行索引。您需要使用push() 或类似的方法来增加您的Vec。

但使用 Rust 有更好的方法：通过迭代输入 String 和 mapping 其元素：

pub fn transliterate(origin: &str) -> String {
    origin.chars().map(transliterate_letter).collect()
}

fn transliterate_letter(letter: char) -> &'static str {
    match letter {
        'А' => "A",
        'Б' => "B",
        ...
        'Є' => "Ye",
        ...
    }
}

Playground

【讨论】：

代码无法编译，因为 origin_mutate vec 从未使用值初始化（并且 Rust 不允许使用可能未初始化的变量），因此它甚至没有长度 0，但如果它是用Vec::new 初始化的，那么你的答案将是完全正确的。
@Frxstrem 啊！我错过了它只是被宣布的。但是，在这种情况下，我觉得很奇怪，错误并没有出现在 origin_mutated[i] = 'A'; 行上。
确实可以通过将第 6 行更改为 let mut origin_mutated: Vec<char> = vec![];

【解决方案3】：

Rust 中的所有堆栈变量在显式分配值之前都未初始化：

let mut origin_mutated: Vec<char>

这里，origin_mutated 实际上并未初始化为向量。它只是一个向量的占位符，将来可能会或可能不会被初始化。

因为 Rust 不知道变量是否被初始化，编译器会静态阻止你读取它：

    |
188 |  origin_mutated[i] = 'Y';
    |  ^^^^^^^^^^^^^^ use of possibly-uninitialized `origin_mutated`

解决方法是将origin_mutated初始化为空向量：

let mut origin_mutated: Vec<char> = Vec::new()

【讨论】：