Tarea Gulp.js, ¿volver en src?

132

Soy nuevo en tragar y he estado buscando ejemplos de configuraciones. Algunas personas tienen la siguiente estructura:

gulp.task("XXXX", function() {
    gulp.src("....

Otras personas tienen esto:

gulp.task("XXXX", function() {
   return gulp.src("....

Me pregunto qué diferencia hace el rendimiento del src.

javascript node.js gulp boldfacedesignuk
fuente

Respuestas:

158

Para returnindicar que la tarea es asíncrona. gulp.src()devuelve una secuencia, por lo que es asíncrona.

Sin él, el sistema de tareas no sabría cuándo terminó. Lee los documentos .

Sindre Sorhus
fuente
¡Excelente! gracias por la respuesta Sindre. Ten un trago corriendo como un encanto ahora. Quiéralo.
boldfacedesignuk
Impresionante exactamente lo que estaba buscando :)
Sebastien Lorber
14
¿Eso significa que debes volver cuando lo usas gulp.src()? ¿Qué pasa si no vuelves gulp.src()?
jbandi
11
Segundo @ jbandi's: la pregunta obvia que debo hacer aquí es "¿hay alguna razón para no regresar gulp.src(..., o deberíamos hacerlo siempre?" Esta respuesta sería más útil si abordara ese punto, OMI; actualmente no aborda por qué hay muchos ejemplos de tareas que llaman gulp.src(...pero que no devuelven.
Mark Amery
2
@jbandi: si no lo hace return, el sistema de dependencia podría iniciar una tarea antes de que se hagan sus dependencias. Tengo un trago con muchas tareas (en su mayoría generadas por código). Debido a que no estaba devolviendo la transmisión, una tarea dependiente ya estaba leyendo el archivo mientras su dependencia aún se estaba construyendo. Me
metió
37

Si tiene tareas dependientes, debe devolver la secuencia para que las tareas esperen a que se completen sus tareas dependientes antes de ejecutarse.

p.ej

// without return
gulp.task('task1', function() {
    gulp.src('src/coffee/*.coffee')
      /* eg compile coffeescript here */
     .pipe(gulp.dest('src'));
});

gulp.task('task2', ['task1'], function() {
    gulp.src('src/*.js')
      /* eg minfify js here */
     .pipe(gulp.dest('dest'));
});

en ese ejemplo, esperaría que la tarea1 se complete (por ejemplo, compilando el coffeescript o lo que sea) antes de que se ejecute la tarea2 ... pero a menos que agreguemos retorno , como en el ejemplo a continuación, se ejecutarán sincrónicamente y no asincrónicamente; y el coffeescript compilado no se minificará porque la tarea 2 no habrá esperado a que se complete la tarea 1 y, por lo tanto, no recogerá el resultado compilado de la tarea1 . Por lo tanto, siempre debemos volver en estas circunstancias.

// with return
gulp.task('task1', function() {
    return gulp.src('**/*.coffee')
      /* your operations here */
     .pipe(gulp.dest('dest'));
});

gulp.task('task2', ['task1'], function() {
    return gulp.src('**/*.js')
      /* your operations here */
     .pipe(gulp.dest('dest'));
});

Editar: La receta aquí lo explica más a fondo. https://github.com/gulpjs/gulp/blob/master/docs/recipes/running-tasks-in-series.md

byronyasgur
fuente
26

Esto me pareció útil, si tienes varias transmisiones por tarea. Debe combinar / fusionar las múltiples transmisiones y devolverlas.

var gulp = require('gulp');
var merge = require('gulp-merge');

gulp.task('test', function() {
    var bootstrap = gulp.src('bootstrap/js/*.js')
        .pipe(gulp.dest('public/bootstrap'));

    var jquery = gulp.src('jquery.cookie/jquery.cookie.js')
        .pipe(gulp.dest('public/jquery'));

    return merge(bootstrap, jquery);
});

La alternativa, utilizando la estructura de definición de tareas Gulps, sería:

var gulp = require('gulp');

gulp.task('bootstrap', function() {
    return gulp.src('bootstrap/js/*.js')
        .pipe(gulp.dest('public/bootstrap'));
});

gulp.task('jquery', function() {
    return gulp.src('jquery.cookie/jquery.cookie.js')
        .pipe(gulp.dest('public/jquery'));
});

gulp.task('test', ['bootstrap', 'jquery']);
jpblancoder
fuente