Parse platform Parse.Object.saveAll与单独保存相比是否具有成本优势？

Parse JS SDK提供了一个

Parse.Object.saveAll（）

方法，可以用一个命令保存多个对象

从外观上看，似乎每个对象都是单独保存的：

if (path === '/batch') {
    let initialPromise = Promise.resolve();
    if (data.transaction === true) {
        initialPromise = config.database.createTransactionalSession();
    }
    return initialPromise.then(() => {
        const promises = data.requests.map(request => {
            return handleRequest(
                request.method,
                request.path,
                request.body,
                options,
                config
            ).then(
                response => {
                    return {
                        success: response
                    };
                },
                error => {
                    return {
                        error: {
                            code: error.code,
                            error: error.message
                        },
                    };
                }
            );
        });
        return Promise.all(promises).then(result => {
            if (data.transaction === true) {
                if (
                    result.find(resultItem => typeof resultItem.error === 'object')
                ) {
                    return config.database.abortTransactionalSession().then(() => {
                        return Promise.reject(result);
                    });
                } else {
                    return config.database.commitTransactionalSession().then(() => {
                        return result;
                    });
                }
            } else {
                return result;
            }
        });
    });
}

似乎

saveAll

只是一个单独保存每个对象的方便包装器，因此它似乎仍然对

n

对象发出

n

数据库请求

---

与在云代码中单独保存每个对象相比，

saveAll

没有成本优势（性能、网络流量等），这是正确的吗？

我可以告诉你答案是，

Parse.object.saveAll

和

Parse.object.destroall

批量对象请求。但为什么要相信我的话呢？让我们测试一下

打开详细日志记录，然后运行以下操作：

const run=async function run（）{
constobjects=[…数组（10）.keys（）].map（i=>newparse.Object（'Test'）.set（{i}））；
等待Parse.Object.saveAll（对象）；
const promises=objects.map（o=>o.increment（'i'）.save（））；
返回承诺。全部（承诺）；
};
运行（）
.then（console.log）
.catch（控制台错误）；

下面是解析服务器日志的输出（我已经截断了它，但它应该足以清楚地显示发生了什么）：

---

verbose:请求[POST]/parse/batch:{//谢谢，我应该提到我指的是云代码，我的错。重点是解析服务器和数据存储之间的数据流量和请求成本。这证实了没有成本优势。云代码调用
localhost
？据我所知，这不会产生数据流量费用，至少在大多数IaaS上是这样。在哪方面效率更高？我可以在调用localhost端口时考虑一些请求限制，但这超出了我的范围：）效率更高，因为TCP和HTTP有开销，所以对20个对象的一个请求比对1个对象的20个请求更有效。在解析服务器上也有一些边际效率节约，例如，只检查一次请求头，而不是检查20次。换句话说，批处理时您可以更有效地使用资源。这是有道理的，并且在查看规模时也有$implementation。
verbose: REQUEST for [POST] /parse/batch: { // <--- note the path
  "requests": [ // <--- an array of requests!!!
    {
      "method": "POST",
      "body": {
        "i": 0
      },
      "path": "/parse/classes/Test"
    },

    ... skip the next 7, you get the idea

    {
      "method": "POST",
      "body": {
        "i": 9
      },
      "path": "/parse/classes/Test"
    }
  ]
} 
.... // <-- remove some irrelevent output for brevity.
verbose: RESPONSE from [POST] /parse/batch: { 
  "response": [
    {
      "success": {
        "objectId": "szVkuqURVq",
        "createdAt": "2020-03-05T21:25:44.487Z"
      }
    },
    ...
    {
      "success": {
        "objectId": "D18WB4Nsra",
        "createdAt": "2020-03-05T21:25:44.491Z"
      }
    }
  ]
} 
...

// now we iterate through and there's a request per object.
verbose: REQUEST for [PUT] /parse/classes/Test/szVkuqURVq: {
  "i": {
    "__op": "Increment",
    "amount": 1
  }
} 
...
verbose: REQUEST for [PUT] /parse/classes/Test/HtIqDIsrX3: {
  "i": {
    "__op": "Increment",
    "amount": 1
  }
} 
// and the responses...
verbose: RESPONSE from [PUT] /parse/classes/Test/szVkuqURVq: {
  "response": {
    "i": 1,
    "updatedAt": "2020-03-05T21:25:44.714Z"
  }
}
...