gulp.run ist veraltet. Wie komponiere ich Aufgaben?

Hier ist eine zusammengesetzte Aufgabe, die ich nicht durch Aufgabenabhängigkeiten ersetzen kann.

...
gulp.task('watch', function () {
 var server = function(){
  gulp.run('jasmine');
  gulp.run('embed');
 };
 var client = function(){
  gulp.run('scripts');
  gulp.run('styles');
  gulp.run('copy');
  gulp.run('lint');
 };
 gulp.watch('app/*.js', server);
 gulp.watch('spec/nodejs/*.js', server);
 gulp.watch('app/backend/*.js', server);
 gulp.watch('src/admin/*.js', client);
 gulp.watch('src/admin/*.css', client);
 gulp.watch('src/geojson-index.json', function(){
  gulp.run('copygeojson');
 });
});

Das entsprechende Änderungsprotokoll https://github.com/gulpjs/gulp/blob/master/CHANGELOG.md#35 [gulp.run veralten]

gulp.task('watch', function () {
  var server = ['jasmine', 'embed'];
  var client = ['scripts', 'styles', 'copy', 'lint'];
  gulp.watch('app/*.js', server);
  gulp.watch('spec/nodejs/*.js', server);
  gulp.watch('app/backend/*.js', server);
  gulp.watch('src/admin/*.js', client);
  gulp.watch('src/admin/*.css', client);
  gulp.watch('src/geojson-index.json', ['copygeojson']);
});

Sie müssen keine Funktion mehr übergeben (obwohl Sie dies noch können), um Aufgaben auszuführen. Sie können watch eine Reihe von Aufgabennamen geben, die dies für Sie erledigen.

Oder Sie können so tun:

gulp.start('task1', 'task2');

Quelle: https://github.com/gulpjs/gulp/issues/755

gulp.start()war nie als öffentliche API gedacht oder benutzt. Und wie oben in den Kommentaren erwähnt, wird die Aufgabenverwaltung in der nächsten Version ersetzt gulp.start().

Die wahre Absicht des gulp-Designs ist es, reguläre Javascript-Funktionen zu erstellen und nur die Aufgabe zu übernehmen, sie aufzurufen.

Beispiel:

function getJsFiles() {
    var sourcePaths = [
        './app/scripts/**/*.js',
        '!./app/scripts/**/*.spec.js',
        '!./app/scripts/app.js'
    ];

    var sources = gulp.src(sourcePaths, { read: false }).pipe(angularFilesort());

    return gulp.src('./app/index.html')
        .pipe(injector(sources, { ignorePath: 'app', addRootSlash: false }))
        .pipe(gulp.dest('./app'));
}  

gulp.task('js', function () {
    jsStream = getJsFiles();
});

Vergib mir, dass ich eine alte Frage wiederbelebt habe. Die akzeptierte Antwort behandelt nicht das Problem der Ausführung von Aufgaben vor dem Einstellen der Uhren. Die nächste Antwort verwendet gulp.start, das verschwindet. Die dritte Antwort weist darauf hin, dass reguläre Funktionen verwendet werden sollten, aber das Beispiel scheint seltsam. Ich habe etwas gesucht, aber kein einfaches Beispiel gefunden.

Hier ist meine Lösung. Die Idee ist, reguläre js-Funktionen zu definieren und sie dann als Aufgaben zu registrieren. Die Funktionen können dann bei Bedarf direkt oder innerhalb einer Uhr aufgerufen werden.

var 
  gulp     = require('gulp'),
  concat   = require('gulp-concat'),
  markdown = require('gulp-showdown')
;
var scriptFiles   = [ 'ang/app.js' ];
var markdownFiles = [ 'content/articles/*.md'];

var watchTask = function() 
{
  buildTask();

  gulp.watch(scriptFiles,  ['scripts' ]);
  gulp.watch(markdownFiles,['markdown']);
};
gulp.task('watch',watchTask);

var buildTask = function()
{
  scriptsTask();
  markdownTask();
};
gulp.task('build',buildTask);

var markdownTask = function() 
{
  gulp.src(markdownFiles)
    .pipe(markdown())
    .pipe(gulp.dest('web/articles'));
};
gulp.task('markdown',markdownTask);

var scriptsTask = function() 
{
  gulp.src(scriptFiles)
    .pipe(concat('app.js'))
    .pipe(gulp.dest('web/js'));

  gulp.src(
    [
      'bower_components/angular/angular.min.js',
      'bower_components/angular-route/angular-route.min.js'
    ])
    .pipe(concat('vendor.js'))
    .pipe(gulp.dest('web/js'));

  gulp.src(
    [
      'bower_components/angular/angular.min.js.map',
      'bower_components/angular-route/angular-route.min.js.map'
    ])
    .pipe(gulp.dest('web/js'));
};
gulp.task('scripts', scriptsTask);

Ich bin neu zu schlucken. Bitte lassen Sie mich wissen, wenn ich etwas Offensichtliches übersehen habe.

schlucken 4

gulp.parallel('taskName1', 'taskName2')()
gulp.series('taskName1', 'taskName2')()

Ich mag gulp4!

Wie @dman erwähnt, gulp.startwird dies in der nächsten Version verworfen. Auch in dieser Ausgabe von gulp ist zu sehen .

Und in den Kommentaren der Antwort von @Pavel Evstigneev, @joemaller erwähnt , dass wir verwenden können Laufsequenz in diesem Szenario.

Bitte beachten Sie jedoch, dass der Autor der Run-Sequenz sagt:

Dies soll eine vorübergehende Lösung bis zur Veröffentlichung von gulp 4.0 sein, die das Definieren von Aufgabenabhängigkeiten in Reihe oder parallel unterstützt.

Beachten Sie, dass diese Lösung ein Hack ist und möglicherweise nicht mehr mit einem zukünftigen Update für gulp arbeitet.

Vor gulp 4.0 können wir also die Run-Sequenz verwenden , nach 4.0 können wir nur noch gulp verwenden.

Wenn Sie die Reihenfolge der ausgeführten Aufgaben beibehalten müssen, können Sie Abhängigkeiten wie hier beschrieben definieren. Sie müssen lediglich den Stream aus der Abhängigkeit zurückgeben:

gulp.task('dependency', function () {
  return gulp.src('glob')
    .pipe(plumber())
    .pipe(otherPlugin())
    .pipe(gulp.dest('destination'));
});

Definieren Sie die davon abhängige Aufgabe:

gulp.task('depends', [ 'dependency' ], function () {
  // do work
});

Und benutze es von der Uhr:

gulp.task('watch', function () {
  watch('glob', [ 'depends' ]);
});

Jetzt wird die dependecyAufgabe vor der Ausführung abgeschlossen depends(zum Beispiel wären Ihre Aufgaben "Jasmin" und "Einbetten" Abhängigkeiten, und Sie hätten einen anderen "Server" für Aufgaben, der von ihnen abhängen würde). Keine Notwendigkeit für Hacks.

In Gulp 4 scheint das einzige, was für mich zu funktionieren scheint:

gulp.task('watch', function() {
    gulp.watch(['my-files/**/*'], gulp.series('my-func'));
});

gulp.task('my-func', function() {
    return gulp.src('[...]').pipe(gulp.dest('...'));
});

Um eine Aufgabe auszuführen, bevor Sie mit dem Ansehen beginnen, führen Sie statt gulp.run () oder gulp.start () einfach den Befehl gulp direkt nach oben aus.

Also statt:

var compress = function () {
    return gulp.src('js/vendor/*.js')
        .pipe(concat('vendor.js'))
        .pipe(gulp.dest('./build/js/'));
};

Mach einfach:

gulp.src('js/vendor/*.js')
        .pipe(concat('vendor.js'))
        .pipe(gulp.dest('./build/js/'));

Oder Sie können den letzteren Code in eine "normale" Funktion einschließen und ihn aufrufen, wann immer Sie möchten.

- Inspiriert von dieser Antwort aus einem ähnlichen Thread .

Ich sehe immer noch nicht, wie dies die vorliegende Frage tatsächlich löst.

Wenn ich 4 Aufgaben habe, zwischen denen Abhängigkeiten definiert sind

A B C D

Dabei hängt A von B usw. ab, wie durch definiert, gulp.task('A',['B'],function A(){});und dann habe ich mit gulp.watch eine neue Aufgabe definiert, bei der nur die Funktionen ausgeführt werden, um die Abhängigkeiten zu duplizieren.

zB gegeben diese Aufgaben (jede Aufgabenfunktion wird über den Namen angezeigt):

function A(){}
gulp.task('A',['B'],A);

function A(){}
gulp.task('A',['B'],A);

function B(){}
gulp.task('B',['C'],B);

function C(){}
gulp.task('C',['D'],C);

function D(){}
gulp.task('D',[],D);

ich kann schreiben 1)

gulp.task('WATCHER', ['A'], function(){
   ...
}

Dies würde A-> D ausführen, aber wenn z. B. Schritt B fehlschlägt, würde es niemals in die Aufgabe eintreten (denken Sie an Kompilierungs- oder Testfehler).

oder ich kann schreiben 2)

gulp.task('WATCHER', [], function(){
   gulp.watch(...,['A'])
}

die nicht A-> D laufen würde, bis etwas zuerst geändert wurde.

oder ich kann schreiben 3)

gulp.task('WATCHER', [], function(){
   D();
   C();
   B();
   A();
   gulp.watch(...,['A'])
}

Dies würde zu Duplikaten (und Fehlern im Laufe der Zeit) der Abhängigkeitshierarchie führen.

PS: Falls sich jemand fragt, warum ich möchte, dass meine Überwachungsaufgabe ausgeführt wird, wenn eine der abhängigen Aufgaben fehlschlägt, liegt dies normalerweise daran, dass ich watch für die Live-Entwicklung verwende. z.B. Ich starte meine Überwachungsaufgabe, um mit der Arbeit an Tests usw. zu beginnen, und es kann sein, dass der ursprüngliche Code, mit dem ich beginne, bereits Probleme aufweist, also Fehler.

Also würde ich hoffen, dass der Schlucklauf oder ein gleichwertiges Produkt für einige Zeit bleibt