Javascript 等待flag=true
我有如下javascript函数：Javascript 等待flag=true,javascript,synchronization,Javascript,Synchronization,我有如下javascript函数： function myFunction(number) { var x=number; ... ... more initializations //here need to wait until flag==true while(flag==false) {} ... ... do something } 问题是javascript卡在了while中，卡在了我的程序中。因此，我的问题是，
function myFunction(number) {
var x=number;
...
... more initializations
//here need to wait until flag==true
while(flag==false)
{}
...
... do something
}
问题是javascript卡在了while中，卡在了我的程序中。因此，我的问题是，如何在函数中间等待，直到没有“忙等待”的标志是真的？ < P> JavaScript是单线程的，因此页面阻塞行为。您可以使用其他人建议的延迟/承诺方法，但最基本的方法是使用
window.setTimeoutfunction checkFlag() {
if(flag == false) {
window.setTimeout(checkFlag, 100); /* this checks the flag every 100 milliseconds*/
} else {
/* do something*/
}
}
checkFlag();
正如其他人指出的，最好的方法是重新构造代码以使用回调。但是，这个答案应该让您了解如何使用
window.setTimeoutwhile(flag==false) {}
while（flag==false）{}flag您需要做的是重新思考代码的工作方式，并找到一种不同的方式，在
标志truetruefunction codeThatMightChangeFlag(callback) {
// do a bunch of stuff
if (condition happens to change flag value) {
// call the callback to notify other code
callback();
}
}
done=falsedone=truesetTimeout使用Ecma脚本2017，您可以使用async await和while来完成此任务 而while将不会崩溃或锁定程序，即使变量永远不会为真
//首先定义一些从异步函数调用的延迟函数
功能延迟（计时器）{
返回新承诺（解决=>{
定时器=定时器| | 2000；
setTimeout（函数（）{
解决（）；
}，定时器）；
});
};
//然后声明某个变量为全局变量或范围内变量
//全靠你了
var标志=假；
//定义你想要的异步功能
异步函数some（）{
while（！flag）
等待延迟（1000）；
//…在此处编码，因为当Variable=true时，此函数将
};
//函数a（回调）{
setTimeout（函数（）{
console.log（“你好，我是订单1”）；
}, 3000);
//回调（）；
//}
//函数b（回调）{
setTimeout（函数（）{
console.log（'Hi I am order 2'）；
}, 2000);
//回调（）；
//}
//函数c（回调）{
setTimeout（函数（）{
console.log（'Hi I am order 3'）；
}, 1000);
//回调（）；
//}
/*函数d（回调）{
a（函数（）{
b（职能（{
c（回调）；
});
});
}
d（）*/
异步函数funa（）{
var pr1=新承诺（（res，rej）=>{
setTimeout（（）=>res（“Hi4我是订单1”），3000）
})
var pr2=新承诺（（res，rej）=>{
setTimeout（（）=>res（“Hi4我是订单2”），2000）
})
var pr3=新承诺（（res，rej）=>{
setTimeout（（）=>res（“Hi4我是订单3”），1000）
})
var res1=等待pr1；
var res2=等待pr2；
var res3=等待pr3；
console.log（res1、res2、res3）；
控制台日志（res1）；
console.log（res2）；
控制台日志（res3）；
}
funa（）；
异步函数f1（）{
等待新的承诺（r=>setTimeout（r，3000））
.然后（（）=>console.log（'Hi3我是订单1'））
返回1；
}
异步函数f2（）{
等待新的承诺（r=>setTimeout（r，2000））
.然后（（）=>console.log（'Hi3我是订单2'））
返回2；
function start()
{
GlobalProducts = getproductsfromsomewhere();
$.each(GlobalProducts, function(index, product) {
product["done"] = false;
});
DoProducts();
}
function DoProducts()
{
var doneProducts = Enumerable.From(GlobalProducts).Where("$.done == true").ToArray(); //linqjs
//update progress bar here
var nextProduct = Enumerable.From(GlobalProducts).Where("$.done == false").First();
if (nextProduct) {
nextProduct.done = true;
Me.UploadProduct(nextProduct.id); //does the long-running work
setTimeout(Me.UpdateProducts, 500)
}
}
function waitFor(condition, callback) {
if(!condition()) {
console.log('waiting');
window.setTimeout(waitFor.bind(null, condition, callback), 100); /* this checks the flag every 100 milliseconds*/
} else {
console.log('done');
callback();
}
}
waitFor(() => window.waitForMe, () => console.log('got you'))
let meaningOfLife = false;
async function waitForMeaningOfLife(){
while (true){
if (meaningOfLife) { console.log(42); return };
await null; // prevents app from hanging
}
}
waitForMeaningOfLife();
setTimeout(()=>meaningOfLife=true,420)
async function myFunction(number) {
var x=number;
...
... more initializations
await until(_ => flag == true);
...
... do something
}
function until(conditionFunction) {
const poll = resolve => {
if(conditionFunction()) resolve();
else setTimeout(_ => poll(resolve), 400);
}
return new Promise(poll);
}
const EventEmitter = require('events');
const bus = new EventEmitter();
let lock = false;
async function lockable() {
if (lock) await new Promise(resolve => bus.once('unlocked', resolve));
....
lock = true;
...some logic....
lock = false;
bus.emit('unlocked');
}
function sleep(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
async function until(fn) {
while (!fn()) {
await sleep(0)
}
}
async function myFunction(number) {
let x = number
...
... more initialization
await until(() => flag == true)
...
... do something
}
checkFlag: function() {
var currentObject = this;
if(flag == false) {
setTimeout(currentObject.checkFlag, 100);
} else {
/* do something*/
}
}
checkFlag: function() {
var worker = setInterval (function(){
if(flag == true){
/* do something*/
clearInterval (worker);
}
},100);
}
const delay = require('delay');
(async () => {
bar();
await delay(100);
// Executed 100 milliseconds later
baz();
})();
const waitFor = async (condFunc: () => boolean) => {
return new Promise((resolve) => {
if (condFunc()) {
resolve();
}
else {
setTimeout(async () => {
await waitFor(condFunc);
resolve();
}, 100);
}
});
};
const myFunc = async () => {
await waitFor(() => (window as any).goahead === true);
console.log('hello world');
};
myFunc();
let _queue = [];
const _addToQueue = (funcToQ) => {
_queue.push(funcToQ);
}
const _runQueue = () => {
if (!_queue || !_queue.length) {
return;
}
_queue.forEach(queuedFunc => {
queuedFunc();
});
_queue = [];
}
_addToQueue(() => methodYouWantToCallLater(<pass any args here like you normally would>));
const waitUntil = (condition) => {
return new Promise((resolve) => {
let interval = setInterval(() => {
if (!condition()) {
return
}
clearInterval(interval)
resolve()
}, 100)
})
}
await waitUntil(() => /* your condition */)
function resolveAfter2Seconds() {
return new Promise(resolve => {
setTimeout(() => {
resolve();
}, 2000);
});
}
function myFunction(number) {
var x=number;
...
... more initializations
//here need to wait until flag==true
while(flag==false)
{
await resolveAfter2Seconds();
}
...
... do something
}