Quiero llamar a una función util que podría encontrar un error. En caso de error, la función process debe finalizar. La única forma de arrojar un error correctamente es la función callback.

Terminaría la función volviendo, pero como estoy en la función util, la función process continuará después de la llamada util().

function util(callback) {

    // do something synchronous

    if (err) {
        // doesn't terminate the process function
        // since we are in the util function
        return callback("something unexpected happened");
    }
}

function process(callback) {
    util(callback);
    console.log("This should not be printed if an error occurs!");
}

process(function (err) {
    if (err) {
        // this has to be executed in case of an error
        console.log(err);

        // terminate the process function somehow?
    }
});
1
Max Mustermann 16 feb. 2017 a las 21:54

4 respuestas

La mejor respuesta

Te sugiero que hagas algunos cambios en tu código

function util(callback) {

    // do something synchronous

    if (err) {
        // doesn't terminate the process function
        // since we are in the util function
        callback("something unexpected happened");
        return false;
    }

   return true;
}

function process(callback) {
    if(!util(callback)) return;
    console.log("This should not be printed if an error occurs!");
}
0
Sharjeel Ahmed 16 feb. 2017 a las 18:59

No, querrás hacer algo como esto:

            function util(callback) {
                // do something synchronous
                if (err) {
                    throw new Error('Something unexpected happened');
                }
                callback(); // only execute callback if an error did not occur
            }

            function process(callback) {
                try{
                    util(callback);
                    console.log("This should not be printed if an error occurs!");
                } catch(error){
                    process(error);
                }
            }

            process(function (err) {
                if (err) {
                    // this has to be executed in case of an error
                    console.log(err);
                    process.exit(1)
                }
            });
0
ShaneDaugherty 16 feb. 2017 a las 21:36

¿Llamar a la devolución de llamada termina la función actual?

No, una devolución de llamada es solo una función regular. Por supuesto, podría arrojar una excepción (aunque eso es despreciado).

Quiero llamar a una función util que pueda encontrar un error. En caso de error, la función del proceso debe finalizar.

Para eso, debe verificar en la devolución de llamada lo que sucedió y actuar en consecuencia. Puede usar process.exit para la terminación.

function myProcess(callback) {
    util(function(err, result) {
         if (err) {
             callback(err);
         } else {
             console.log("This should not be printed if an error occurs!");
             callback(null, result);
         }
     });
}

myProcess(function (err) {
    if (err) {
        // this has to be executed in case of an error
        console.log(err);
        process.exit(1);
    }
});

Tenga en cuenta que las promesas podrían simplificar mucho esto, ya que distinguen entre devoluciones de llamada de éxito y error. util tendría que devolver una promesa para eso:

function util() {
    return new Promise(function(resolve, reject) {
        // do something asynchronous

        if (err)
            reject("something unexpected happened");
        else
            resolve(…);
    });
}

function myProcess() {
    return util().then(function(res) {
        console.log("This should not be printed if an error occurs!");
        return res;
    });
}

myProcess().catch(function (err) {
    // this has to be executed in case of an error
    console.log(err);
    process.exit(1); // you might not even need this:
    throw err; // The node process will by default exit with an unhandled rejection
});
3
Bergi 16 feb. 2017 a las 19:41

Este parece ser un buen momento para usar una Promesa, las promesas son la forma de Javascript de forzar una función síncrona. Básicamente lo configuras así:

var util = new Promise(function(resolve, reject) {
    /* do some stuff here */

    if (someCondition) {
        resolve("With a message");
    } else {
        reject("with a message");
    }
}

function process() {
    util.then(function() {
        console.log("Won't call if there is an error");
    }).catch(function() {
        console.log("There was an error, Bob");
    });
}
0
EvSunWoodard 16 feb. 2017 a las 20:14