动态键值json解析中的颤振问题

下面是我的JSON的输出

{
    "success": true,
    "data": {
        "ones": [{
                "id": "2",
                "username": "LM10002"
            },
            {
                "id": "6",
                "username": "LM10006"
            }
        ],
        "twos": [{
                "id": "3",
                "username": "LM10003"
            },
            {
                "id": "8",
                "username": "LM10008"
            }
        ],
        "threes": [{
            "id": "4",
            "username": "LM10004"
        }],
        "fours": [{
                "id": "5",
                "username": "LM10005"
            },
            {
                "id": "14",
                "username": "GT10014"
            }
        ]
    }
}

这里的键是动态键值 我尝试了解析，并且能够得到

  DownLineModel({this.success, this.data});
  DownLineModel.fromJson(Map<String, dynamic> json) {
    success = json['success'];
    data = json['data'];
    print(data);

DownLineModel（{this.success，this.data}）；
DownLineModel.fromJson（映射json）{
success=json['success']；
data=json['data']；
打印（数据）；

---

如何解析json并找到关键术语，然后再次解析它。

除非

这个。数据
是一个
Map
你的代码将无法工作。你必须使用自己的
数据模型.fromJson（Map json）为
数据
属性创建一个单独的类
method。然后在DownLineModel构造函数中，您可以像这样简单地解析数据json：

this.data = DataModel.fromJson(jsonData);

假设在执行此操作时，
打印（数据）
，您会得到此响应

    {
        "ones": [{
                "id": "2",
                "username": "LM10002"
            },
            {
                "id": "6",
                "username": "LM10006"
            }
        ],
        "twos": [{
                "id": "3",
                "username": "LM10003"
            },
            {
                "id": "8",
                "username": "LM10008"
            }
        ],
        "threes": [{
            "id": "4",
            "username": "LM10004"
        }],
        "fours": [{
                "id": "5",
                "username": "LM10005"
            },
            {
                "id": "14",
                "username": "GT10014"
            }
        ]
    }

现在，我们可以做的是，再次迭代数据，找到
动态键
，比如
一个
，
两个

我们可以这样做。我给你看的是
的
，你可以为res做

//for ones
List<Map<String, String>> ones = data["ones"];

//iterating over it
ones.forEach((element){
   // we are now inside the array
   // iterating over element which is {"id": "", "username": ""}
   element.forEach((key, value){
      print("$key => $value");
   });
});

// OUTPUT
// id => 2
// username => LM10002
// id => 6
// username => LM10006

//对于
列出一个=数据[“一个”]；
//迭代
1.forEach（（元素）{
//我们现在在阵列中
//在{“id”：“，“username”：“}元素上迭代
元素。forEach（（键，值）{
打印（“$key=>$value”）；
});
});
//输出
//id=>2
//用户名=>LM10002
//id=>6
//用户名=>LM10006
json['data']
将是
Map
。因此您可以使用
forEach
对这些动态键进行迭代

json['data'].forEach((dynamicKey, list) {
  // dynamicKey will be 'ones', 'twos', ....
  // list will be the corresponding list of maps
});

只需查看我基于您提供的json为您制作的示例

import 'dart:convert';

import 'package:flutter/material.dart';
import 'package:json_parsing_example/models.dart';
import 'package:http/http.dart' as http;

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(home: HomePage());
  }
}

class HomePage extends StatefulWidget {
  @override
  _HomePageState createState() => _HomePageState();
}

class _HomePageState extends State<HomePage> {
  double value;

  String json = '''
  {
    "success": true,
    "data": {
        "ones": [{
                "id": "2",
                "username": "LM10002"
            },
            {
                "id": "6",
                "username": "LM10006"
            }
        ],
        "twos": [{
                "id": "3",
                "username": "LM10003"
            },
            {
                "id": "8",
                "username": "LM10008"
            }
        ],
        "threes": [{
            "id": "4",
            "username": "LM10004"
        }],
        "fours": [{
                "id": "5",
                "username": "LM10005"
            },
            {
                "id": "14",
                "username": "GT10014"
            }
        ]
    }
}
  
  ''';
  @override
  void initState() {
    super.initState();

    getData();
  }

  getData() {
    Map mapValue = jsonDecode(json);
    // This is where you iterate via the data object
    // that is the value which is key,value pair
    List<Data> data = List();
    mapValue['data'].forEach((key, value) {
      List<User> user = List();
      value.forEach((item) {
        user.add(User(id: item['id'], username: item['username']));
      });
      data.add(Data(name: key, userList: user));
    });

    data.forEach((element) {
      print(element.name + " : " + '${element.userList.length}');
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: Container(child: Text('s')),
    );
  }
}

class Data {
  final String name;
  final List<User> userList;

  Data({this.name, this.userList});
}

class User {
  final String id;
  final String username;

  User({this.id, this.username});
}


导入'dart:convert'；
进口“包装：颤振/材料.省道”；
导入“package:json_parsing_example/models.dart”；
将“package:http/http.dart”导入为http；
void main（）=>runApp（MyApp（））；
类MyApp扩展了无状态小部件{
@凌驾
小部件构建（构建上下文）{
返回资料app（主页：HomePage（））；
}
}
类主页扩展了StatefulWidget{
@凌驾
_HomePageState createState（）=>\u HomePageState（）；
}
类_HomePageState扩展状态{
双重价值；
字符串json=''
{
“成功”：没错，
“数据”：{
“一个”：[{
“id”：“2”，
“用户名”：“LM10002”
},
{
“id”：“6”，
“用户名”：“LM10006”
}
],
“两个”：[{
“id”：“3”，
“用户名”：“LM10003”
},
{
“id”：“8”，
“用户名”：“LM10008”
}
],
“三”：[{
“id”：“4”，
“用户名”：“LM10004”
}],
“四个”：[{
“id”：“5”，
“用户名”：“LM10005”
},
{
“id”：“14”，
“用户名”：“GT10014”
}
]
}
}
''';
@凌驾
void initState（）{
super.initState（）；
getData（）；
}
getData（）{
Map mapValue=jsonDecode（json）；
//这是通过数据对象进行迭代的地方
//这是一个值，它是键，值对
列表数据=列表（）；
mapValue['data'].forEach（（键，值）{
List user=List（）；
value.forEach（（项目）{
添加（用户（id:item['id']，用户名：item['username']）；
});
添加（数据（名称：key，用户列表：user））；
});
data.forEach（（元素）{
打印（element.name+“：“+”${element.userList.length}”）；
});
}
@凌驾
小部件构建（构建上下文）{
返回脚手架(
正文：容器（子项：文本（'s'）），
);
}
}
类数据{
最后的字符串名；
最终列表用户列表；
数据（{this.name，this.userList}）；
}
类用户{
最终字符串id；
最终字符串用户名；
用户（{this.id，this.username}）；
}

让我知道它是否有效