Promise 还是异步结构，异步是没有“循环”概念的，等价的控制结构是递归。

Async库的Whist、Until、During、doWhist、doUntil、doDuring等循环方法很好用

async function asyncWhile(){
	while(true){
		const result = await aPromise();
		if (!result.success){
			break;
		}
		...
	}
}

@yszou 同意你的说法 楼主可以通过递归函数来实现 跳出 可以通过抛error来控制 举例：

async function promiseWhile() {
	doSomething
	if (是时候跳出了) {
		throw 'exit';
	}
	await promiseWhile();
}

async function invokePromistWhile() {
	try {
		await promiseWhile()
	} cache (e) {
		if (e === 'exit') {
			什么都不做 继续去执行其他逻辑吧
		} else {
			错误处理
		}
	}
}

谢谢大家，我正在尝试用async/awaie发现蛮好用的

思路是构造一个promise then链，将这个链封一下，然后提供一个回调供while函数体(promiseWhile)使用，本想办法不暴露resolve,reject，但是由于异步的缘故，似乎又不得不添加，暂时没有想到一个好的封装方法。

function promiseWhile(tasks, callback) {
	if (!callback) return;
	let queue = Promise.resolve();
	tasks.map((task, i) => {
		queue = queue.then(() => {
			return new Promise((resolve, reject) => {
				let stop = reject;
				let next = resolve;
				callback(task, i, resolve, reject);
			});
		});
	});
	queue.catch(e => {
		console.log('break');
	});
}

测试：

let tasks = [1.13, 2.13, 3.13, 4.13];
promiseWhile(tasks, (task, i, next, stop) => {
	setTimeout(() => {
		console.log(task);
		if (task > 3) {
			stop();
		} else {
			next();
		}
	}, 1000);
});