如何将 JSON 对象转换为 JavaScript 数组

var json_data = {"2013-01-21":1,"2013-01-22":7};
var result = [];
for(var i in json_data)
    result.push([i, json_data [i]]);

var data = new google.visualization.DataTable();
data.addColumn('string', 'Topping');
data.addColumn('number', 'Slices');
data.addRows(result);

http://jsfiddle.net/MV5rj/

如果你有一个格式良好的JSON字符串，你应该能够做到

var as = JSON.parse(jstring);

通过 AJAX 传输数组时，我一直这样做。

假设你有：

var j = {0: "1", 1: "2", 2: "3", 3: "4"};

您可以使用以下值（几乎所有浏览器版本都支持）：

Object.keys(j).map(function(_) { return j[_]; })

或者简单地：

Object.values(j)

输出：

["1", "2", "3", "4"]

function json2array(json){
    var result = [];
    var keys = Object.keys(json);
    keys.forEach(function(key){
        result.push(json[key]);
    });
    return result;
}

请参阅此完整解释：http://book.mixu.net/node/ch5.html

这将解决问题：

const json_data = {"2013-01-21":1,"2013-01-22":7};
const arr = Object.keys(json_data).map((key) => [key, json_data[key]]);
console.log(arr);

或者使用 Object.entries（） 方法：

console.log(Object.entries(json_data));

在这两种情况下，输出都将是：

/* output: 
[['2013-01-21', 1], ['2013-01-22', 7]]
*/

上述解决方案不适用于嵌套对象。对于嵌套对象，我们可以做这样的事情：

const isObject = (obj) => {
  return typeof obj === 'object' && !Array.isArray(obj) && obj !== null;
}
const objToArray = (obj) => {
  return Object.keys(obj).map((key) => {
    return [
      key, isObject(obj[key]) ? 
        objToArray(obj[key]) :
        obj[key]
    ];
  });    
}
const json_data = {
  "2013-01-21":1, 
  "2013-01-22":7,
  "ab":{"x":{"xa": 3, "xb": 4}, "y": 2},
};
console.log(JSON.stringify(objToArray(json_data)));

在这种情况下，输出将是：

/* output: 
[["2013-01-21",1],["2013-01-22",7],["ab",[["x",[["xa",3],["xb",4]]],["y",2]]]]
*/

您可以按如下方式将对象项插入数组

 
 let obj2 = {"2013-01-21":1,"2013-01-22":7}
 
 console.log(Object.keys(obj2).map(key => [key, obj2[key]]))
let obj = {
  '1st': {
    name: 'stackoverflow'
  },
  '2nd': {
    name: 'stackexchange'
  }
};
// you can use Object.values(obj)
console.log(Object.values(obj))
 
// or you can use this instead. 
 let wholeArray = Object.keys(obj).map(key => obj[key]);
 
 console.log(wholeArray);
 console.log(Object.values(obj));

考虑有一个我们要转换的 json 对象

const my_object = {
    "key1": "value1",
    "key2": "value2",
    "key3": "value3"
}

您可以使用几种解决方案：

1. Object.keys（） 和 Object.values（）

这些函数将任何对象转换为数组。一个返回一个包含所有键的数组，另一个返回所有值：

console.log(Object.keys(my_object))
// Output : ["key1", "key2", "key3"]
console.log(Object.values(my_object))
// Output : ["value1", "value2", "value3"]

我不确定是否理解最初的问题，但解决方案可能是

data.addRows(Object.values(my_object));

2. 对象条目（）

此函数是上述两个函数的混合：

console.log(Object.entries(my_object))
// Output : [["key1", "value1"],  ["key2", "value2"],  ["key3", "value3"]]

对于最初的问题没有用，但是这个功能非常有用，我不得不提到它。特别是，当value_是嵌套对象时。假设我们的值是这样的对象：

const my_object = {
    "key1": {"a": 1, "b": 2},
    "key2": {"y": 25, "z": 26},
    "key3": {"much": "stuff"}
}

我们希望最终得到这样的数组

my_array = [
    {"key": "key1", "a": 1, "b": 2},
    {"key": "key2", "y": 25, "z": 26},
    {"key": "key3", "much": "stuff"}
]

我们需要使用Object.entries()来获取所有具有其价值的密钥。我们将从一个过于详细的代码开始：

my_array = Object.entries(my_object).map(function(entry){
   key = entry[0];
   value = entry[1];
   nested_object = value;
   nested_object.key = key;
   return nested_object;
});
console.log(my_array);
// Expected output : [
//    {"key": "key1", "a": 1, "b": 2},
//    {"key": "key2", "y": 25, "z": 26},
//    {"key": "key3", "much": "stuff"}
//]

我们可以利用 spread 运算符来简化我们的代码：

my_array = Object.entries(my_object).map(entry => {"key": entry[0], ...entry[1]});
console.log(my_array);
// Expected output : [
//    {"key": "key1", "a": 1, "b": 2},
//    {"key": "key2", "y": 25, "z": 26},
//    {"key": "key3", "much": "stuff"}
//]

如果目标是创建一个对象数组，这里有一个解决方案，它将完成你尝试使用 Object.keys（） 执行的操作：

const jsonResponse = '{"2013-01-21":1,"2013-01-22":7}'
// Only use json parse if the data is a JSON string.
const obj = typeof jsonResponse === 'string' ? JSON.parse(jsonResponse) : jsonResponse;
const data = [];
Object.keys(obj).forEach((key) => data.push({[key]: obj[key]}))
// Example 2 - storing it directly in a variable using map
const arrayOfObjs = Object.keys(obj).map((key) => ({[key]: obj[key]}))

或使用 Object.entries（）

// Example 1
Object.entries(obj).forEach((array) => data.push({[array[0]]: array[1]}))
// Example 2
Object.entries(obj).forEach(([key, value]) => data.push({[key]: value}))
// Example 3 - Store it directly in a new variable using map
const arrayOfObjs = Object.entries(obj).map(([key, value]) => ({[key]: value}))

对@Mister Aqua 的一些更正溶液

const my_array = [];
    Object.entries(set_of_objects).map(function (entry) {
      const key = entry[0];
      const value = entry[1];
      const nested_object = {};
      nested_object[key] = value;
      my_array.push(nested_object);
    });

感冒药:)

当我将长 JSON 字符串放入隐藏的div 中然后尝试通过此代码将其转换为JSON-

var data = document.getElementById('data');
var json = JSON.parse(data);

发现错误了吗？是的，我忘了在第一行添加.innerHTML。所以数据已经是一个对象。不是字符串。JSON.parse如何解析对象？

JSON.parse 用于解析字符串。 而不是对象。

就这么简单！

var json_data = {"2013-01-21":1,"2013-01-22":7};
var result = [json_data];
console.log(result);