Regresa de una promesa entonces ()

Tengo un código javascript como este:

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

var test = justTesting();

Siempre tengo un valor indefinido para la prueba var. Creo que se debe a que las promesas aún no se han resuelto ... ¿hay alguna forma de devolver un valor de una promesa?

Cuando devuelve algo de una then()devolución de llamada, es un poco mágico. Si devuelve un valor, then()se llama al siguiente con ese valor. Sin embargo, si devuelve algo parecido a una promesa, el siguiente lo then()espera y solo se llama cuando esa promesa se establece (tiene éxito / falla).

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

Para usar una promesa, debe llamar a una función que crea una promesa o debe crear una usted mismo. Realmente no describe qué problema está realmente tratando de resolver, pero así es como crearía una promesa usted mismo:

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);
}

O, si ya tiene una función que devuelve una promesa, puede usar esa función y devolver su promesa:

// 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);
}

Lo que he hecho aquí es que he devuelto una promesa de la función justTesting. A continuación, puede obtener el resultado cuando se resuelva la función.

// 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 esto ayude!

// old answer

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

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

Prefiero usar el comando "await" y las funciones asíncronas para deshacerme de las confusiones de las promesas,

En este caso, primero escribiría una función asincrónica, esta se usará en lugar de la función anónima llamada en "promesa. Luego" parte de esta pregunta:

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;

}

y luego llamaría a esta función desde la función principal:

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

   return lv_result + 1;
}

Observando que devolví la función principal y la función secundaria a las funciones asíncronas aquí.