Comment faire pour exécuter une gorgée tâche à partir d'une autre tâche?

Je suis conscient de la possibilité de déclarer des dépendances qui sera exécuté avant la tâche, par exemple

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

Tâches 'a' et 'b' sera exécuté chaque fois après la tâche "c' est appelé et avant que la tâche " c " est exécutée.

Cependant, comment dois-je appeler par programmation un arbitraire de la tâche à partir de l'intérieur d'un gulp.task?

InformationsquelleAutor Gajus | 2015-10-06

gulp

66

Je l'ai fait à l'aide de gulp.start(); comme ceci:
```
gulp.task('test1', function(){
  gulp.start('test2');
})

gulp.task('test2', function(){
  //do something
})
```
J'ai été en utilisant gulp 3.9.1 si il le faut. Ressemble gulp.start() peuvent être retirés ou abandonnés; mais il n'est pas encore arrivé.

Mise à jour
Si je devais casser des choses dans des fonctions distinctes, comme Novellizator suggéré, il serait quelque chose comme ceci:
```
function doSomething(){
  //do something
}

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

gulp.task('test2', function(){
  doSomething();
})
```
Il est simple et permet d'éviter l'utilisation de gulp.start().
- "Diviser les tâches en fonctions, puis de les réutiliser dans d'autres tâches si vous avez besoin de" morceau de conseils à partir de la question ci-dessus
- Je viens d'installer gulp et cette méthode fonctionne pour moi. Mais je vais énumérer les alternatives discutées ci-dessous.
- Merci tu m'as sauvé la fois; il a bien fonctionné pour moi!
- gulp.début, n'est pas une fonction
- Il a été finalement retiré?
- Doit avoir été, pas le dernier.
- gulp.start('test2'); Ses depreicated.
InformationsquelleAutor JeffryHouser
7

Sur le thème général de "ne pas" d'autres réponses, cela dépend de ce que vous êtes en train de faire.

Si vous êtes en train de penser:
```
gulp.task("a", () => {
    doSomethingInstant()
    return doTaskB()
})
```
Vous voulez:
```
gulp.task("meta-a", () => {
    doSomethingInstant()
})
gulp.task("a", ["meta-a", "b"])
```
Cela fonctionne parce que toutes les tâches sont lancés dans l'ordre, donc si vous ne faites rien async en "méta-un", il sera fini avant "b" commence. Si c'est de l'asynchrone, alors vous devez être plus explicite:
```
gulp.task("meta-a", () => {
    return doSomethingAsync()
})
function taskB() {
    //Original task B code...
}
gulp.task("b", taskB)
gulp.task("a", ["meta-a"], taskB)
```
InformationsquelleAutor Jim Driscoll

De Gulp 4+, j'ai trouvé que cela fonctionne bien comme un remplacement pour le trait.départ:

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")());

InformationsquelleAutor DoubleA

5

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

Exemple:

Avant v4
```
gulp.task('protractor', ['protractor:src']);
```
Après v4
```
gulp.task('protractor', gulp.series('protractor:src'));
```
InformationsquelleAutor John Lee
3

Comme JeffryHouser indiqué ci-dessus à l'aide de la méthode suivante fonctionne mais est obsolète et sera supprimée dans une future version. Je viens de tenter la suite sur 3.9.1 et il fonctionne très 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'));
});
```
Le deuxième moyen mentionné dans le commentaire par Novellizator est:

"Diviser les tâches en fonctions, puis de les réutiliser dans d'autres tâches si vous avez besoin de" morceau de conseils à partir de la question ci-dessus

Je fais cela par l'utilisation de 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 ce qui donne les suivantes:
- De départ "par défaut"...
- [22:59:12] à Partir de 'lessToCss'...
- [22:59:12] Fini "lessToCss" après 13 ms
- [22:59:12] Terminé "par défaut" au bout de 48 ms
Pour un total de 61 ms pour compléter

Méthode 2?
- [23:03:24] à Partir de "par défaut"...
- [23:03:24] Terminé "par défaut" après 38 ms

Pratiquement la moitié de celui de 38 ms

Pour un total de différence de 23 ms

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

Ils sont à la fois facile à écrire, aussi longtemps que vous ne comprenez pas d'appeler un flux directement au sein de la lazypipe().
- C'est une interprétation plus complexe de @Novellizator commentaire que mon interpertation. J'ai modifié ma réponse à inclure une autre approche. Il est difficile d'évaluer la performance des stats dans l'isolement, surtout depuis que vous êtes en cours d'exécution de code différent. Si lessToCss utilise une approche progressive, il est prévu que la seconde serait plus rapide que la première.
- .commencer est obsolète
InformationsquelleAutor Callat
-6

Il ya un couple de façons de le faire:
La première: il suffit d'invoquer une nouvelle tâche d'appel pour les autres:
```
gulp.task('foo', function() {
  gulp.task('caller', ['bar']); //<- this calls the other existing task!
}
gulp.task('bar', function() {
  //do something
}
```
La seconde, moins propre: Gulp est en Javascript, il vous suffit de définir un couple d'instructions comme une fonction aléatoire et de l'appeler!
```
gulp.task('task', function() {
  recurrent_task();
}
gulp.task('task2', function() {
  recurrent_task();
}
function recurrent_task() {
  //do something
}
```
- est-ce juste moi ou ce n'est pas du travail?
- d'abord on ne travaille pas
- La première proposition que vient de registres une gorgée de travail, mais sans une fonction de rappel, donc oui, ça ne marchera pas.
InformationsquelleAutor PpToño

Vous devez vous connecter pour publier un commentaire.