J'essaie d'exécuter cette fonction, mais elle continue de retourner indéfinie lorsque je code explicitement en dur la valeur de retour.

const splitVideo = async (sid, video, part) => {
    let framesLocation =`${process.cwd()}/${dirs.videoFrames}/${sid}_${part}`;

    console.log(fs.existsSync(framesLocation));

    if(!fs.existsSync(framesLocation)) {
        console.log("making dir");
        f.s.mkdirSync(framesLocation);
    }

    ffmpeg(video)
        .on('end', () => {
             return "done";
         })
         .on('error', (err) => {
             throw err;
         })
         .screenshots({
              timestamps: [1,2],
              filename: `${sid}_${part}/frame-%s.png`,
              folder: `${process.cwd()}/${dirs.videoFrames}`
         });
};

S'il vous plaît, aidez cela est très frustrant.

0
Leon Wright 12 avril 2018 à 19:57

3 réponses

Meilleure réponse

Votre fonction ne renvoie rien, c'est pourquoi vous obtenez undefined. Enveloppez l'appel ffmpeg dans new Promise(...) pour pouvoir resolve son résultat asynchrone:

const splitVideo = async (sid, video, part) => {
    // ...

    return new Promise((resolve, reject) => {
        ffmpeg(video)
            .on('end', () => {
                resolve("done");
             })
            .on('error', (err) => {
                reject(err);
             })
             .screenshots({
                  timestamps: [1,2],
                  filename: `${sid}_${part}/frame-%s.png`,
                  folder: `${process.cwd()}/${dirs.videoFrames}`
             });
    };
};

const ret = await splitVideo(...);
console.log(ret);

Notez également que vous devez await cette fonction pour pouvoir lire le résultat (ou obtenir le résultat dans le gestionnaire then).

4
Martin Adámek 14 avril 2018 à 10:22

Vous ne pouvez que await promesses.

const splitVideo = async (sid, video, part) => {
// ...

const val = await new Promise((resolve, reject) => {
    ffmpeg(video)
        .on('end', () => {
            resolve("done");
         })
        .on('error', (err) => {
            reject(err);
         })
         .screenshots({
              timestamps: [1,2],
              filename: `${sid}_${part}/frame-%s.png`,
              folder: `${process.cwd()}/${dirs.videoFrames}`
         });
      //... more code using the val maybe?
      return val
  };
};
0
Abhishek Gupta 12 avril 2018 à 17:12

Le problème est que votre fonction ffmpeg (vidéo) à l'intérieur de votre fonction asynchrone splitVideo est asynchrone. Ce qui se passe, c'est que votre fonction splitVideo est appelée mais qu'elle retourne indéfinie avant que votre fonction ffmpeg (vidéo) n'accomplisse. Que pouvez-vous faire pour résoudre ce problème?

Vous avez déjà défini votre fonction splitVideo comme une fonction asynchrone, cela vous permet d'utiliser le mot réservé "wait". Mais d'abord, encapsulons votre fonction ffmpeg (vidéo) dans une promesse.

const splitVideo = async (sid, video, part) => {
    //Your code
    let promise = new Promise((resolve, reject) => {
         ffmpeg(video)
            .on('end', () => {
                  resolve("done");
             })
             .on('error', (err) => {
                 reject(err);
             })
             .screenshots({
                   timestamps: [1,2],
                   filename: `${sid}_${part}/frame-%s.png`,
                   folder: `${process.cwd()}/${dirs.videoFrames}`
             });
       });
try{
    return await promise;
 }catch(err){
    return err;        
}

Cela devrait être suffisant pour votre fonction splitVideo, mais il est important de faire attention car les promesses non gérées sont rejetées et à l'avenir mettront fin à votre processus node.js. Ce que vous devez faire est également d'ajouter une instruction .catch () à votre splitVideoFunction, quelque chose comme:

splitVideo.catch ((err) => {// votre code}). puis ((result) => {// Votre code})

Ou vous pouvez appeler splitVideo dans une autre fonction asynchrone et utiliser:

try {
    await splitVideo(video);
}catch(err){
    //Your code
}

Si vous avez un doute sur async / wait comme je l'ai fait, cette question peut vous être utile. Node.JS - Impossible d'obtenir des lancers asynchrones avec des blocs try / catch

J'espère que ça aide.

0
Henrique Borges 12 avril 2018 à 18:03