Loops 如何迭代递归/嵌套hashmap中的所有键？

我希望从

HashMap

创建

Vec

。

值

类型来自

预期产出为：

[
[“姓名”]
[“年龄”]
[“电话”]
[“电话”，“0”]
[“电话”，“1”]
[“朋友”]
[“朋友”，“0”]
[“朋友”、“0”、“姓名”]
[“朋友”、“0”、“年龄”]
[“朋友”、“0”、“电话”]
[“朋友”、“0”、“电话”、“0”]
[“朋友”、“0”、“电话”、“1”]
[“朋友”、“0”、“朋友”]
[“朋友”、“0”、“朋友”、“0”]
[“朋友”、“0”、“朋友”、“0”、“姓名”]
[“朋友”、“0”、“朋友”、“0”、“年龄”]
[“朋友”、“0”、“朋友”、“0”、“电话”]
[“朋友”、“0”、“朋友”、“0”、“电话”、“0”]
[“朋友”、“0”、“朋友”、“0”、“朋友”]
[“朋友”、“0”、“朋友”、“1”]
[“朋友”、“0”、“朋友”、“1”、“姓名”]
[“朋友”、“0”、“朋友”、“1”、“年龄”]
[“朋友”、“0”、“朋友”、“1”、“电话”]
[“朋友”、“0”、“朋友”、“1”、“电话”、“0”]
[“朋友”、“0”、“朋友”、“1”、“朋友”]
[“朋友”、“0”、“朋友”、“2”]
[“朋友”、“0”、“朋友”、“2”、“姓名”]
[“朋友”、“0”、“朋友”、“2”、“年龄”]
[“朋友”、“0”、“朋友”、“2”、“电话”]
[“朋友”、“0”、“朋友”、“2”、“电话”、“0”]
[“朋友”、“0”、“朋友”、“2”、“朋友”]
];

问题：如何迭代递归/嵌套hashmap中的所有键并匹配上面的预期输出

use serde_json::{Result, Value};
use std::collections::HashMap;

fn deep_keys(data: HashMap<String, Value>) -> Vec<Vec<String>>{
    let mut vec = Vec::new();
    vec.push(Vec::new());

    // logic

    for (str, val) in data {
        match &val {
            Value::String(string) => vec[0].push(str),
            Value::Number(Number) => vec[0].push(str),
            Value::Bool(bool) => vec[0].push(str),
            _ => {
                let mut map = HashMap::new();
                for (innerStr, innerVal) in val {
                    let mut map = HashMap::new();
                    map.insert(str, innerVal);
                    deep_keys(map);
                }

            }
        };
    }
    vec
}

fn main() {
    let data = r#"
    {
        "name": "John Doe",
        "age": 43,
        "phones": [
            "+44 1234567",
            "+44 2345678"
        ],
        "friends": [
            {
                "name": "Jenn Doe",
                "age": 15,
                "phones": ["+44 1234567", "+44 2345678"],
                "friends": [
                    {
                        "name": "Richard Carter",
                        "age": 20,
                        "phones": ["+1 1234567"],
                        "friends": []
                    },
                      {
                        "name": "Angus Yik",
                        "age": 21,
                        "phones": ["+1 1234567"],
                        "friends": []
                    },
                    {
                        "name": "Diana White",
                        "age": 24,
                        "phones": ["+1 12345673"],
                        "friends": []
                    }
                ]
            }
        ]
    }"#;
    let v: HashMap<String, Value> = serde_json::from_str(data).expect("error");
    println!("{:?}", deep_keys(v));
}

使用serde_json:：{Value}；
使用std：：fs；
//使用std:：path:：path；
使用std:：io:：Read；
fn深\u键（值：&value，当前路径：Vec，输出：&mut Vec）{
如果当前路径.len（）大于0{
push（当前路径.clone（））；
}
匹配值{
值：：对象（映射）=>{
对于地图中的（k，v）{
让mut new_path=current_path.clone（）；
新路径推送（k.to_owned（））；
深_键（v，新_路径，输出）；
}
},
值：：数组（数组）=>{
对于array.iter（）.enumerate（）中的（i，v）{
让mut new_path=current_path.clone（）；
新路径推送（i.到字符串（）.到所拥有的字符串（））；
深_键（v，新_路径，输出）；
}
},
_ => ()
}
}
fn main（）{
让mut output=vec！[vec！[]]；
让当前路径=vec！[]；
让mut file=fs:：file:：open（“src/geo.json”）.unwrap（）；
让mut data=String:：new（）；
file.read_to_string（&mut data）.unwrap（）；
let value:value=serde_json:：from_str（&data）.expect（“error”）；
深_键（&value、当前_路径和mut输出）；
println！（“{：？}”，输出）；
}

@Shepmaster抱歉，我试图简化这个问题的json，并输入了您标记为的错误，但我没有看到任何递归函数的尝试。“如果你尝试一个会发生什么？”Shepmaster我以前尝试过递归，但我不确定这是否是唯一的解决方法，我无法让它工作。我已经用我的递归尝试更新了答案，但由于强制/静态类型的原因，我没有走多远。如果这有助于我尝试在RUST中重新创建，请参见类似以下行的内容：

if（typeof object[k]==“object”&&object[k]！==null）

？用模式匹配替换它们。在类似的情况下，这对我很有用。。。。还发现区分

Value:：Null

很有帮助。值类型在中有详细说明，我猜它们只是底层

serde

类型的变体。。。

use serde_json::{Value};
use std::fs;
//use std::path::Path;
use std::io::Read;

fn deep_keys(value: &Value, current_path: Vec<String>, output: &mut Vec<Vec<String>>) {
    if current_path.len() > 0 {
        output.push(current_path.clone());
    }

    match value {
        Value::Object(map) => {
            for (k, v) in map {
                let mut new_path = current_path.clone();
                new_path.push(k.to_owned());
                deep_keys(v,  new_path, output);

            }
        },
        Value::Array(array) => {
            for (i, v) in array.iter().enumerate() {
                let mut new_path = current_path.clone();
                new_path.push(i.to_string().to_owned());
                deep_keys(v,  new_path, output);
            }
        },
        _ => ()
    }
}

fn main() {
    let mut output = vec![vec![]];
    let current_path = vec![];
    let mut file = fs::File::open("src/geo.json").unwrap();
    let mut data = String::new();
    file.read_to_string(&mut data).unwrap();

    let value:Value = serde_json::from_str(&data).expect("error");
    deep_keys(&value, current_path, &mut output);
    println!("{:?}", output);
}