gulp.run est obsolète. Comment composer des tâches?
Voici une tâche composée que je ne sais pas comment la remplacer par des dépendances de tâches.
...
gulp.task('watch', function () {
var server = function(){
gulp.run('jasmine');
gulp.run('embed');
};
var client = function(){
gulp.run('scripts');
gulp.run('styles');
gulp.run('copy');
gulp.run('lint');
};
gulp.watch('app/*.js', server);
gulp.watch('spec/nodejs/*.js', server);
gulp.watch('app/backend/*.js', server);
gulp.watch('src/admin/*.js', client);
gulp.watch('src/admin/*.css', client);
gulp.watch('src/geojson-index.json', function(){
gulp.run('copygeojson');
});
});
Le journal des modifications correspondant https://github.com/gulpjs/gulp/blob/master/CHANGELOG.md#35 [deprecate gulp.run]
gulp.task('watch', function () {
var server = ['jasmine', 'embed'];
var client = ['scripts', 'styles', 'copy', 'lint'];
gulp.watch('app/*.js', server);
gulp.watch('spec/nodejs/*.js', server);
gulp.watch('app/backend/*.js', server);
gulp.watch('src/admin/*.js', client);
gulp.watch('src/admin/*.css', client);
gulp.watch('src/geojson-index.json', ['copygeojson']);
});
Vous n'avez plus besoin de passer une fonction (bien que vous le puissiez toujours) pour exécuter des tâches. Vous pouvez donner à watch un tableau de noms de tâches et il le fera pour vous.
Ou vous pouvez faire comme ça:
gulp.start('task1', 'task2');
source: https://github.com/gulpjs/gulp/issues/755
gulp.start() n'a jamais été conçu pour être une API publique ni utilisé. Et comme indiqué ci-dessus dans les commentaires, la gestion des tâches sera remplacée dans la prochaine version .... donc gulp.start() sera rompu.
La véritable intention de gulp design est de créer des fonctions javascript régulières et de ne créer que la tâche de les appeler.
Exemple:
function getJsFiles() {
var sourcePaths = [
'./app/scripts/**/*.js',
'!./app/scripts/**/*.spec.js',
'!./app/scripts/app.js'
];
var sources = gulp.src(sourcePaths, { read: false }).pipe(angularFilesort());
return gulp.src('./app/index.html')
.pipe(injector(sources, { ignorePath: 'app', addRootSlash: false }))
.pipe(gulp.dest('./app'));
}
gulp.task('js', function () {
jsStream = getJsFiles();
});
Pardonnez-moi d'avoir ressuscité une vieille question. La réponse acceptée ne résout pas le problème des tâches en cours avant de définir les contrôles. La réponse suivante utilise gulp.start qui s'en va. La troisième réponse indique que les fonctions régulières devraient être utilisées, mais l'exemple semble étrange. J'ai fait des recherches mais je n'ai pas trouvé d'exemple simple.
Voici ma solution. L'idée est de définir des fonctions js régulières, puis de les enregistrer en tant que tâches. Les fonctions peuvent ensuite être appelées directement si nécessaire ou depuis une montre.
var
gulp = require('gulp'),
concat = require('gulp-concat'),
markdown = require('gulp-showdown')
;
var scriptFiles = [ 'ang/app.js' ];
var markdownFiles = [ 'content/articles/*.md'];
var watchTask = function()
{
buildTask();
gulp.watch(scriptFiles, ['scripts' ]);
gulp.watch(markdownFiles,['markdown']);
};
gulp.task('watch',watchTask);
var buildTask = function()
{
scriptsTask();
markdownTask();
};
gulp.task('build',buildTask);
var markdownTask = function()
{
gulp.src(markdownFiles)
.pipe(markdown())
.pipe(gulp.dest('web/articles'));
};
gulp.task('markdown',markdownTask);
var scriptsTask = function()
{
gulp.src(scriptFiles)
.pipe(concat('app.js'))
.pipe(gulp.dest('web/js'));
gulp.src(
[
'bower_components/angular/angular.min.js',
'bower_components/angular-route/angular-route.min.js'
])
.pipe(concat('vendor.js'))
.pipe(gulp.dest('web/js'));
gulp.src(
[
'bower_components/angular/angular.min.js.map',
'bower_components/angular-route/angular-route.min.js.map'
])
.pipe(gulp.dest('web/js'));
};
gulp.task('scripts', scriptsTask);
Je suis nouveau à avaler. S'il vous plaît laissez-moi savoir si j'ai oublié quelque chose d'évident.
avaler 4
gulp.parallel('taskName1', 'taskName2')()
gulp.series('taskName1', 'taskName2')()
J'aime gulp4!
Comme @dman le mentionne, gulp.start sera supprimé dans la prochaine version. On peut aussi le voir dans ce numéro de gulp .
Et dans les commentaires de la réponse de @Pavel Evstigneev, @joemaller mentionne que nous pouvons utiliser séquence d'exécution dans ce scénario.
Mais s'il vous plaît noter que, l'auteur de run-sequence dit:
Cela doit être une solution temporaire jusqu'à la publication de gulp 4.0, qui prend en charge la définition de dépendances de tâches en série ou en parallèle.
Sachez que cette solution est un hack et peut ne plus fonctionner avec une future mise à jour de gulp.
Donc, avant gulp 4.0, nous pouvons utiliser séquence d'exécution, après 4.0, nous pouvons simplement utiliser gulp.
Si vous devez conserver l'ordre d'exécution des tâches, vous pouvez définir les dépendances comme décrit ici - il vous suffit de renvoyer le flux à partir de la dépendance:
gulp.task('dependency', function () {
return gulp.src('glob')
.pipe(plumber())
.pipe(otherPlugin())
.pipe(gulp.dest('destination'));
});
Définissez la tâche qui en dépend:
gulp.task('depends', [ 'dependency' ], function () {
// do work
});
Et utilisez-le de la montre:
gulp.task('watch', function () {
watch('glob', [ 'depends' ]);
});
Désormais, la tâche dependecy sera terminée avant l'exécution de depends (par exemple, vos tâches "jasmine" et "embed" seraient des dépendances et vous auriez une autre tâche "serveur" qui en dépendrait). Pas besoin de hacks.
Dans Gulp 4, la seule chose qui semble fonctionner pour moi est la suivante:
gulp.task('watch', function() {
gulp.watch(['my-files/**/*'], gulp.series('my-func'));
});
gulp.task('my-func', function() {
return gulp.src('[...]').pipe(gulp.dest('...'));
});
Pour exécuter une tâche avant de commencer à regarder, au lieu d'utiliser gulp.run () ou gulp.start (), exécutez simplement la commande gulp.
Donc au lieu de:
var compress = function () {
return gulp.src('js/vendor/*.js')
.pipe(concat('vendor.js'))
.pipe(gulp.dest('./build/js/'));
};
Il suffit de faire:
gulp.src('js/vendor/*.js')
.pipe(concat('vendor.js'))
.pipe(gulp.dest('./build/js/'));
Ou vous pouvez envelopper ce dernier code dans une fonction "normale" et l'appeler quand vous le souhaitez.
- Inspiré par cette réponse d'un fil similaire .
Je ne vois toujours pas comment cela résoudrait réellement la question.
Si j'ai 4 tâches avec des dépendances définies entre elles
A B C D
où A dépend de B, etc. tel que défini par gulp.task('A',['B'],function A(){});, puis j'ai défini une nouvelle tâche à l'aide de gulp.watch, en exécutant uniquement les fonctions, afin de dupliquer les dépendances.
par exemple, étant donné ces tâches (chaque fonction de tâches est exposée via un nom):
function A(){}
gulp.task('A',['B'],A);
function A(){}
gulp.task('A',['B'],A);
function B(){}
gulp.task('B',['C'],B);
function C(){}
gulp.task('C',['D'],C);
function D(){}
gulp.task('D',[],D);
je peux écrire 1)
gulp.task('WATCHER', ['A'], function(){
...
}
qui exécuterait A-> D mais si, par exemple, l'étape B échouait, elle n'entrerait jamais dans la tâche (pensez à une erreur de compilation ou de test)
ou je peux écrire 2)
gulp.task('WATCHER', [], function(){
gulp.watch(...,['A'])
}
qui ne fonctionnerait pas A-> D jusqu'à ce que quelque chose ait été changé en premier.
ou je peux écrire 3)
gulp.task('WATCHER', [], function(){
D();
C();
B();
A();
gulp.watch(...,['A'])
}
ce qui entraînerait une duplication (et des erreurs dans le temps) de la hiérarchie des dépendances.
PS: Au cas où quelqu'un se demanderait pourquoi je voudrais que ma tâche de surveillance soit exécutée si l'une des tâches dépendantes échoue, c'est généralement parce que j'utilise watch pour le développement dynamique. par exemple. Je commence ma tâche de surveillance pour commencer à travailler sur des tests, etc. et il se peut que le code initial avec lequel je commence a déjà des problèmes, donc des erreurs.
J'espère donc que gulp run ou un équivalent reste pendant un certain temps