Como executar tarefas Gulp seqüencialmente, uma após a outra

no trecho assim:

gulp.task "coffee", -> gulp.src("src/server/**/*.coffee") .pipe(coffee {bare: true}).on("error",gutil.log) .pipe(gulp.dest "bin") gulp.task "clean",-> gulp.src("bin", {read:false}) .pipe clean force:true gulp.task 'develop',['clean','coffee'], -> console.log "run something else" 

Na tarefa de develop , quero correr clean e, depois de pronto, coffee e, quando isso acontecer, executar outra coisa. Mas eu não consigo descobrir isso. Esta peça não funciona. Por favor informar.

Ainda não é um lançamento oficial, mas o próximo Gulp 4.0 permite que você faça facilmente tarefas síncronas com o gulp.series. Você pode simplesmente fazer assim:

 gulp.task('develop', gulp.series('clean', 'coffee')) 

Eu encontrei um bom post introduzindo como atualizar e fazer uso desses resources: migrando para engolir 4 pelo exemplo

Por padrão, gulp executa tarefas simultaneamente, a menos que elas tenham dependencies explícitas. Isso não é muito útil para tarefas como clean , onde você não quer depender, mas precisa executá-las antes de todo o resto.

Eu escrevi o plugin de run-sequence especificamente para corrigir esse problema com gulp. Depois de instalá-lo, use-o assim:

 var runSequence = require('run-sequence'); gulp.task('develop', function(done) { runSequence('clean', 'coffee', function() { console.log('Run something else'); done(); }); }); 

Você pode ler as instruções completas no pacote README – ele também suporta a execução de alguns conjuntos de tarefas simultaneamente.

Observe que isso será (efetivamente) corrigido na próxima versão principal do gulp , pois eles estão eliminando completamente o pedido de dependência automática e fornecendo ferramentas semelhantes à run-sequence para permitir que você especifique manualmente a ordem de execução como deseja.

No entanto, essa é uma grande mudança, por isso não há razão para esperar quando você pode usar run-sequence hoje.

A única boa solução para este problema pode ser encontrada na documentação do gulp que pode ser encontrada aqui

 var gulp = require('gulp'); // takes in a callback so the engine knows when it'll be done gulp.task('one', function(cb) { // do stuff -- async or otherwise cb(err); // if err is not null and not undefined, the orchestration will stop, and 'two' will not run }); // identifies a dependent task must be complete before this one begins gulp.task('two', ['one'], function() { // task 'one' is done now }); gulp.task('default', ['one', 'two']); // alternatively: gulp.task('default', ['two']); 

Gerei um aplicativo node / gulp usando o gerador Yeoman gerador -gulp-webapp . Ele lidou com o “enigma limpo” dessa maneira (traduzindo as tarefas originais mencionadas na pergunta):

 gulp.task('develop', ['clean'], function () { gulp.start('coffee'); }); 

run-sequence é o caminho mais claro (pelo menos até o Gulp 4.0 ser lançado)

Com a sequência de execução , sua tarefa ficará assim:

 var sequence = require('run-sequence'); /* ... */ gulp.task('develop', function (done) { sequence('clean', 'coffee', done); }); 

Mas se você (por algum motivo) preferir não usá-lo, o método gulp.start ajudará :

 gulp.task('develop', ['clean'], function (done) { gulp.on('task_stop', function (event) { if (event.task === 'coffee') { done(); } }); gulp.start('coffee'); }); 

Nota: Se você apenas iniciar a tarefa sem ouvir o resultado, a tarefa de develop será concluída antes do coffee e isso pode ser confuso.

Você também pode remover o ouvinte de evento quando não for necessário

 gulp.task('develop', ['clean'], function (done) { function onFinish(event) { if (event.task === 'coffee') { gulp.removeListener('task_stop', onFinish); done(); } } gulp.on('task_stop', onFinish); gulp.start('coffee'); }); 

Considere também que task_err evento task_err que você pode querer ouvir. task_stop é acionado no término bem-sucedido, enquanto task_err aparece quando há algum erro.

Você também pode se perguntar por que não há documentação oficial para gulp.start() . Esta resposta do membro gulp explica as coisas:

gulp.start foi documentado propositalmente porque pode levar a arquivos de construção complicados e não queremos que as pessoas o usem

(fonte: https://github.com/gulpjs/gulp/issues/426#issuecomment-41208007 )

De acordo com os documentos do Gulp:

Suas tarefas estão sendo executadas antes que as dependencies sejam concluídas? Certifique-se de que suas tarefas de dependência estejam usando corretamente as dicas de execução assíncronas: receba um retorno de chamada ou retorne uma promise ou um stream de events.

Para executar sua sequência de tarefas de forma síncrona:

  1. Retorna o stream de events (por exemplo, gulp.src ) para gulp.task para informar a tarefa de quando o stream termina.
  2. Declare as dependencies de tarefa no segundo argumento do gulp.task .

Veja o código revisado:

 gulp.task "coffee", -> return gulp.src("src/server/**/*.coffee") .pipe(coffee {bare: true}).on("error",gutil.log) .pipe(gulp.dest "bin") gulp.task "clean", ['coffee'], -> return gulp.src("bin", {read:false}) .pipe clean force:true gulp.task 'develop',['clean','coffee'], -> console.log "run something else" 

Eu estava tendo exatamente o mesmo problema e a solução acabou sendo muito fácil para mim. Basicamente, mude seu código para o seguinte e ele deve funcionar. NOTA: o retorno antes do gulp.src fez toda a diferença para mim.

 gulp.task "coffee", -> return gulp.src("src/server/**/*.coffee") .pipe(coffee {bare: true}).on("error",gutil.log) .pipe(gulp.dest "bin") gulp.task "clean",-> return gulp.src("bin", {read:false}) .pipe clean force:true gulp.task 'develop',['clean','coffee'], -> console.log "run something else" 

tentei todas as soluções propostas, todas parecem ter problemas próprios.

Se você realmente examinar a origem do orquestrador, particularmente a implementação .start() , verá que, se o último parâmetro for uma function, ele será tratado como um retorno de chamada.

Eu escrevi este trecho para minhas próprias tarefas:

  gulp.task( 'task1', () => console.log(a) ) gulp.task( 'task2', () => console.log(a) ) gulp.task( 'task3', () => console.log(a) ) gulp.task( 'task4', () => console.log(a) ) gulp.task( 'task5', () => console.log(a) ) function runSequential( tasks ) { if( !tasks || tasks.length < = 0 ) return; const task = tasks[0]; gulp.start( task, () => { console.log( `${task} finished` ); runSequential( tasks.slice(1) ); } ); } gulp.task( "run-all", () => runSequential([ "task1", "task2", "task3", "task4", "task5" )); 

Eu estava procurando por essa resposta por um tempo. Agora eu entendi na documentação oficial do gole.

Se você quiser executar uma tarefa de gulp quando a última estiver concluída, você deve retornar um stream:

 gulp.task('wiredep', ['dev-jade'], function () { var stream = gulp.src(paths.output + '*.html') .pipe($.wiredep()) .pipe(gulp.dest(paths.output)); return stream; // execute next task when this is completed }); // First will execute and complete wiredep task gulp.task('prod-jade', ['wiredep'], function() { gulp.src(paths.output + '**/*.html') .pipe($.minifyHtml()) .pipe(gulp.dest(paths.output)); }); 

Para mim, não estava executando a tarefa de redução após a concatenação, pois ela esperava uma input concatenada e não foi gerada algumas vezes.

Eu tentei adicionar a uma tarefa padrão em ordem de execução e não funcionou. Funcionou depois de adicionar apenas um return para cada tarefa e obter a minificação dentro do gulp.start() como abaixo.

 /** * Concatenate JavaScripts */ gulp.task('concat-js', function(){ return gulp.src([ 'js/jquery.js', 'js/jquery-ui.js', 'js/bootstrap.js', 'js/jquery.onepage-scroll.js', 'js/script.js']) .pipe(maps.init()) .pipe(concat('ux.js')) .pipe(maps.write('./')) .pipe(gulp.dest('dist/js')); }); /** * Minify JavaScript */ gulp.task('minify-js', function(){ return gulp.src('dist/js/ux.js') .pipe(uglify()) .pipe(rename('ux.min.js')) .pipe(gulp.dest('dist/js')); }); gulp.task('concat', ['concat-js'], function(){ gulp.start('minify-js'); }); gulp.task('default',['concat']); 

Fonte http://schickling.me/synchronous-tasks-gulp/

Simplesmente faça o coffee depender de clean e develop depender do coffee :

 gulp.task('coffee', ['clean'], function(){...}); gulp.task('develop', ['coffee'], function(){...}); 

O envio agora é serial: cleancoffeedevelop . Observe que a implementação do clean e a implementação do coffee devem aceitar um retorno de chamada “para que o mecanismo saiba quando será feito” :

 gulp.task('clean', function(callback){ del(['dist/*'], callback); }); 

Em conclusão, abaixo está um padrão de gole simples para uma clean síncrona seguida por dependencies de construção assíncrona :

 //build sub-tasks gulp.task('bar', ['clean'], function(){...}); gulp.task('foo', ['clean'], function(){...}); gulp.task('baz', ['clean'], function(){...}); ... //main build task gulp.task('build', ['foo', 'baz', 'bar', ...], function(){...}) 

Gulp é inteligente o suficiente para rodar clean exatamente uma vez por build , não importa quantas dependencies da build dependam de clean . Como escrito acima, clean é uma barreira de synchronization, então todas as dependencies da build são executadas em paralelo e, em seguida, são executadas.

Gulp e Node usam promises .

Então você pode fazer isso:

 // ... require gulp, del, etc function cleanTask() { return del('./dist/'); } function bundleVendorsTask() { return gulp.src([...]) .pipe(...) .pipe(gulp.dest('...')); } function bundleAppTask() { return gulp.src([...]) .pipe(...) .pipe(gulp.dest('...')); } function tarTask() { return gulp.src([...]) .pipe(...) .pipe(gulp.dest('...')); } gulp.task('deploy', function deployTask() { // 1. Run the clean task cleanTask().then(function () { // 2. Clean is complete. Now run two tasks in parallel Promise.all([ bundleVendorsTask(), bundleAppTask() ]).then(function () { // 3. Two tasks are complete, now run the final task. tarTask(); }); }); }); 

Se você retornar o stream do gulp, poderá usar o método then() para adicionar um retorno de chamada. Como alternativa, você pode usar a Promise nativa do Nó para criar suas próprias promises. Aqui eu uso Promise.all() para ter um retorno de chamada que é acionado quando todas as promises resolvidas.

Tente este hack 🙂 Gulp v3.x Hack para bug Async

Eu tentei todas as formas “oficiais” no Readme, eles não funcionaram para mim, mas isso aconteceu. Você também pode atualizar para engolir 4.x, mas eu recomendo que você não faça isso, ele quebra muita coisa. Você poderia usar uma promise real de js, mas ei, isso é rápido, sujo, simples 🙂 Essencialmente você usa:

 var wait = 0; // flag to signal thread that task is done if(wait == 0) setTimeout(... // sleep and let nodejs schedule other threads 

Confira o post!