Attività Gulp.js, ritorno su src?

132

Sono nuovo a deglutire e ho guardato attraverso configurazioni di esempio. Alcune persone hanno la seguente struttura:

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

Altre persone hanno questo:

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

Mi chiedo che differenza fa il ritorno su src ??

javascript node.js gulp

— boldfacedesignuk
fonte

Risposte:

158

È returnper indicare che il compito è asincrona. gulp.src()restituisce un flusso, quindi è asincrono.

Senza di essa, il sistema delle attività non potrebbe sapere quando è finito. Leggi i documenti .

— Sindre Sorhus
fonte

Eccellente! grazie per la risposta Sindre. Fai sorseggiare un boccone come un fascino ora. Lo adoro.

— boldfacedesignuk,

Fantastico esattamente quello che stavo cercando :)

— Sebastien Lorber,

Significa che devi tornare quando lo usi gulp.src()? Cosa succede se non torni gulp.src()?

— jbandi,

Io secondo @Jbandi - l'ovvia domanda da porsi qui è "c'è mai qualche motivo per non tornare gulp.src(..., o dovremmo farlo sempre?" Questa risposta sarebbe più utile se affrontasse quel punto, IMO; al momento non affronta perché ci sono molti esempi di attività che chiamano gulp.src(...ma non le restituiscono.

— Mark Amery,

@jbandi: In caso contrario, returnil sistema di dipendenza potrebbe avviare un'attività prima che vengano eseguite le dipendenze. Ho un gulpfile con molte attività (principalmente generate dal codice). Poiché non stavo restituendo il flusso, un'attività dipendente stava già leggendo il file mentre la sua dipendenza era ancora in fase di sviluppo. Mi ha messo nei guai di ogni genere ...

— Gligoran,

Se si dispone di attività dipendenti, è necessario restituire il flusso affinché le attività possano essere completate prima che vengano eseguite.

per esempio

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

in quell'esempio ti aspetti che task1 venga completato (es. compilando il coffeescript o altro) prima che task2 venga eseguito ... ma a meno che non aggiungiamo return - come nell'esempio sotto - allora funzioneranno in modo sincrono e non asincrono; e il coffeescript compilato non verrà minimizzato perché task2 non avrà atteso il completamento dell'attività 1 e quindi non prenderà in considerazione l'output compilato di task1 . Quindi dovremmo sempre tornare in queste circostanze.

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

Modifica: la ricetta qui lo spiega ulteriormente. https://github.com/gulpjs/gulp/blob/master/docs/recipes/running-tasks-in-series.md

— byronyasgur
fonte

L'ho trovato utile se hai più flussi per attività. È necessario combinare / unire i flussi multipli e restituirli.

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

L'alternativa, utilizzando la struttura di definizione dell'attività di Gulps, sarebbe:

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
fonte