Как синхронизировать объекты промисов?

async promiseController(){
  for(const value of array) {
    console.log((await this.getVal(value))+'prom');
  }
}

Не нужно слишком усложнять вещи. Просто вызовите await внутри цикла, и он будет ждать того, что вы хотите.

Как справедливо сказано в другом ответе, обещание представляет собой значение, а не операцию. Для операций используются обычные функции.

Если вы хотите игнорировать сбои, вы можете .catch(() => {}) выполнить обещание. Если вы хотите повторить попытку до сбоя, вы можете реорганизовать повторную попытку в функцию и использовать ее:

const retry = fn => (...args) => fn(...args).catch(retry(fn));

Если ваша цель состоит в том, чтобы не "выполнять последующие промисы" до тех пор, пока первый промис не разрешится, вам нужно помнить, что промисы представляют собой асинхронную активность, уже выполняемую. Когда обещание существует, уже слишком поздно.

Вместо этого вам нужно не вызывать последующие методы фабрики обещаний, пока не завершится первое обещание. Ваш первый пример делает это, не вызывая getVal() до тех пор, пока предыдущее обещание не завершится.

Таким образом, вы получите что-то вроде:

delay(time) {
    return new Promise(resolve => setTimeout(resolve, time));
}

async promiseController() {
    const factories = [];
    for (let i = 0; i < 5; ++i) {
        factories.push(() => this.getVal());
    }

    for (const f of factories) {
        // keep running this factory until it succeeds
        let success = false;
        while (!success) {
            try {
                const promise = f();
                const result = await f;
                success = true;
                console.log(`result = ${result}`);
            }
            catch (err) {
                console.log("promise failed.  retrying");
                await delay(100);
            }
        }
    }
}

Вы можете использовать рекурсию, именованную функцию, .then()

var arr = [Promise.resolve("a")
           , Promise.resolve("b")
           , Promise.resolve("c")];
var i = 0;
var res = [];

function foo() {
  // conditional resolved or rejected promise
  var n = String(new Date().getTime()).slice(-1);
  // if `n` < 5 reject `n` , else resolve `n`
  var curr = n < 5;
  return curr ? arr[i] : Promise.reject(["rejected", n])
}

var p = (function repeat() {
  var promise = foo();
  return promise
    .then(function(data) {
      console.log(data);
      res.push(data);
      ++i;
      if (i < arr.length) return repeat()
      // return `res` array when all promises complete
      else return res
    })
    .catch(function(err) {
      console.log(err);
      if (err[0] === "rejected") return repeat()
    })
}());

p.then(function(complete) {
  console.log("complete:", complete)
});

Ладно, хорошо. Я считаю, что ради правильных целей функционального программирования следует избегать async и await. Я считаю, что обещаний вполне достаточно. Тем не менее, если вы хотите продолжить кодирование в императивном стиле C++, то async и await для вас.

У меня есть объекты обещания, которые должны работать синхронно. Например, второе обещание не должно работать до того, как будет выполнено первое. Если первый отклоняет первый, его нужно выполнить снова.

Позвольте мне кратко рассказать о коде ниже. У нас есть функция async(), которая принимает данные и обратный вызов (ошибка первого типа). Что касается демонстрационных целей, он попытается вызвать обратный вызов с данными в пределах 2000 мс, однако есть тайм-аут в 1000 мс. Итак, 50-50 он либо вызовет обратный вызов с данными, либо с ошибкой.

Таким образом, нам действительно нужно, чтобы он вернул нам обещание, поэтому я обещаю его с помощью promisify(), и он принимает функцию async() и возвращает мне функцию asyncPro(). Что на самом деле то же самое, что и async(), но вместо этого возвращает обещание. Таким образом, ожидается, что мы будем использовать наш обратный вызов на этапе then.

Затем идет функция tryNTimes(data,asyncFun,n = 5), которая принимает данные, обещанная асинхронная функция и целое число, определяющее количество попыток, прежде чем отклонить ее. Количество попыток по умолчанию равно 5, но вы можете установить любое значение, передав третий аргумент.

Что касается последней части, у нас есть flowControl(), который идеально связывает наши промисы с помощью Array.prototype.reduce().

Итак, теперь у нас есть все наши обещания, связанные одно за другим, и ни одно из них не подведет, пока мы не попытаемся 5 раз.

function promisify(fun){
  return (data) => new Promise((resolve,reject) => fun(data, (err,res) => err ? reject(err) : resolve(res)));
}

function async(data, callback){
  var dur = Math.floor(Math.random()*2000);
  setTimeout(_ => callback(false,data),dur);           // may resolve before timeout
  setTimeout(_ => callback("error at " + data),1000);  // timeout at 1 sec
}

function tryNTimes(data,asyncFun,n = 5){
  return new Promise((resolve,reject) => { n === 0 && reject("try out fail at 5 tries: " + data);
                                           asyncFun(data).then(v => resolve("resolved at countdown " + n + ": " + v))
                                                         .catch(e => resolve(tryNTimes(data,asyncFun,--n)));
                                         });
}

function flowControl(d,f,tc){
  return d.reduce((prom,chunk) => prom.then(v => { console.log(v);
                                                   return tryNTimes(chunk,f,tc);
                                                 }),Promise.resolve("initial dummy promise"));
}

var data = ["chunk_1", "chunk_2", "chunk_3", "chunk_4", "chunk_5"],
asyncPro = promisify(async);                           // now our async function returns a promise

flowControl(data,asyncPro).then(v => console.log(v))
                          .catch(e => console.log(e));

Если вы хотите, чтобы ошибки "5 раз пытались" появляться чаще, уменьшите значение времени ожидания в функции async().