Retorne de uma promessa então ()

Eu tenho um código javascript como este:

function justTesting() {
  promise.then(function(output) {
    return output + 1;
  });
}

var test = justTesting();

Sempre tenho um valor indefinido para o teste var. Acho que é porque as promessas ainda não foram resolvidas ... há como devolver o valor de uma promessa?

Quando você retorna algo de um then()retorno de chamada, é um pouco mágico. Se você retornar um valor, o próximo then()será chamado com esse valor. No entanto, se você retornar algo semelhante a uma promessa, o próximo then()espera por isso e só é chamado quando a promessa é estabelecida (sucesso / falha).

Fonte: https://developers.google.com/web/fundamentals/getting-started/primers/promises#queuing-asynchronous-actions

Para usar uma promessa, você deve chamar uma função que cria uma promessa ou você mesmo deve criar uma. Você realmente não descreve o problema que está tentando resolver, mas veja como você mesmo criaria uma promessa:

function justTesting(input) {
    return new Promise(function(resolve, reject) {
        // some async operation here
        setTimeout(function() {
            // resolve the promise with some value
            resolve(input + 10);
        }, 500);
    });
}

justTesting(29).then(function(val) {
   // you access the value from the promise here
   log(val);
});

// display output in snippet
function log(x) {
    document.write(x);
}

Ou, se você já tem uma função que retorna uma promessa, pode usar essa função e retornar sua promessa:

// function that returns a promise
function delay(t) {
  return new Promise(function(resolve) {
    setTimeout(function() {
      resolve();
    }, t);
  });
}

function justTesting(input) {
  return delay(100).then(function() {
    return input + 10;
  });
}

justTesting(29).then(function(val) {
  // you access the value from the promise here
  log(val);
});

// display output in snippet
function log(x) {
  document.write(x);
}

O que fiz aqui é retornar uma promessa da função justTesting. Você pode obter o resultado quando a função for resolvida.

// new answer

function justTesting() {
  return new Promise((resolve, reject) => {
    if (true) {
      return resolve("testing");
    } else {
      return reject("promise failed");
   }
 });
}

justTesting()
  .then(res => {
     let test = res;
     // do something with the output :)
  })
  .catch(err => {
    console.log(err);
  });

Espero que isto ajude!

// old answer

function justTesting() {
  return promise.then(function(output) {
    return output + 1;
  });
}

justTesting().then((res) => {
     var test = res;
    // do something with the output :)
    }

Eu prefiro usar o comando "await" e funções assíncronas para me livrar de confusões de promessas,

Neste caso, eu escreveria uma função assíncrona primeiro; ela será usada em vez da função anônima chamada em "promessa. Então" parte desta pergunta:

async function SubFunction(output){

   // Call to database , returns a promise, like an Ajax call etc :

   const response = await axios.get( GetApiHost() + '/api/some_endpoint')

   // Return :
   return response;

}

e então eu chamaria esta função da função principal:

async function justTesting() {
   const lv_result = await SubFunction(output);

   return lv_result + 1;
}

Observando que retornei a função principal e a subfunção para funções assíncronas aqui.