取消隐藏和加载webview的顺序是否会影响性能？(Does the order of unhiding and loading a webview affect performance?)

 
 
 当我将其注销时，为什么我的问题变量为空？ 有明显的结果与它相结合。 
 
 
 这里的一个主要问题是.concat()返回一个新数组。 它不会将项添加到现有阵列上。 
 
 你可以改变这个： 
 
issues.concat(JSON.parse(body).issues);
 
 对此： 
 
issues = issues.concat(JSON.parse(body).issues);
 
 确保保留新的连锁数组。 这是一个非常常见的错误。 
 
 
 您也可能在数组中遇到排序问题，因为您正在运行for循环，它会同时启动一大堆请求，结果可能会或可能不会以正确的顺序返回。 您仍将获得正确的问题总数，但它们可能不符合要求的顺序。 我不知道你是否有问题。 如果这是一个问题，我们也可以建议修复。 
 
 
 
 一个更普遍的问题：这种方法是解决我想要实现的目标的最佳方式吗？ 我认为即使我的代码确实有效，异步性的本质意味着结果可能以错误的顺序连接起来。 
 
 
 除了也可以修复的订购问题，这是一种合理的做事方式。 我们需要了解有关您的API的更多信息，以了解这是否是使用API​​获取结果的最有效方式。 通常，您希望避免对同一服务器进行N次重复API调用，而是进行一次API调用以获取所有结果。 
 
 
 
 我应该只使用同步请求库吗？ 
 
 
 绝对不。 node.js需要学习如何进行异步编程。 对于大多数人来说，这是一个学习步骤，但是你是如何从node.js获得最佳性能的，应该学习和使用它。 
 
 
 这是一种使用promises进行同步和错误传播的可靠顺序收集所有结果的方法（这对于node.js中的异步处理非常有用）： 
 
// promisify the request() function so it returns a promise
// whose fulfilled value is the request result
function requestP(url) {
    return new Promise(function(resolve, reject) {
        request(url, function(err, response, body) {
            if (err || response.statusCode !== 200) {
                reject({err: err, response: response});
            } else {
                resolve({response: response, body: body});
            }
        });
    });
}

Donedone.prototype.getAllActiveIssues = function() {
    var url = this.url;
    return requestP(url + `/issues/all_active.json?take=500`).then(function(results) {
        var data = JSON.parse(results.body);
        var totalIssues = data.total_issues;
        var promises = [];
        for (let i = 0; i < totalIssues; i+= 500) {
            promises.push(requestP(url + `/issues/all_active.json?skip=${i}&take=500`).then(function(results) {
                return JSON.parse(results.body).issues;                
            }));
        }
        return Promise.all(promises).then(function(results) {
            // results is an array of each chunk (which is itself an array) so we have an array of arrays
            // now concat all results in order
            return Array.prototype.concat.apply([], results);
        })
    });
}

xxx.getAllActiveIssues().then(function(issues) {
    // process issues here
}, function(err) {
    // process error here
})

 
 
Why is my issues variable empty when I log it out? There are clearly results to concatenate with it.
 
 
A main problem here is that .concat() returns a new array. It doesn't add items onto the existing array.
 
You can change this:
 
issues.concat(JSON.parse(body).issues);
 
to this:
 
issues = issues.concat(JSON.parse(body).issues);
 
to make sure you are retaining the new concatenated array. This is a very common mistake.
 
 
You also potentially have sequencing issues in your array because you are running a for loop which is starting a whole bunch of requests at the same time and results may or may not arrive back in the proper order. You will still get the proper total number of issues, but they may not be in the order requested. I don't know if that is a problem for you or not. If that is a problem, we can also suggest a fix for that.
 
 
 
A more general question: is this approach the best way to go about what I'm trying to achieve? I figured that even if my code did work, the nature of asynchronicity means it's entirely possible for the results to be concatenated in the wrong order.
 
 
Except for the ordering issue which can also be fixed, this is a reasonable way to do things. We would have to know more about your API to know if this is the most efficient way to use the API to get your results. Usually, you want to avoid making N repeated API calls to the same server and you'd rather make one API call to get all the results.
 
 
 
Should I just use a synchronous request library?
 
 
Absolutely not. node.js requires learning how to do asynchronous programming. It is a learning step for most people, but is how you get the best performance from node.js and should be learned and used.
 
 
Here's a way to collect all the results in reliable order using promises for synchronization and error propagation (which is hugely useful for async processing in node.js):
 
// promisify the request() function so it returns a promise
// whose fulfilled value is the request result
function requestP(url) {
    return new Promise(function(resolve, reject) {
        request(url, function(err, response, body) {
            if (err || response.statusCode !== 200) {
                reject({err: err, response: response});
            } else {
                resolve({response: response, body: body});
            }
        });
    });
}

Donedone.prototype.getAllActiveIssues = function() {
    var url = this.url;
    return requestP(url + `/issues/all_active.json?take=500`).then(function(results) {
        var data = JSON.parse(results.body);
        var totalIssues = data.total_issues;
        var promises = [];
        for (let i = 0; i < totalIssues; i+= 500) {
            promises.push(requestP(url + `/issues/all_active.json?skip=${i}&take=500`).then(function(results) {
                return JSON.parse(results.body).issues;                
            }));
        }
        return Promise.all(promises).then(function(results) {
            // results is an array of each chunk (which is itself an array) so we have an array of arrays
            // now concat all results in order
            return Array.prototype.concat.apply([], results);
        })
    });
}

xxx.getAllActiveIssues().then(function(issues) {
    // process issues here
}, function(err) {
    // process error here
})