Javascript 将键/值对数组转换为对象数组

我需要能够将数组转换为包含多个对象的新数组。例如，如果我有这个数组：

["name", "Tom", "id", "48688", "name", "Bob", "id", "91282"]

我希望能够将其转换为：

[{
   "name": "Tom",
   "id": "48688"
}, {
   "name": "Bob"
   "id": "91282"
}]

---

我经常看到这样的问题，所以我做了一个小转换器来实现这个特定的目标：

//输入
变量inputArray=[“姓名”、“汤姆”、“身份证”、“48688”、“姓名”、“鲍勃”、“身份证”、“91282”]
var sizeOfObjects=2；//每个对象的条目数
//作用
函数转换（数组、大小）{
var newArray=[]//设置一个数组
var res3=数组。减少（（会计科目、项目、索引）=>{
如果（索引%2==0）{//如果索引为偶数：
acc[`${item}`]=数组[index+1]；//向数组中添加项
}
if（Object.keys（acc.length==size）{//如果已达到所需的大小：
newArray.push（acc）；//将对象推入数组
acc={}；//重置对象
}
return acc；//保存累加器，以免忘记
}，{}；//reducer的初始值是空对象
return newArray；//返回数组
}
log（convert（inputArray，sizeOfObjects））使用
for
循环，将其迭代次数增加
4
，如下所示：

let results = [];
for(let i = 0; i < array.length; i += 4) {    // increment i by 4 to get to the start of the next object data
  results.push({
    id: array[i + 3],                         // array[i + 0] is the string "name", array[i + 1] is the name,
    name: array[i + 1]                        // array[i + 2] is the string "id" and array[i + 3] is the id
  });
}

let results=[]；
对于（设i=0；i

演示：


let array=[“name”、“Tom”、“id”、“48688”、“name”、“Bob”、“id”、“91282”、“name”、“Ibrahim”、“id”、“7”]；
让结果=[]；
for（设i=0；i控制台日志（结果）您可以采用动态方法，使用对象跟踪相同命名键的目标索引


const
getArray=数据=>{
设索引={}，
结果=[]，
i=0；
而（i
。作为控制台包装{max height:100%！important；top:0；}
我们可以使用
%
操作符来决定是否找到要插入数组的对象：


const data=[“name”、“Tom”、“id”、“48688”、“name”、“Bob”、“id”、“91282”]；
makeObjectArray=arr=>{
常数结果=[]，温度=[]；
arr.forEach（（a，i）=>{
如果（i%2==0）
临时推送（{[arr[i]]：arr[i+1]}）
如果（i%3==0&&i！=0）{
push（Object.assign（{}，…temp））；
温度长度=0；
}
})
返回结果；
}
log（makeObjectArray（data））
您可以使用以下帮助函数将数组拆分为所需大小的小块：

function chunk(to_chunk, chunk_size) {
    var output = [];
    if(to_chunk.length > chunk_size) {
        output.push(to_chunk.slice(0, chunk_size));
        output.push(chunk(to_chunk.slice(chunk_size)));
        return output;
    } else {
        return to_chunk;
    }
}

然后，您可以使用其他函数映射结果以返回所需对象：

var final = chunk(seed, 4).map((x) => myObject(x));
function myObject(seed) {
    var output = {};
    output[seed[0]] = seed[1];
    output[seed[2]] = seed[3];
    return output;
}

我认为这种方法在可读性方面是很好的，将您所有的：


var seed=[“姓名”、“汤姆”、“身份证”、“48688”、“姓名”、“鲍勃”、“身份证”、“91282”]；
var final=chunk（seed，4）.map（（x）=>myObject（x））；
控制台日志（最终）；
功能块（到块，块大小）
{
var输出=[]；
如果（到chunk.length>chunk\u size）{
推送（到块.slice（0，块大小））；
push（chunk（到chunk.slice（chunk\u size））；
返回输出；
}否则{
返回到_chunk；
}
}
函数myObject（种子）
{
var输出={}；
输出[种子[0]]=种子[1]；
输出[种子[2]]=种子[3]；
返回输出；
}
通常会看到一个
zip
函数获取一个键
k
和一个值
v
，并用它们创建一个对象：

const-zip=
（k，v）=>
（{[k]：v}）；
zip（“姓名”、“汤姆”）；
//=>{name:“Tom”}

如果键和值都在一个数组中，您可以将其分散在类似于
zip（…arr）
的zip调用中。或者您可以稍微修改签名：

const-zip=
（[k，v]）=>
（{[k]：v}）；
邮政编码（[“姓名”，“汤姆]）；
//=>{name:“Tom”}

如果数组包含多对键和值，那么我们可以设计一个递归版本的
zip
：

const Nil=Symbol（）；
常数拉链=
（[k=Nil，v=Nil，…xs]，o={}）=>
k==Nil&&v==Nil
? o
：zip（xs，（o[k]=v，o））；
邮政编码（[“姓名”、“汤姆”、“身份证”、“48688”）；
//=>{name:“Tom”，id:“48688”}

现在，我们可以考虑将数组分为相等数量的块，并对每个块应用
zip

首先，让我们编写一个
slices
函数，该函数将数组切割成n个元素的片：

const切片=
（xs，n，ys=[]）=>
xs.length==0
? ys
：切片（xs.slice（n），n，（ys.push（xs.slice（0，n）），ys））；
切片（[“姓名”、“汤姆”、“身份证”、“48688”、“姓名”、“鲍勃”、“身份证”、“91282”]、4）；
//=>[[“姓名”、“汤姆”、“身份证”、“48688”]、[“姓名”、“鲍勃”、“身份证”、“91282”]]

我们现在可以对每个区块应用
zip
：

切片（[“姓名”、“汤姆”、“身份证”、“48688”、“姓名”、“鲍勃”、“身份证”、“91282”]，4）
.map（chunk=>zip（chunk））；
//=>[{name:“Tom”，id:“48688”}，{name:“Bob”，id:“91282”}]



const Nil=Symbol（）；
常数拉链=
（[k=Nil，v=Nil，…xs]，o={}）=>
k==Nil&&v==Nil
? o
：zip（xs，（o[k]=v，o））；
常数切片=
（xs，n，ys=[]）=>
xs.length==0
? ys
：切片（x.切片（n），n，（Y.推送（x