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

¿Eso significa que debes volver cuando lo usas gulp.src()? ¿Qué pasa si no vuelves gulp.src()?

— jbandi

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

@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ó

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

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