node.js - Problème asynchrone gulp.task

Question

Comment comprendre cette phrase : vos tâches sont-elles en cours d'exécution avant que les dépendances ne soient terminées ? Assurez-vous que vos tâches de dépendance utilisent correctement les astuces d'exécution asynchrone : effectuez un rappel ou renvoyez une promesse ou un flux d'événements.

Traduction du site Web en chinois gulpjs : votre tâche a-t-elle été exécutée avant que ces tâches prédépendantes ne soient terminées ? Veuillez vous assurer que les tâches de la liste de tâches dont vous dépendez utilisent la méthode d'exécution asynchrone correcte : utilisez un rappel ou renvoyez une promesse ou un flux.

Je suis un peu confus. Si le rappel n’est pas utilisé ou si une promesse/un flux est renvoyé, alors cette tâche n’est pas une tâche asynchrone ?

Il y a aussi gulp.task('mytask',['beforemytask']), ce qui signifie que beforemytask est exécuté avant que mytask ne soit exécuté, ce qui est un peu synchrone, mais beforemytask doit-il utiliser la bonne méthode asynchrone ?

Je suis confus, s'il vous plaît, demandez à Dieu de clarifier ma confusion

Answer 1

Si le rappel n'est pas utilisé ou si une promesse/un flux est renvoyé, alors cette tâche n'est pas une tâche asynchrone ?

Oui. L'exécution de la séquence de tâches Gulp repose sur Orchestrator, qui déterminera si la fonction a des paramètres (rappel) et une valeur de retour (promesse/flux) pour déterminer si elle est asynchrone.

Mais avant que ma tâche doive utiliser la bonne méthode asynchrone ?

Vous devez détecter la fin de beforemytask et utiliser la méthode ci-dessus pour vous assurer que mytask est exécutée plus tard. Sinon, n'importe quelle méthode fera l'affaire.

Answer 2

Vous ne savez pas quand cette tâche sera terminée. Ajoutez un traitement de rappel plus tard En ce qui concerne cette tâche, le traitement ici est asynchrone
La synchronisation est exactement ce que vous avez dit, une tâche doit attendre une autre tâche. ne seront traités qu'après leur exécution. Parfois, il existe des dépendances entre les tâches,

.

Il doit être traité en fonction de la relation de dépendance. J'utilise la synchronisation pour le comprendre ici. Je pense qu'il n'y a pas de problème. Ceci est ma compréhension et est uniquement à titre de référence

.

Voici un exemple

var gulp = require('gulp'); 
var minifycss = require('gulp-minify-css'); //压缩css
var uglify = require('gulp-uglify'); //压缩js
var del = require('del'); // 删除目录

gulp.task('clean',function() {
    return del(['dist/**']);
});
//压缩 css 
gulp.task('minify-css',['clean'], function() {
    return  gulp.src('./public/**/*.css')
            .pipe(minifycss())
            .pipe(gulp.dest('./dist'));
});

//压缩 js 
gulp.task('minify-js',['clean'], function() {
    return gulp.src('./public/**/*.js')
            .pipe(uglify())
            .pipe(gulp.dest('./dist'));
});
// 每一次跑任务 需要删除 dist 目录， 然后开始跑  minify-css 和 minify-js 
//执行任务 这里 minify-css 和 minify-js 就依赖前面 clean 
// 也就是说必须等  clean 这个任务跑完，minify-css 和 minify-js 才能执行
// 
// default 是默认执行的任务
gulp.task('default',[
    'clean','minify-css','minify-js'
]);