JavaScript中的多维关联数组

有以下查询结果：（key1和key2可以是任何文本）

我希望将数据存储在网格中（可能作为数组）循环所有记录如下：

         apple    orange   banana  melon
fred        2        4         7     -
mary        -        10        -     -
sarah       -        -         -     5

var people = ['fred', 'alice'];
var fruit = ['apples', 'lemons'];

var grid = {};
for(var i = 0; i < people.length; i++){
    var name = people[i];
    if(name in grid == false){
        grid[name] = {}; // must initialize the sub-object, otherwise will get 'undefined' errors
    }

    for(var j = 0; j < fruit.length; j++){
        var fruitName = fruit[j];
        grid[name][fruitName] = 0;
    }
}

1 : Category 1
2 : Category 2
3 : Category 3
4 : Category 4
2300 : Category 2300
2301 : Category 2301

在PHP中，使用关联数组非常容易：

$result['fred']['apple'] = 2;

但在JavaScript关联数组中，这种方法不起作用。 在阅读了大量教程后，我所能得到的是：

arr=[];
arr[1]['apple'] = 2;

但是

arr['fred']['apple']=2不起作用。
我尝试了对象数组，但对象属性不能是自由文本。
我读的教程越多，我就越糊涂

欢迎任何想法：）
不要使用数组，使用对象

var foo = new Object();

Javascript非常灵活：

var arr = {
  "fred": {"apple": 2, "orange": 4},
  "mary": {}
  //etc, etc
};

alert(arr.fred.orange);
alert(arr["fred"]["orange"]);
for (key in arr.fred)
    alert(key + ": " + arr.fred[key]);

如果它不一定是数组，您可以创建一个“多维”JS对象

<script type="text/javascript">
var myObj = { 
    fred: { apples: 2, oranges: 4, bananas: 7, melons: 0 }, 
    mary: { apples: 0, oranges: 10, bananas: 0, melons: 0 }, 
    sarah: { apples: 0, oranges: 0, bananas: 0, melons: 5 } 
}

document.write(myObj['fred']['apples']);
</script>


var myObj={
弗雷德：{苹果2个，橘子4个，香蕉7个，西瓜0个}，
玛丽：{苹果：0，橘子：10，香蕉：0，西瓜：0}，
莎拉：{苹果：0，橘子：0，香蕉：0，西瓜：5}
}
写作（myObj['fred']['apples']）；
只需使用一个常规JavaScript对象，它将以与关联数组相同的方式“读取”。您还必须记住首先初始化它们

var obj = {};

obj['fred'] = {};
if('fred' in obj ){ } // can check for the presence of 'fred'
if(obj.fred) { } // also checks for presence of 'fred'
if(obj['fred']) { } // also checks for presence of 'fred'

// The following statements would all work
obj['fred']['apples'] = 1;
obj.fred.apples = 1;
obj['fred'].apples = 1;

// or build or initialize the structure outright
var obj = { fred: { apples: 1, oranges: 2 }, alice: { lemons: 1 } };

如果您查看的是值，则可能有如下内容：

         apple    orange   banana  melon
fred        2        4         7     -
mary        -        10        -     -
sarah       -        -         -     5

var people = ['fred', 'alice'];
var fruit = ['apples', 'lemons'];

var grid = {};
for(var i = 0; i < people.length; i++){
    var name = people[i];
    if(name in grid == false){
        grid[name] = {}; // must initialize the sub-object, otherwise will get 'undefined' errors
    }

    for(var j = 0; j < fruit.length; j++){
        var fruitName = fruit[j];
        grid[name][fruitName] = 0;
    }
}

1 : Category 1
2 : Category 2
3 : Category 3
4 : Category 4
2300 : Category 2300
2301 : Category 2301

var people=['fred'，'alice']；
变量水果=['苹果'，'柠檬']；
var-grid={}；
for（var i=0；i
当我需要以一种很好的方式获取所有元素时，我遇到了这样一个主题“遍历二维关联数组/对象”-不管我叫什么名字，因为功能很重要

var imgs_pl = { 
    'offer':        { 'img': 'wer-handwritter_03.png', 'left': 1, 'top': 2 },
    'portfolio':    { 'img': 'wer-handwritter_10.png', 'left': 1, 'top': 2 },
    'special':      { 'img': 'wer-handwritter_15.png', 'left': 1, 'top': 2 }
};
for (key in imgs_pl) { 
    console.log(key);
    for (subkey in imgs_pl[key]) { 
        console.log(imgs_pl[key][subkey]);
    }
}

当属性名称为整数时，获取关联数组属性数组的值：

从属性名称为整数的关联数组开始：

var categories = [
    {"1":"Category 1"},
    {"2":"Category 2"},
    {"3":"Category 3"},
    {"4":"Category 4"}
];

将项目推送到阵列：

categories.push({"2300": "Category 2300"});
categories.push({"2301": "Category 2301"});

循环遍历数组并对属性值执行某些操作

for (var i = 0; i < categories.length; i++) {
    for (var categoryid in categories[i]) {
        var category = categories[i][categoryid];
        // log progress to the console
        console.log(categoryid + " : " + category);
        //  ... do something
    }
}

如您所见，您可以绕过关联数组限制，将属性名称设置为整数

注意：我的示例中的关联数组是序列化Dictionary[]对象时所使用的json。
对于某些应用程序，javascript中的多维关联数组有一种简单得多的方法

鉴于所有数组的内部表示实际上都是对象的对象，已经证明，数字索引元素的访问时间实际上与关联（文本）索引元素的访问时间相同

第一级关联索引元素的访问时间不会随着实际元素数量的增加而增加

考虑到这一点，在许多情况下，使用串联字符串方法来创建多维元素的等价性实际上更好。例如：

store['fruit']['apples']['granny']['price] = 10
store['cereal']['natural']['oats']['quack'] = 20

转到：

store['fruit.apples.granny.price'] = 10
store['cereal.natural.oats.quack'] = 20

优点包括：


无需初始化子对象或找出如何最好地组合对象
单级访问时间。对象中的对象需要N倍的访问时间
可以使用Object.keys（）提取所有维度信息并
可以使用键上的函数regex.test（string）和array.map函数精确提取所需内容
维度中没有层次结构
“点”是任意的-使用下划线实际上使正则表达式更容易
还有很多脚本可以将JSON“扁平化”成这种格式，也可以将JSON“扁平化”成这种格式
可以使用keylist上的所有其他nice数组处理函数


//将值设置为变量
var sectionName=“TestSection”；
var fileMap=“fileMapData”；
var fileId=“foobar”；
var fileValue=“foobar.png”；
var fileId2=“barfoo”；
var fileValue2=“barfoo.jpg”；
//创建顶级图像对象
var图像={}；
//使用对象在图像中创建第二级对象
//sectionName值的名称
图像[sectionName]={}；
//创建第三级对象
var fileMapObj={}；
//将第三层对象添加到第二层对象
images[sectionName][fileMap]=fileMapObj；
//添加第四级关联数组键和值数据
图像[sectionName][fileMap][fileId]=fileValue；
图像[sectionName][fileMap][fileId2]=fileValue2；
//所有变量
警报（“示例1值：“+images[sectionName][fileMap][fileId]）；
//所有的钥匙都有点
警报（“示例2值：”+images.TestSection.fileMapData.foobar）；
//混合了不同的最终关键点
警报（“示例3值：”+images[sectionName]['fileMapData'][fileId2]）；
//混合括号和点。。。
警报（“示例4值：”+images[sectionName]['fileMapData'].barfoo）；
//这将失败！变量名必须放在括号内！
警报（“示例5值：”+images[sectionName]['fileMapData'].fileId2）；
//产生：“示例5值：未定义”。
//这也行不通。值必须用括号括起来。
警报（“示例6值：“+images[sectionName][fileMapData].barfoo”）；
//引发异常并停止执行，但出现错误：未定义fileMapData
//我们从未到过这里，因为上面的意外例外。。。
警惕（“结束！”）；
您不必使用对象，可以使用普通的多维数组

这是我的解决方案，没有对象：

// Javascript
const matrix = [];

matrix.key1 = [
  'value1',
  'value2',
];

matrix.key2 = [
  'value3',
];

这在PHP中相当于：

// PHP
$matrix = [
    "key1" => [
        'value1',
        'value2',
    ],
    "key2" => [
        'value3',
    ]
];

输出：


基地发现
找到Base.panel.panel_Base
旧值：Base
新价值：新价值

数组操作有效。没问题

迭代：

     Object.keys(myObj['Base']).forEach(function(key, index) {            
        var value = objcons['Base'][key];                   
      }, myObj);

我想说变量名“arr”在这里用词不当，因为它实际上不是数组，而是一个对象。我是一个懒惰的人，因此不能使用您的解决方案。如果我愿意