Javascript 从链接的axios请求合并两个阵列_Javascript_Arrays_Object_Axios_Chain

Javascript 从链接的axios请求合并两个阵列

javascript arrays object

Javascript 从链接的axios请求合并两个阵列,javascript,arrays,object,axios,chain,Javascript,Arrays,Object,Axios,Chain,我将一组axios get请求链接到API的不同端点，并尝试从数据创建一个类似这样的数组（简化）：在其中一个请求中，我检索数组中每个人的姓名和id，如下所示： [ { name: "John", id: 1 }, { name: "Anna", id: 2 }, ] let peopleArray = []; axios.get('api/' + 'getPeopleArray').then(pe

我将一组axios get请求链接到API的不同端点，并尝试从数据创建一个类似这样的数组（简化）：

在其中一个请求中，我检索数组中每个人的姓名和id，如下所示：

[
    {
        name: "John",
        id: 1
    },
    {
        name: "Anna",
        id: 2
    },
]

let peopleArray = [];
axios.get('api/' + 'getPeopleArray').then(people => {
    peopleArray = people;
    people.forEach((person, index) => {
       axios.get('api/' + 'getGender?id='.concat(person.id.toString()))
           .then(gender => {
               peopleArray[index].gender = gender;
           });
    });
});

现在，我只需要通过在两个单独的请求中将每个人的id发送到端点来获取他们的性别

我花了几个小时试图用push（）和then（）在顶部构造数组，但我就是做不好

我该怎么做？

<html>

<head>
    <script src="https://unpkg.com/axios/dist/axios.min.js"></script>
</head>

<body>

    <script>

        getConnectionStatusData();

        async function getConnectionStatusData() {

            let serviceDomains = await axios.get('http://api.ntjp.se/coop/api/v1/serviceDomains.json', {
                                        params: {
                                            namespace: "crm:scheduling"
                                        }
                                    });

            serviceDomainId = serviceDomains.data[0].id;

            let connectionPoints = await axios.get('http://api.ntjp.se/coop/api/v1/connectionPoints.json', {
                                        params: {
                                            platform: "NTJP",
                                            environment: "PROD"
                                        }
                                    });

            connectionPointId = connectionPoints.data[0].id;

            let logicalAddresss = await axios.get('http://api.ntjp.se/coop/api/v1/logicalAddresss.json', {
                                        params: {
                                            logicalAdress: "SE2321000016-167N",
                                            serviceConsumerHSAId: "SE2321000016-92V4",
                                            connectionPointId: connectionPointId
                                        }
                                    });

            logicalAddressId = logicalAddresss.data[0].id;

            let serviceConsumers = await axios.get('http://api.ntjp.se/coop/api/v1/serviceConsumers.json', {
                                        params: {
                                            connectionPointId: connectionPointId,
                                            logicalAddressId: logicalAddressId
                                        }
                                    });

            consumer = serviceConsumers.data.filter(obj => {
                  return obj.hsaId === "SE2321000016-92V4"
                });

            serviceConsumerId = consumer[0].id;

            let cooperations = await axios.get('http://api.ntjp.se/coop/api/v1/cooperations.json', {
                                        params: {
                                            connectionPointId: connectionPointId,
                                            logicalAddressId: logicalAddressId,
                                            serviceDomainId: serviceDomainId,
                                            serviceConsumerId: serviceConsumerId,
                                            include: "serviceContract"
                                        }
                                    });

            for(var idx in cooperations.data) {

                var data = async () => { return await axios.get('http://api.ntjp.se/coop/api/v1/serviceProducers.json', {
                                        params: {
                                            connectionPointId: connectionPointId,
                                            logicalAddressId: logicalAddressId,
                                            serviceDomainId: serviceDomainId,
                                            serviceConsumerId: serviceConsumerId,
                                            serviceContractId: cooperations.data[idx].serviceContract.id
                                        }
                                    }) }
                cooperations.data[idx].producerDescription = data.description;
                cooperations.data[idx].producerHSAId = data.hsaId;
            }

            console.log(cooperations.data);

        }

    </script>

</body>

我正在链接axios请求，如下所示：

axios.get('api/' + endpoint1]).then(response => {
    axios.get('api/' + endpoint2).then(response => {
        axios.get('api/' + endpoint3).then(response => {
            // and so on...
         });
    });
});

更新1:

我觉得我没有正确地解释这个问题。这就是我的代码现在的样子，从上一个承诺开始。如何更改它以使数组位于问题的顶部

.then(response => {

    people= response.data; // Array of people including their name id (not their gender though)

    for (var key in people) {

        var person = {};

        person["name"] = people[key].node.name;

        person["id"] = people[key].node.id;

        finalArray.push(person);

        axios.get('api/' + endpoint3, { // Endpoint for getting a persons gender from id
            params: {
                personId: person.id
                }
        }).then(response => {

            // I don't know what to do here...            

        });

    }

    console.log(finalArray); // Gives me an array of objects without "gender".

});

更新2:

非常感谢你的回答

我结合了您的一些解决方案，这就是我现在真正的代码的外观。未发送到的请求为什么？

<html>

<head>
    <script src="https://unpkg.com/axios/dist/axios.min.js"></script>
</head>

<body>

    <script>

        getConnectionStatusData();

        async function getConnectionStatusData() {

            let serviceDomains = await axios.get('http://api.ntjp.se/coop/api/v1/serviceDomains.json', {
                                        params: {
                                            namespace: "crm:scheduling"
                                        }
                                    });

            serviceDomainId = serviceDomains.data[0].id;

            let connectionPoints = await axios.get('http://api.ntjp.se/coop/api/v1/connectionPoints.json', {
                                        params: {
                                            platform: "NTJP",
                                            environment: "PROD"
                                        }
                                    });

            connectionPointId = connectionPoints.data[0].id;

            let logicalAddresss = await axios.get('http://api.ntjp.se/coop/api/v1/logicalAddresss.json', {
                                        params: {
                                            logicalAdress: "SE2321000016-167N",
                                            serviceConsumerHSAId: "SE2321000016-92V4",
                                            connectionPointId: connectionPointId
                                        }
                                    });

            logicalAddressId = logicalAddresss.data[0].id;

            let serviceConsumers = await axios.get('http://api.ntjp.se/coop/api/v1/serviceConsumers.json', {
                                        params: {
                                            connectionPointId: connectionPointId,
                                            logicalAddressId: logicalAddressId
                                        }
                                    });

            consumer = serviceConsumers.data.filter(obj => {
                  return obj.hsaId === "SE2321000016-92V4"
                });

            serviceConsumerId = consumer[0].id;

            let cooperations = await axios.get('http://api.ntjp.se/coop/api/v1/cooperations.json', {
                                        params: {
                                            connectionPointId: connectionPointId,
                                            logicalAddressId: logicalAddressId,
                                            serviceDomainId: serviceDomainId,
                                            serviceConsumerId: serviceConsumerId,
                                            include: "serviceContract"
                                        }
                                    });

            for(var idx in cooperations.data) {

                var data = async () => { return await axios.get('http://api.ntjp.se/coop/api/v1/serviceProducers.json', {
                                        params: {
                                            connectionPointId: connectionPointId,
                                            logicalAddressId: logicalAddressId,
                                            serviceDomainId: serviceDomainId,
                                            serviceConsumerId: serviceConsumerId,
                                            serviceContractId: cooperations.data[idx].serviceContract.id
                                        }
                                    }) }
                cooperations.data[idx].producerDescription = data.description;
                cooperations.data[idx].producerHSAId = data.hsaId;
            }

            console.log(cooperations.data);

        }

    </script>

</body>

我也不想在调用之前将整个对象保存在cooperations响应数组中。我只想从每个对象保存两个特定的键/值对。这两个键/值对都位于每个响应对象中名为“serviceContract”的对象中如何保存它们？

<html>

<head>
    <script src="https://unpkg.com/axios/dist/axios.min.js"></script>
</head>

<body>

    <script>

        getConnectionStatusData();

        async function getConnectionStatusData() {

            let serviceDomains = await axios.get('http://api.ntjp.se/coop/api/v1/serviceDomains.json', {
                                        params: {
                                            namespace: "crm:scheduling"
                                        }
                                    });

            serviceDomainId = serviceDomains.data[0].id;

            let connectionPoints = await axios.get('http://api.ntjp.se/coop/api/v1/connectionPoints.json', {
                                        params: {
                                            platform: "NTJP",
                                            environment: "PROD"
                                        }
                                    });

            connectionPointId = connectionPoints.data[0].id;

            let logicalAddresss = await axios.get('http://api.ntjp.se/coop/api/v1/logicalAddresss.json', {
                                        params: {
                                            logicalAdress: "SE2321000016-167N",
                                            serviceConsumerHSAId: "SE2321000016-92V4",
                                            connectionPointId: connectionPointId
                                        }
                                    });

            logicalAddressId = logicalAddresss.data[0].id;

            let serviceConsumers = await axios.get('http://api.ntjp.se/coop/api/v1/serviceConsumers.json', {
                                        params: {
                                            connectionPointId: connectionPointId,
                                            logicalAddressId: logicalAddressId
                                        }
                                    });

            consumer = serviceConsumers.data.filter(obj => {
                  return obj.hsaId === "SE2321000016-92V4"
                });

            serviceConsumerId = consumer[0].id;

            let cooperations = await axios.get('http://api.ntjp.se/coop/api/v1/cooperations.json', {
                                        params: {
                                            connectionPointId: connectionPointId,
                                            logicalAddressId: logicalAddressId,
                                            serviceDomainId: serviceDomainId,
                                            serviceConsumerId: serviceConsumerId,
                                            include: "serviceContract"
                                        }
                                    });

            for(var idx in cooperations.data) {

                var data = async () => { return await axios.get('http://api.ntjp.se/coop/api/v1/serviceProducers.json', {
                                        params: {
                                            connectionPointId: connectionPointId,
                                            logicalAddressId: logicalAddressId,
                                            serviceDomainId: serviceDomainId,
                                            serviceConsumerId: serviceConsumerId,
                                            serviceContractId: cooperations.data[idx].serviceContract.id
                                        }
                                    }) }
                cooperations.data[idx].producerDescription = data.description;
                cooperations.data[idx].producerHSAId = data.hsaId;
            }

            console.log(cooperations.data);

        }

    </script>

</body>

我不太确定你的具体问题。但假设您的意思是有两个端点，第一个是返回对象数组的端点（我们称之为

'getPeopleArray'

）：

第二个端点返回给定

id

的

gender

（让我们用一个参数

id

将其称为

'getGender'

），

.push

将不会为您执行此任务

您的问题可以通过以下方式解决：

[
    {
        name: "John",
        id: 1
    },
    {
        name: "Anna",
        id: 2
    },
]

let peopleArray = [];
axios.get('api/' + 'getPeopleArray').then(people => {
    peopleArray = people;
    people.forEach((person, index) => {
       axios.get('api/' + 'getGender?id='.concat(person.id.toString()))
           .then(gender => {
               peopleArray[index].gender = gender;
           });
    });
});

首先，保存第一个请求返回的数组，然后必须循环该数组中的每个对象，使用

[].forEach（callbackfn）

的

index

参数从第二个端点获取并分配其

性别。只要在所有请求完成期间或之前没有使用peopleArray
进行操作，索引就会正确
更新2:
针对您在评论中提出的问题“为什么.推送不起作用？”，如果您想使用.push
结束算法，并且不使用跟踪索引，我决定采用另一种方法
let peopleArray = [];
axios.get('api/' + 'getPeopleArray').then(people => {
    people.forEach((person) => {
       axios.get('api/' + 'getGender?id='.concat(person.id.toString()))
           .then(gender => {
               peopleArray.push({id: person.id, name: person.name, gender, gender});
           });
    });
});

通过这种方式，只有在获取对象的性别时，才会将对象推送到集合peopleArray
。这还将消除使用.map
（如注释中所建议）仅存储您希望保留的单个对象的属性的情况，因为您在第行peopleArray.push上推送了一个新的结构化对象（{id:person.id，name:person.name，gender，gender}）
我不喜欢阅读连锁承诺，而是喜欢使用async/await
。您可以先获取列表，然后使用地图循环该列表，并请求每个姓名的性别。请记住，在继续之前，您必须等待映射中的所有承诺都得到解决
const axios = require('axios');

async function getPeople() {
    let firstResult = await axios.get('api/path/endpoint1');
    // firstResult = [{name: "John", id: 1}, {name: "Anna", id: 2}]

    let updatedResult = firstResult.map(async item => {
        let people = await axios.get('api/path/endpoint2' + item.name); // or however your endpoint is designed 
        // people = {name: "John", id: 1, gender: male}
        item.gender = people.gender;
        return item; 
    });
    // updatedResult = undefined

    Promise.all(updatedResult)
        .then(finalResult => console.log(finalResult));
    //  [{name: "John", id: 1, gender: male}, {name: "Anna", id: 2, gender: female}]
}

您可以使用async/awaits并将gender
键重新分配给第一个端点数据
var users;
axios.get('api/' + endpoint1]).then(response => {
   users = response; // assume all user id list
   for(var idx in users) {
     var data = async () => { return await axios.get('api/' + users[idx].id) } //get gender api by user id
     users[idx].gender = data.gender; //create gender key value 
   }
   console.log(users);
});

只需将endpoint1修改为包含性别！它将保存编码行和服务器请求：）@ﾃﾞﾋﾞｯﾄ: API不是我的。看看你有没有想过使用wait
？这可能会清理你的代码第二个请求的结果是什么？哇！我试试看。但是在每次调用之后，在执行下一次调用之前，我必须对检索到的数据运行一些过滤函数等。如下所示：var John=response.data.filter（obj=>{return obj.someretriedvalue===someStoredValue}）如何实现它？在进行下一步之前，您可以在每次调用后执行任何您想要的操作。所以你可以简单地在中间加上一行，没问题：）为什么Promise.all是必需的？等待不是意味着在接下一个电话之前等待吗？如果我有10个电话，我是否需要将他们所有的名字（让我们）都放在Promise.all（）中？如果你wait
在map
中，它将返回需要解决的承诺。将名称放入map函数中。因此，您创建了一个name=[“Alex”，“Anna”]数组，并使用该数组调用map names.map（//这里的异步函数）。完成后，您使用名称作为参数，如下所示：Promise.all（name）.then（result=>console.log（result））好的，下面是我对真实数据的了解：由于API在http上，所以无法运行fiddle，但您至少可以看到代码。注意结尾的评论。这就是我被困的地方。你能帮帮我吗？我想JavaScriptMy bad中没有等待
关键字！谢谢你的提醒！请看我原来帖子的更新2。谢谢！推不起作用的原因是什么？另外，来自getPeopleArray的响应包含一组我不想保存的数据。我只想保存姓名和身份证。它还能用吗？谢谢！请查看我的原始帖子的更新2。@RawlandHustle是的，您实际上可以使用.map
保存数组中每个对象的特定属性。因此，您不必只在peopleArray
中保存人员（查看给定的示例peopleArray=people；
），而必须使用.map。示例：peopleArray=people.map（p=>{id:p.id，name:p.name}）
@RawlandHustle，.push
执行它应该执行的操作，即向数组中添加一个元素。在您的情况下，您不希望将性别推送到id名称对象的数组中。您将获得类似于[{id:1，name:'abc'}，{id:2，name:'def'}，'female']
的内容，而不是添加gender
属性