web-dev-qa-db-fra.com

Comment exécuter une tâche d'abeille à partir d'une autre tâche?

Je suis conscient de la possibilité de déclarer des dépendances qui s'exécuteront avant la tâche, par exemple.

gulp.task('a', () => {});
gulp.task('b', () => {});
gulp.task('c', ['a', 'c'], () => {});

Les tâches 'a' et 'b' seront exécutées chaque fois après l'appel de la tâche 'c' et avant l'exécution de la tâche 'c'.

Cependant, comment puis-je appeler par programme une tâche arbitraire à partir d'un gulp.task?

gulp
43
Gajus

Je l'ai fait en utilisant gulp.start (); comme ça:

gulp.task('test1', function(){
  gulp.start('test2');
})

gulp.task('test2', function(){
  // do something
})

J'utilisais gulp 3.9.1 si c'est important. On dirait que gulp.start () peut être supprimé ou obsolète; mais ce n'est pas encore arrivé. 

Update Si je divisais les choses en fonctions distinctes, comme suggéré par Novellizator, ce serait quelque chose comme ceci:

function doSomething(){
  // do something
}

gulp.task('test1', function(){
  doSomething();
})

gulp.task('test2', function(){
  doSomething();
})

C'est simple et évite l'utilisation de gulp.start ().

65
JeffryHouser

Sur le thème général "ne pas" des autres réponses, cela dépend de ce que vous faites.

Si vous pensez:

gulp.task("a", () => {
    doSomethingInstant()
    return doTaskB()
})

Tu veux:

gulp.task("meta-a", () => {
    doSomethingInstant()
})
gulp.task("a", ["meta-a", "b"])

Cela fonctionne parce que toutes les tâches sont démarrées dans l'ordre, donc si vous ne faites rien d'async dans "meta-a", cela se terminera avant le début de "b" Si c'est async, alors vous devez être beaucoup plus explicite:

gulp.task("meta-a", () => {
    return doSomethingAsync()
})
function taskB() {
    // Original task B code...
}
gulp.task("b", taskB)
gulp.task("a", ["meta-a"], taskB)
6
Jim Driscoll

Comme JeffryHouser l'a indiqué ci-dessus, l'utilisation de la méthode suivante fonctionne mais est obsolète et sera supprimée dans les versions futures. Je viens d'essayer ce qui suit sur 3.9.1 et cela fonctionne bien. 

Code:

// Variables
var gulp = require('gulp');
var less = require('gulp-less');
var watch = require('gulp-watch');


// Task to compile less -> css: Method 1- The bad way
gulp.task('default', function(){
    gulp.src('src/*.less')
    gulp.start('lessToCss');
});

gulp.task('lessToCss', function() {
    gulp.src('src/*.less')
    .pipe(less())
    .pipe(gulp.dest('src/main.css'));
});

La deuxième manière mentionnée dans le commentaire de Novellizator est:

"Découpez les tâches en fonctions, puis réutilisez-les dans d'autres tâches si vous avez besoin de" conseil tiré du problème susmentionné.

Je le fais en utilisant lazypipe () https://www.npmjs.com/package/lazypipe

Code:

// Variables
var gulp = require('gulp');
var less = require('gulp-less');
var watch = require('gulp-watch');

var lazypipe = require('lazypipe');
var fixMyCSS = lazypipe()
     .pipe(less); // Be CAREFUL here do not use less() it will give you an errror



// Task to compile less -> css: Method 2 - The Nice way
gulp.task('default', function(){
    //gulp.start('lessToCss');
    gulp.src('src/*.less')
    .pipe(fixMyCSS())
    .pipe(gulp.dest('src/main.css'));
});

Une brève comparaison

Méthode 1 donnant les résultats suivants:

  • Démarrer 'par défaut' ...
  • [22:59:12] Démarrer 'lessToCss' ...
  • [22:59:12] Terminé 'lessToCss' après 13 ms
  • [22:59:12] Terminé 'défaut' après 48 ms

Pour un total de 61 ms à compléter

Méthode 2? - [23:03:24] Démarrer 'par défaut' ...- [23:03:24] Terminé 'par défaut' après 38 ms

Pratiquement la moitié à 38 ms

Pour une différence totale de 23 ms

Maintenant, pourquoi est-ce le cas? Honnêtement, je n'en sais pas assez sur gulp, mais la méthode 2 est clairement le choix le plus lisible, maintenable et même le plus rapide.

Ils sont tous deux faciles à écrire tant que vous comprenez ne pas appeler un flux directement dans la lazypipe(). 

4
Callat

De Gulp 4+, j'ai trouvé que cela fonctionnait bien pour remplacer gulp.start:

const task1 = () => { /*do stuff*/ };
const task2 = () => { /*do stuff*/ };

// Register the tasks with gulp. They will be named the same as their function
gulp.task(task1);
gulp.task(task2);

...

// Elsewhere in your gulfile you can run these tasks immediately by calling them like this
(gulp.series("task1", "task2")());
// OR
(gulp.parallel("task1", "task2")());
1
DoubleA

Sur une note connexe, vous pouvez lancer les tâches à l'aide de gulp.series ou gulp.parallel dans gulp v4. Bien que ce ne soit pas un remplacement direct de gulp.start, il atteint le même objectif.

Exemple:

Avant la v4

gulp.task('protractor', ['protractor:src']);

Après v4

gulp.task('protractor', gulp.series('protractor:src'));
1
John Lee