简要方式

let result={};
Object.keys(array[0]).forEach((key)=>{
           result[key]=array.map((e)=> e[key]);
})

演示

如果我理解你，你得到类似东西的最简单方法是将所有值存储在一个数组中。

例如，您可以使用 for 循环：

var i, store_name, store_input, store_Amount, array;
array = [
    {
        "store_name":"ABC",
        "store_iput": "123",
        "store_Amount": "34"
    },
    {
        "store_name":"XYZ",
        "store_iput": "178",
        "store_Amount": "346"
    },
    {
        "store_name":"Tokr",
        "store_iput": "3",
        "store_Amount": "3"
    }
]
for(i=0;i<array.length;i++){
    store_name[i]=array[i].store_name;
    store_input[i]=array[i].store_name;
    store_Amount[i]=array[i].store_name;
}

然后，您将获得 3 个值数组 - 存储名称、存储输入和存储数量。

如果您决定将所有值存储在一个对象中，则可以执行以下操作，而不是以前的 for 循环：

var obj = {
    var store_name = [],
        store_input= [],
        store_Amount = [];
};
for(i=0;i<array.length;i++){
    obj.store_name[i]=array[i].store_name;
    obj.store_input[i]=array[i].store_name;
    obj.store_Amount[i]=array[i].store_name;
}

Object.keys 获取数组第一个对象中的键的名称，然后遍历此数组，使用 Array#map 从所有对象中获取映射的值，并将映射的值添加到每个键的新对象中：

var keys = Object.keys(objectArray[0]);
var combinedObject = {};
keys.forEach(function(key){
    combinedObject[key] = objectArray.map(function(object){
        return object[key];
    });
})

(function(arr) {
  var rtn = {};
  for (var i = 0; i < arr.length; i++) {
    for (var k in arr[i]) {
      if (rtn[k]) {
        rtn[k].push(arr[i][k]);
      } else {
        rtn[k] = [arr[i][k]];
      }
    }
  }
  console.log(rtn)
  return rtn;
})([{
  "store_name": "ABC",
  "store_iput": "123",
  "store_Amount": "34"
}, {
  "store_name": "XYZ",
  "store_iput": "178",
  "store_Amount": "346"
}, {
  "store_name": "Tokr",
  "store_iput": "3",
  "store_Amount": "3"
}]);

这里有一种方法可以做到这一点：

var input = [
  { "store_name": "ABC", "store_iput": "123", "store_Amount": "34" },
  { "store_name": "XYZ", "store_iput": "178", "store_Amount": "346" },
  { "store_name": "Tokr", "store_iput": "3", "store_Amount": "3" }
];
var output = input.reduce(function(a, v) {
  Object.keys(v).forEach(function(k) { (a[k] || (a[k] = [])).push(v[k]); });
  return a;
}, {});
console.log(output);

延伸阅读：

• Array.prototype.reduce()
• Object.keys()
• Array.prototype.forEach()

只需迭代数组项。对于每个属性，获取其属性并迭代它们。使用该属性作为在结果中存储数据的键。如果密钥不存在，请创建一个新数组。

var data = [
  {
    "store_name":"ABC",
    "store_iput": "123",
    "store_Amount": "34"
  },
  {
    "store_name":"XYZ",
    "store_iput": "178",
    "store_Amount": "346"
  },
  {
    "store_name":"Tokr",
    "store_iput": "3",
    "store_Amount": "3"
  }
];
console.log(data.reduce(function(result, item, index) {
  Object.keys(item).forEach(function(key) {
    if(!result.hasOwnProperty(key)) result[key] = new Array(data.length);
    result[key][index] = item[key];
  });
  return result;
}, {}));

如果您事先知道所有密钥，这很容易。

var data = {
   store_name:[],
   store_input:[],
   store_Amount:[]
}
items.forEach(function(el, i, arr){
   data.store_name.push(el.store_name);
   data.store_input.push(el.store_input);
   data.store_Amount.push(el.store_Amount);       
} 
// or
items.forEach(function(el, i, arr){
   Object.keys(el).forEach(function(key) {
       data[key].push(el[key]);
   });       
} 

如果需要考虑新的或丢失的键，则需要将键动态添加到数据对象，然后根据需要进行后处理以同步键数组长度

var data = {};
items.forEach(function(el, i, arr){
    Object.keys(el).forEach(function(key) {
       var arr = data[key] || [];
       arr[i] = el[key]; // set to i to account for missing values
       data[key] = arr;
    }
}
// resize any short arrays
// fill in missing data?
Object.keys(data).forEach(function(key){
    data[key].length = items.length;
});

有多种方法，正如其他人所列出的。

如果您正在考虑使用ECMA5语法解决它，那么您可以使用 reduce .

例：

var test =
[
    {
        "store_name":"ABC,",
        "store_input": "123",
        "store_Amount": "34"
    },
    {
        "store_name":"XYZ",
        "store_input": "178",
        "store_Amount": "346"
    },
    {
        "store_name":"Tokr",
        "store_input": "3",
        "store_Amount": "3"
    }
];
let output = test.reduce((accumulator, current) => {
    accumulator.store_name.push(current.store_name);
    accumulator.store_input.push(current.store_input);
    accumulator.store_Amount.push(current.store_Amount);
    return accumulator
}, {
    "store_name" : [],
    "store_input" : [],
    "store_Amount" : []
});
console.log(JSON.stringify(output));

输出：

{
    "store_name":["ABC,","XYZ","Tokr"],
    "store_input":["123","178","3"],
    "store_Amount":["34","346","3"]
}

从本质上讲，代码正在做的是尝试使用您的 JSON 对象test并将其简化为填充有键的单个对象; store_name，store_input和store_amount。其中每个都有一个数组。请参阅reduce的第二个参数。

然后，对于 reduce API 中的每次迭代，代码将从current中检索相应的属性，并将其值推送到正确的数组中。它一直持续到迭代结束。

您可能还想查看 reduce 的其他用法。

看：
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce

var final = {store_name: [], store_iput: [], store_Amount: []}
var original = [
    {
        "store_name":"ABC",
        "store_iput": "123",
        "store_Amount": "34"
    },
    {
        "store_name":"XYZ",
        "store_iput": "178",
        "store_Amount": "346"
    },
    {
        "store_name":"Tokr",
        "store_iput": "3",
        "store_Amount": "3"
    }
]
original.forEach(function(x){
    final.store_name.push(x.store_name)
    final.store_iput.push(x.store_iput)
    final.store_Amount.push(x.store_Amount)
})

https://repl.it/CdX5/1

没有直接的方法可以实现所需的输出。您需要进行一些计算才能实现它。尝试使用以下方法：

var arr = [{"store_name":"ABC", "store_iput": "123", "store_Amount": "34" }, {"store_name":"XYZ", "store_iput": "178", "store_Amount": "346"}, {"store_name":"Tokr", "store_iput": "3", "store_Amount": "3"}]
var result= {};
for (var i = 0; i < arr.length; i++) {
    var obj = arr[i];
    for (var prop in obj) {
        if (result[prop] == null) {
            result[prop] = [];
            result[prop].push(obj[prop]);
        } else {
            result[prop].push(obj[prop]);
        }
    }
}
for (var prop in result) {
    // you need to use print statement to print key and value
}