在数组javascript的排序函数中实现async/await

我正在尝试在量角器 ElementArrayFinder 上实现排序方法.众所周知，所有量角器方法都返回承诺.所以我的排序方法有一个取决于承诺解决的条件.我正在为 async/await 使用节点插件，以使其与低于 6 的 node.js 版本兼容.(这里的插件:https://www.npmjs.com/package/asyncawait)p>

这是我的代码，其中 this 是 ArrayElementFinder:

var asyncCompare = async(function(a, b) {让 x = 等待 (a.getText());让 y = 等待 (b.getText());控制台.log(x.localeCompare(y));返回 x.localeCompare(y);});var sortTheArray = async(函数(arrayOfElementFinders){返回等待(arrayOfElementFinders.sort(asyncCompare))；});this.then((元素) => {让arrayOfElementFinders = [元素[0]，元素[1]，元素[2]]；让 sortedArray = sortTheArray(arrayOfElementFinders);console.log('数组排序');});

不幸的是，时间执行不是我所期望的.print: array sorted 发生在比较 x.localeCompare(y) 之前.知道我在做什么错吗?知道如何实现我的目标吗?

非常感谢您的帮助

解决方案

sort 不采用异步回调.它期望一个数值作为返回值，而不是一个承诺；它确实返回一个数组而不是一个承诺.没有办法解决这个问题(尽管可以实现自定义的异步排序算法——甚至是并行算法).

但这无论如何都是非常低效的.在每个排序步骤中异步获取比较值会很慢 - 它会多次获取每个元素的相同值.不要那样做.相反，使用 Schwartzian 变换 来获取要排序的值，然后排序(同步)，然后使用结果.

你应该这样做

const 元素 = 等待这个；const arrayOfElementFinders = elements.slice(0, 3);//还是 Array.from?常量可比较数组 = await Promise.all(arrayOfElementFinders.map(async x => [await x.getText(), x]));compareArray.sort((a, b) => +(a[0] > b[0]) || -(a[0] < b[0]));const sortedArray = compatibleArray.map(x => x[1]);console.log('数组排序');

I am trying to implement a sort method on protractor ElementArrayFinder. As known, all protractor methods return promises. So my sort method has a condition which depends on promises resolution. I am using a node plugin for async/await in order to make it compatible with node.js versions lower than 6. (Here the plugin: https://www.npmjs.com/package/asyncawait)

Here my code, where this is the ArrayElementFinder:

var asyncCompare = async(function(a, b) {
    let x = await (a.getText());
    let y = await (b.getText());
    console.log(x.localeCompare(y));
    return x.localeCompare(y);
});

var sortTheArray = async(function(arrayOfElementFinders) {
    return await (arrayOfElementFinders.sort(asyncCompare));
});

this.then((elements) => {
    let arrayOfElementFinders = [elements[0], elements[1], elements[2]];
    let sortedArray = sortTheArray(arrayOfElementFinders);
    console.log('array sorted');
});

Unfortunately the timing execution is not the one I expect. The print: array sorted happens before than the prints of comparing x.localeCompare(y). Any idea what am I doing wrong? And any idea how to achieve my objective?

Thanks a lot for any help

解决方案

sort does not take an asynchronous callback. It expects a numeric value as the return value, not a promise for one; and it does return an array not a promise. There's no way around this (though one could implement a custom asynchronous sorting algorithm - even a parallel one).

But that's pretty inefficient anyway. Doing asynchronous fetching of compare values in every sort step will be slow - and it will fetch the same value per element multiple times. Don't do that. Instead, use a Schwartzian transform to fetch the values to sort by before, then sort (synchronously), then use the results.

You should do

const elements = await this;
const arrayOfElementFinders = elements.slice(0, 3); // or Array.from?
const comparableArray = await Promise.all(arrayOfElementFinders.map(async x => [await x.getText(), x]));
comparableArray.sort((a, b) => +(a[0] > b[0]) || -(a[0] < b[0]));
const sortedArray = comparableArray.map(x => x[1]);
console.log('array sorted');