Cómo ejecutar tareas Gulp secuencialmente una tras otra

en el fragmento así:

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"

En la developtarea que quiero ejecutar cleany después de que esté hecho, ejecute coffeey cuando haya terminado, ejecute otra cosa. Pero no puedo entender eso. Esta pieza no funciona. Por favor avise.

Todavía no es un lanzamiento oficial, pero el próximo Gulp 4.0 le permite realizar fácilmente tareas sincrónicas con gulp.series. Simplemente puedes hacerlo así:

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

Encontré una buena publicación de blog que presenta cómo actualizar y utilizar esas características interesantes: migrar a Gulp 4 por ejemplo

Por defecto, gulp ejecuta tareas simultáneamente, a menos que tengan dependencias explícitas. Esto no es muy útil para tareas como clean, donde no desea depender, pero necesita que se ejecuten antes que todo lo demás.

Escribí el run-sequencecomplemento específicamente para solucionar este problema con trago. Después de instalarlo, úsalo así:

var runSequence = require('run-sequence');

gulp.task('develop', function(done) {
    runSequence('clean', 'coffee', function() {
        console.log('Run something else');
        done();
    });
});

Puede leer las instrucciones completas en el paquete README: también admite ejecutar algunos conjuntos de tareas simultáneamente.

Tenga en cuenta que esto se solucionará (de manera efectiva) en la próxima versión principal de Gulp , ya que están eliminando por completo el orden de dependencia automático y proporcionando herramientas similares run-sequencepara permitirle especificar manualmente el orden de ejecución como lo desee.

Sin embargo, ese es un cambio importante, por lo que no hay razón para esperar cuando puede usarlo run-sequencehoy.

La única buena solución a este problema se puede encontrar en la documentación de Gulp que se puede encontrar aquí.

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']);

Genere una aplicación de nodo / trago usando el generador Yeoman de generator -gulp-webapp . Manejó el "acertijo limpio" de esta manera (traduciéndose a las tareas originales mencionadas en la pregunta):

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

La secuencia de ejecución es la forma más clara (al menos hasta que se publique Gulp 4.0)

Con la secuencia de ejecución , su tarea se verá así:

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

Pero si (por alguna razón) prefiere no usarlo, el gulp.startmétodo ayudará :

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

Nota: Si solo inicia la tarea sin escuchar el resultado, la developtarea finalizará antes coffeey eso puede ser confuso.

También puede eliminar el detector de eventos cuando no sea necesario

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 que también hay un task_errevento que tal vez quiera escuchar. task_stopse activa al finalizar con éxito, mientras task_erraparece cuando hay algún error.

También puede preguntarse por qué no hay documentación oficial para gulp.start(). Esta respuesta del miembro de Gulp explica las cosas:

gulp.start no está documentado a propósito porque puede generar archivos de compilación complicados y no queremos que la gente lo use

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

De acuerdo con los documentos de Gulp:

¿Sus tareas se ejecutan antes de que se completen las dependencias? Asegúrese de que sus tareas de dependencia estén utilizando correctamente las sugerencias de ejecución asíncrona: reciba una devolución de llamada o devuelva una secuencia de promesa o evento.

Para ejecutar su secuencia de tareas sincrónicamente:

1. Devuelva la secuencia del evento (por ejemplo gulp.src) a gulp.taskpara informar a la tarea cuándo finaliza la secuencia.
2. Declarar dependencias de tareas en el segundo argumento de gulp.task.

Ver el 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"

Estaba teniendo exactamente el mismo problema y la solución resultó ser bastante fácil para mí. Básicamente cambie su código a lo siguiente y debería funcionar. NOTA: la devolución antes de gulp.src marcó la diferencia para mí.

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"

Probé todas las soluciones propuestas, todas parecen tener problemas propios.

Si realmente busca en la fuente del orquestador, particularmente en la .start()implementación, verá que si el último parámetro es una función, lo tratará como una devolución de llamada.

Escribí este fragmento para mis propias tareas:

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

Estuve buscando esta respuesta por un tiempo. Ahora lo tengo en la documentación oficial de Gulp.

Si desea realizar una tarea de trago cuando se complete la última, debe devolver una secuencia:

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));
});

Simplemente haga coffeedepender cleany developdependa de coffee:

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

El envío ahora es serial: clean→ coffee→ develop. Tenga en cuenta que cleanla implementación y coffeela implementación deben aceptar una devolución de llamada, "para que el motor sepa cuándo se realizará" :

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

En conclusión, a continuación se muestra un patrón de trago simple para una cleandependencia de compilación síncrona seguida de así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 es lo suficientemente inteligente como para ejecutarse cleanexactamente una vez por cada uno build, sin importar de cuántas builddependencias dependan clean. Como se escribió anteriormente, cleanes una barrera de sincronización, entonces todas buildlas dependencias se ejecutan en paralelo, luego se buildejecuta.

Para mí, no estaba ejecutando la tarea minify después de la concatenación, ya que espera una entrada concatenada y no se generó algunas veces.

Intenté agregar a una tarea predeterminada en orden de ejecución y no funcionó. Funcionó después de agregar solo un returnpara cada tarea y obtener la minificación dentro gulp.start()como se muestra a continuación.

/**
* 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']); 

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

Gulp y Node usan promesas .

Entonces puedes hacer esto:

// ... 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();
    });
  });
});

Si devuelve la secuencia de trago, puede usar el then()método para agregar una devolución de llamada. Alternativamente, puede usar el nativo de Node Promisepara crear sus propias promesas. Aquí solía Promise.all()tener una devolución de llamada que se activa cuando se resuelven todas las promesas.

Prueba este truco :-) Gulp v3.x Hack para error asíncrono

Probé todas las formas "oficiales" en el archivo Léame, no funcionaron para mí, pero esto sí. También puede actualizar a Gulp 4.x, pero le recomiendo que no lo haga, rompe muchas cosas. Podría usar una promesa js real, pero bueno, esto es rápido, sucio, simple :-) Esencialmente usa:

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

¡Mira la publicación!