前端读取json数据时候，可以使用以下方法读取对象的key值
 
if (network?.win) {
                        for (const key in network.win) {
                        netData1.push(key);
                    }
                    } else {
                        for (const key in network) {
                        netData1.push(key);
                    }

*注意  该方法只获取第一次出现的key对应的value 
 
 public static String getJsonValue(String key, String jsonString) {
        //使用非贪婪模式
        StringBuffer regex = new StringBuffer();
        regex.append("\"");
        regex.append(key);
        regex.append("\":\"(.*?)\\\"");
        Matcher matcher = Pattern.compile(regex.toString()).matcher(jsonString);
        String ret = null;
        while (matcher.find()) {
            ret = matcher.group(1);
            if (ret != null) {
                break;
            }
        }
        return ret;
    }
 
测试
 
 public static void main(String[] args) {
        String parem = "{\"appId\":\"123\",\"age\":0,\"name\":\"string\",\"prive\":{\"asg\":\"789\",\"sex\":\"string\"}}";
        System.out.println(getJsonValue("appId", parem));
    }
 
 
 
结果
 

C#获取动态key的json对象的值
 
问题描述
 
如果直接获取某个json数组中的元素将得到如下的json
 
{
    "44": {
        "height": 25,
        "appeared": -70000000,
        "length": 44,
        "order": "saurischia",
        "vanished": -70000000,
        "weight": 135000
    }
}
 
这个json对象如果使用C#类来反序列化，那么实体类的结构如下，实体类的类名需要与json对象key相同的才可以使用json反序列化，这样对程序造成了极大的不便。
 
public class 44
{
    public int height { get; set; }
    public int appeared { get; set; }
    public int length { get; set; }
    public string order { get; set; }
    public int vanished { get; set; }
    public int weight { get; set; }
}

public class Root
{
    public 44 44 { get; set; }
}
 
解决方案
 
以上json对象由于key是动态的无法使用C#反序列化，但是直接取到value就能序列化了，如下。
 
{
    "height":25,
    "appeared":-70000000,
    "length":44,
    "order":"saurischia",
    "vanished":-70000000,
    "weight":135000
}
 
以上json对象就可以使用我们常用的格式转换了。
 
public class Root
{
    public int height { get; set; }
    public int appeared { get; set; }
    public int length { get; set; }
    public string order { get; set; }
    public int vanished { get; set; }
    public int weight { get; set; }
}
 
实现代码
 
从动态key的json对象里面拿到value那部分，可以反序列化的字符串，请使用如下的函数，注意引入类库。
 
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.Linq;
 
/// <summary>
/// 本类用于处理动态Key的json对象
/// </summary>
/// <param name="jObject">需要处理的json对象</param>
/// <returns>json对象的第一个元素的values</returns>
public static string GetJsonValue(string strJson)
{
    string strResult;
    JObject jo = JObject.Parse(strJson);
    string[] values = jo.Properties().Select(item => item.Value.ToString()).ToArray();
    if (values == null)
    {
        strResult = "";
    }
    else
    {
        strResult = values[0];
    }
    return strResult;
}

一、使用 Object.keys(obj)方法获取 JSON对象的key值。
 
     
 
Object.keys( ) 会返回一个数组，数组中是这个对象的key值列表。
 
Polyfill
 
要在原生不支持的旧环境中添加兼容的Object.keys，请复制以下代码段：
 
if (!Object.keys) {
  Object.keys = (function () {
    var hasOwnProperty = Object.prototype.hasOwnProperty,
        hasDontEnumBug = !({toString: null}).propertyIsEnumerable('toString'),
        dontEnums = [
          'toString',
          'toLocaleString',
          'valueOf',
          'hasOwnProperty',
          'isPrototypeOf',
          'propertyIsEnumerable',
          'constructor'
        ],
        dontEnumsLength = dontEnums.length;
 
    return function (obj) {
      if (typeof obj !== 'object' && typeof obj !== 'function' || obj === null) throw new TypeError('Object.keys called on non-object');
 
      var result = [];
 
      for (var prop in obj) {
        if (hasOwnProperty.call(obj, prop)) result.push(prop);
      }
 
      if (hasDontEnumBug) {
        for (var i=0; i < dontEnumsLength; i++) {
          if (hasOwnProperty.call(obj, dontEnums[i])) result.push(dontEnums[i]);
        }
      }
      return result;
    }
  })()
};