Question

我想最终得到类似的东西：

{
Link:
    [
        {
            'Key':String,
            'Versions':[]
        }
    ]
}

Key是动态的，而不是名为Key的字符串。

例如，这可能是：

{
    Link:[
        {
            'Hello':'Hi!',
            'Versions':[1,2,3]
        },
        {
            'Foo':'Bar',
            'Versions':[5g32,6392]
        }
    ]
}

我希望迭代填写此对象，使用Array.push填写Version的值，因此我的程序需要知道Versions的值是一个数组。 / p>

我该怎么做？

另一个问题linked here没有回答我的问题，因为这是一对一的关系。

我需要1对多的关系。

我需要一个键来链接到一组值。

我想要配对的数据源来自单个数组，这就是我需要迭代执行此操作的原因。

Versions的键和值都在此单个数组中。

他们至少是有序的。

我的数据源类似于：

[
 {
   Key:'Slide1',
   Version: 'FSDdfgonbwipoenv',
 },
 {
   Key:'Slide1',
   Version : 'DFpiesenfsgbv',
 },
 {
  Key:'Slide2',
  Version: 'SpShdpkins',
 }
]

因此，只需遍历数组并将各条信息链接在一起就很容易，这样就形成了

[
 {
  Key:'Slide1',
  Version: ['FSDdfgonbwipoenv','DFpiesenfsgbv']
 ...etc

Answer 1

编辑：现在您已经包含了有关您实际尝试的更多信息：

您的数据结构对您尝试的操作不是很友好。如果每个项目都具有唯一键，则Link的数组是错误的结构类型。但是，如果这是你想要的，那么你必须搜索数组以找到匹配的密钥：

// versions to add for given Key values
var newInfo = [
 {
   Key:'Slide1',
   Version: 'FSDdfgonbwipoenv',
 },
 {
   Key:'Slide1',
   Version : 'DFpiesenfsgbv',
 },
 {
  Key:'Slide2',
  Version: 'SpShdpkins',
 }
];

// original data structure
var data = {Link: []};

// function to take an array of objects in newInfo and add them to the
// data structure
function addVersions(info) {
    var link = data.Link;

    // find a given key in the Link array
    function findKey(key) {
        for (var i = 0; i < link.length; i++) {
           if (link[i].Key === key) {
               return link[i];
           }
        }
    }

    // go through each item in the new info
    for (var i = 0; i < info.length; i++) {
        // find the right key
        var o = findKey(info[i].Key);
        // if we didn't find the key, then create one
        // and add it to the data structure
        if (!o) {
            o = {Key: info[i].Key, Version: []};
            link.push(o);
        }
        // add this new version onto the array for the right key
        o.Version.push(info[i].Version);
    }

}

编辑问题之前的原始答案指出了另一个问题。

你可以这样做：

// construct shell of the object
var data = {Link: []};

// directly .push() a new object where everything is known statically
data.Link.push({Hello: 'Hi!', Versions: [1,2,3]});

// .push() a new object where you have to build the object from the contents
// of other variables
var key1 = "Foo";
var key2 = "Versions";
var data1 = "Bar";
var data2 = [5g32,6392];
var obj = {};
obj[key1] = data1;
obj[key2] = data2;
data.Link.push(obj);

console.log(data.Link.length);   // an array of two objects

关键是这种语法，用于通过变量中包含的名称分配属性，而在编写代码时不知道：

    obj[key1] = data1;

你最终会得到这个：

var data = {
    Link:[
        {
            'Hello':'Hi!',
            'Versions':[1,2,3]
        },
        {
            'Foo':'Bar',
            'Versions':[5g32,6392]
        }
    ]
};

当然，如果您已经拥有了对象的链接数组并且想要添加版本，则可以使用.push（）将版本号添加到Versions数组中：

data.Link[0].Versions.push(4);

将上述数据结构更改为：

var data = {
    Link:[
        {
            'Hello':'Hi!',
            'Versions':[1,2,3, 4]
        },
        {
            'Foo':'Bar',
            'Versions':[5g32,6392]
        }
    ]
};

或者，如果你想动态迭代链接数组，你可以这样做：

for (var i = 0; i < data.Link.length; i++) {
    data.Link[i].Versions.push(xxx);
}

Answer 2

我通过这样做来修复它：

var link={};
for(i=0;i<data2.Versions.length;i++){
    if(!(typeof link[data2.Versions[i].Key] === 'undefined')){
        link[data2.Versions[i].Key] ['Versions'].push(data2.Versions[i].VersionId);
    }else{
        link[data2.Versions[i].Key] = {Versions:[]};
        link[data2.Versions[i].Key] ['Versions'].push(data2.Versions[i].VersionId);
    }

}

很简单。

如何在没有对象的对象内部定义数组？

2 个答案: