像矩阵一样访问javaScript对象数组

是否可以将对对象属性的访问转换为像矩阵一样的对象数组

我的意思是这样的：

jSon生成的对象：

[
    {
        "Nome": "1",
        "Departamento": "1",
        "Cargo": "1"
    },
    {
        "Nome": "5",
        "Departamento": "5",
        "Cargo": "5"
    },
    {
        "Nome": "2",
        "Departamento": "2",
        "Cargo": "2"
    },
    {
        "Nome": "3",
        "Departamento": "33",
        "Cargo": "33"
    },
    {
        "Nome": "4",
        "Departamento": "4",
        "Cargo": "4"
    }
]

object[0][1] = value;

object[0]["Nome"] = value;

我如何尝试访问对象属性：

[
    {
        "Nome": "1",
        "Departamento": "1",
        "Cargo": "1"
    },
    {
        "Nome": "5",
        "Departamento": "5",
        "Cargo": "5"
    },
    {
        "Nome": "2",
        "Departamento": "2",
        "Cargo": "2"
    },
    {
        "Nome": "3",
        "Departamento": "33",
        "Cargo": "33"
    },
    {
        "Nome": "4",
        "Departamento": "4",
        "Cargo": "4"
    }
]

object[0][1] = value;

object[0]["Nome"] = value;

我已经在做的事情：

[
    {
        "Nome": "1",
        "Departamento": "1",
        "Cargo": "1"
    },
    {
        "Nome": "5",
        "Departamento": "5",
        "Cargo": "5"
    },
    {
        "Nome": "2",
        "Departamento": "2",
        "Cargo": "2"
    },
    {
        "Nome": "3",
        "Departamento": "33",
        "Cargo": "33"
    },
    {
        "Nome": "4",
        "Departamento": "4",
        "Cargo": "4"
    }
]

object[0][1] = value;

object[0]["Nome"] = value;

我找了很多，但找不到解决这个问题的办法。

没有

对象和数组在JavaScript中是两种截然不同的类型。在数组中，顺序非常重要，但不会保留对象关键帧的顺序。请记住，您仍然可以迭代对象的键

for (var prop in myObj) {
  console.log("myObj.prop -> ", myObj[prop]);
}

没有

对象和数组在JavaScript中是两种截然不同的类型。在数组中，顺序非常重要，但不会保留对象关键帧的顺序。请记住，您仍然可以迭代对象的键

for (var prop in myObj) {
  console.log("myObj.prop -> ", myObj[prop]);
}

如前所述，s和s是不同的。我不真的按照你的推理从一个结构转换到另一个结构，你应该考虑以不同的方式工作，这完全可以从你的问题和评论描述。但是，如果您真的必须转换，那么您将需要执行某种映射，以确保事物的顺序正确。你可以这样做

Javascript

function toMapped (array) {
    var mapping = {
            "Nome": 0,
            "Departamento": 1,
            "Cargo": 2
        },
        mapped = [],
        length = array.length,
        i = 0,
        element,
        j;

    while (i < length ) {
        element = [];

        for (j in mapping) {
            if (mapping.hasOwnProperty(j) && array[i].hasOwnProperty(j)) {
                element[mapping[j]] = array[i][j];
            }
        }

        mapped.push(element);
        i += 1;
    }

    return mapped;
}

function fromMapped (array) {
    var mapping = {
            0: "Nome",
            1: "Departamento",
            2: "Cargo"
        },
        mapped = [],
        length = array.length,
        i = 0,
        object,
        j;

    while (i < length ) {
        object = {};
        for (j in mapping) {
            if (mapping.hasOwnProperty(j) && array[i].hasOwnProperty(j)) {
                object[mapping[j]] = array[i][j];
            }
        }

        mapped.push(object);
        i += 1;
    }

    return mapped;
}

var test = [{
    "Nome": "1",
    "Departamento": "1",
    "Cargo": "1"
}, {
    "Nome": "5",
    "Departamento": "5",
    "Cargo": "5"
}, {
    "Nome": "2",
    "Departamento": "2",
    "Cargo": "2"
}, {
    "Nome": "3",
    "Departamento": "33",
    "Cargo": "33"
}, {
    "Nome": "4",
    "Departamento": "4",
    "Cargo": "4"
}];

var mapped = toMapped(test);
var unmapped = fromMapped(mapped);

console.log(test);
console.log(mapped);
console.log(unmapped);

function toMapped(array) {
    var mapping = {
        "Nome": 0,
        "Departamento": 1,
        "Cargo": 2
    };

    return array.map(function (object) {
        var element = [],
            i;

        for (i in mapping) {
            if (mapping.hasOwnProperty(i) && object.hasOwnProperty(i)) {
                element[mapping[i]] = object[i];
            }
        }

        return element;
    });
}

function fromMapped(array) {
    var mapping = {
        0: "Nome",
        1: "Departamento",
        2: "Cargo"
    };

    return array.map(function (element) {
        var object = {},
            i;

        for (i in mapping) {
            if (mapping.hasOwnProperty(i) && element.hasOwnProperty(i)) {
                object[mapping[i]] = element[i];
            }
        }

        return object;
    });
}

var test = [{
    "Nome": "1",
        "Departamento": "1",
        "Cargo": "1"
}, {
    "Nome": "5",
        "Departamento": "5",
        "Cargo": "5"
}, {
    "Nome": "2",
        "Departamento": "2",
        "Cargo": "2"
}, {
    "Nome": "3",
        "Departamento": "33",
        "Cargo": "33"
}, {
    "Nome": "4",
        "Departamento": "4",
        "Cargo": "4"
}];

var mapped = toMapped(test);
var unmapped = fromMapped(mapped);

console.log(test);
console.log(mapped);
console.log(unmapped);

如前所述，s和s是不同的。我不真的按照你的推理从一个结构转换到另一个结构，你应该考虑以不同的方式工作，这完全可以从你的问题和评论描述。但是，如果您真的必须转换，那么您将需要执行某种映射，以确保事物的顺序正确。你可以这样做

Javascript

function toMapped (array) {
    var mapping = {
            "Nome": 0,
            "Departamento": 1,
            "Cargo": 2
        },
        mapped = [],
        length = array.length,
        i = 0,
        element,
        j;

    while (i < length ) {
        element = [];

        for (j in mapping) {
            if (mapping.hasOwnProperty(j) && array[i].hasOwnProperty(j)) {
                element[mapping[j]] = array[i][j];
            }
        }

        mapped.push(element);
        i += 1;
    }

    return mapped;
}

function fromMapped (array) {
    var mapping = {
            0: "Nome",
            1: "Departamento",
            2: "Cargo"
        },
        mapped = [],
        length = array.length,
        i = 0,
        object,
        j;

    while (i < length ) {
        object = {};
        for (j in mapping) {
            if (mapping.hasOwnProperty(j) && array[i].hasOwnProperty(j)) {
                object[mapping[j]] = array[i][j];
            }
        }

        mapped.push(object);
        i += 1;
    }

    return mapped;
}

var test = [{
    "Nome": "1",
    "Departamento": "1",
    "Cargo": "1"
}, {
    "Nome": "5",
    "Departamento": "5",
    "Cargo": "5"
}, {
    "Nome": "2",
    "Departamento": "2",
    "Cargo": "2"
}, {
    "Nome": "3",
    "Departamento": "33",
    "Cargo": "33"
}, {
    "Nome": "4",
    "Departamento": "4",
    "Cargo": "4"
}];

var mapped = toMapped(test);
var unmapped = fromMapped(mapped);

console.log(test);
console.log(mapped);
console.log(unmapped);

function toMapped(array) {
    var mapping = {
        "Nome": 0,
        "Departamento": 1,
        "Cargo": 2
    };

    return array.map(function (object) {
        var element = [],
            i;

        for (i in mapping) {
            if (mapping.hasOwnProperty(i) && object.hasOwnProperty(i)) {
                element[mapping[i]] = object[i];
            }
        }

        return element;
    });
}

function fromMapped(array) {
    var mapping = {
        0: "Nome",
        1: "Departamento",
        2: "Cargo"
    };

    return array.map(function (element) {
        var object = {},
            i;

        for (i in mapping) {
            if (mapping.hasOwnProperty(i) && element.hasOwnProperty(i)) {
                object[mapping[i]] = element[i];
            }
        }

        return object;
    });
}

var test = [{
    "Nome": "1",
        "Departamento": "1",
        "Cargo": "1"
}, {
    "Nome": "5",
        "Departamento": "5",
        "Cargo": "5"
}, {
    "Nome": "2",
        "Departamento": "2",
        "Cargo": "2"
}, {
    "Nome": "3",
        "Departamento": "33",
        "Cargo": "33"
}, {
    "Nome": "4",
        "Departamento": "4",
        "Cargo": "4"
}];

var mapped = toMapped(test);
var unmapped = fromMapped(mapped);

console.log(test);
console.log(mapped);
console.log(unmapped);

---

在

上，不能以与数组索引相同的方式访问对象的属性（这似乎是您尝试执行的操作）。如果您需要使用索引来访问这些值，我建议将这些对象转换为数组。如何进行此转换？我能把数组转换成矩阵，然后再转换成对象数组吗？@Wellington:你需要矩阵做什么？属性名会发生什么变化（它们不包含在矩阵中，因此转换回属性名很复杂）？您希望项目的值按什么顺序排列，当前对象是无序的？如果您确实需要进行转换，您可以使用以下方法进行转换：@Wellington:但您不需要矩阵，您当前的结构完全可以。当然，具有附加标题信息（和列顺序）的类似CSV的结构也可以工作，但这不是必需的。您不能像访问数组索引那样访问对象的属性（这似乎是您尝试执行的操作）。如果您需要使用索引来访问这些值，我建议将这些对象转换为数组。如何进行此转换？我能把数组转换成矩阵，然后再转换成对象数组吗？@Wellington:你需要矩阵做什么？属性名会发生什么变化（它们不包含在矩阵中，因此转换回属性名很复杂）？您希望项目的值按什么顺序排列，当前对象是无序的？如果您确实需要进行转换，您可以使用以下方法进行转换：@Wellington:但您不需要矩阵，您当前的结构完全可以。当然，具有附加标题信息（和列顺序）的类似CSV的结构也可以工作，但这不是必需的。我建议只在

映射上迭代/枚举，而不是在
对象上迭代/枚举。另外，你真的应该使用
map
函数，而不是
forEach
。当然，这可以用很多方法来实现，在这样的例子中，我通常会使用
while
，以实现跨浏览器兼容性，但是使用
forEach
有点懒/时间短。但是肯定
map
也适用于ECMA5方法。@Bergi根据您的建议进行了更新。我建议只迭代/枚举
映射
，而不是
对象
/
子数组
。另外，你真的应该使用
map
函数，而不是
forEach
。当然，这可以用很多方法来实现，在这样的例子中，我通常会使用
while
，以实现跨浏览器兼容性，但是使用
forEach
有点懒/时间短。但是肯定
map
也适用于ECMA5方法。@Bergi更新了您的建议。