gulp.run không được dùng nữa. Làm cách nào để soạn các tác vụ?

Đây là một tác vụ đã soạn mà tôi không biết làm thế nào để thay thế nó bằng các phụ thuộc tác vụ.

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

Bản thay đổi tương ứng https://github.com/gulpjs/gulp/blob/master/CHANGELOG.md#35 [không dùng nữa gulp.run]

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

Bạn không còn cần phải chuyển một hàm (mặc dù bạn vẫn có thể) để chạy các tác vụ. Bạn có thể cung cấp cho đồng hồ một dãy tên nhiệm vụ và nó sẽ thực hiện việc này cho bạn.

Hoặc bạn có thể làm như sau:

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

nguồn: https://github.com/gulpjs/gulp/issues/755

gulp.start()không bao giờ có nghĩa là một api công cộng cũng như không được sử dụng. Và như đã nêu ở trên trong phần nhận xét, quản lý tác vụ đang được thay thế trong bản phát hành tiếp theo .... vì vậy gulp.start()sẽ bị phá vỡ.

Mục đích thực sự của thiết kế gulp là tạo ra các hàm Javascript thông thường và chỉ thực hiện nhiệm vụ gọi chúng.

Thí dụ:

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

Thứ lỗi cho tôi vì đã làm sống lại một câu hỏi cũ. Câu trả lời được chấp nhận không giải quyết vấn đề chạy các tác vụ trước khi đặt đồng hồ. Câu trả lời tiếp theo sử dụng gulp.start sẽ biến mất. Câu trả lời thứ ba chỉ ra rằng các hàm thông thường nên được sử dụng nhưng ví dụ này có vẻ lạ. Tôi đã thực hiện một số tìm kiếm nhưng không tìm thấy một ví dụ đơn giản.

Đây là giải pháp của tôi. Ý tưởng là xác định các hàm js thông thường sau đó đăng ký chúng như các tác vụ. Các chức năng sau đó có thể được gọi trực tiếp nếu cần hoặc từ trong đồng hồ.

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

Tôi mới nuốt nước bọt. Vui lòng cho tôi biết nếu tôi đã bỏ qua điều gì đó rõ ràng.

nuốt 4

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

Tôi thích gulp4!

Như @dman đã đề cập đến điều đó, gulp.startsẽ bị loại bỏ trong phiên bản tiếp theo. Ngoài ra nó có thể được nhìn thấy trong vấn đề này của nuốt .

Và trong phần nhận xét về câu trả lời của @Pavel Evstigneev, @joemaller đề cập rằng chúng ta có thể sử dụng chuỗi chạy trong trường hợp này.

Nhưng xin lưu ý rằng, tác giả của run-serial nói:

Đây được coi là một giải pháp tạm thời cho đến khi phát hành gulp 4.0 có hỗ trợ xác định các phụ thuộc nhiệm vụ theo chuỗi hoặc song song.

Xin lưu ý rằng giải pháp này là một cuộc tấn công và có thể ngừng hoạt động với bản cập nhật trong tương lai.

Vì vậy, trước gulp 4.0, chúng ta có thể sử dụng run-serial , sau 4.0, chúng ta có thể sử dụng gulp.

Nếu bạn cần duy trì thứ tự của các tác vụ đang chạy, bạn có thể xác định các phần phụ thuộc như được mô tả ở đây - bạn chỉ cần trả về luồng từ phần phụ thuộc:

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

Xác định nhiệm vụ phụ thuộc vào nó:

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

Và sử dụng nó từ đồng hồ:

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

Bây giờ dependecytác vụ sẽ hoàn thành trước khi dependschạy (ví dụ: tác vụ "jasmine" và "nhúng" của bạn sẽ là các phụ thuộc và bạn có một "máy chủ" nhiệm vụ khác sẽ phụ thuộc vào chúng). Không cần bất kỳ hack nào.

Trong Gulp 4, điều duy nhất có vẻ hiệu quả với tôi là:

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

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

Để chạy một tác vụ trước khi bắt đầu xem, thay vì sử dụng gulp.run () hoặc gulp.start (), chỉ cần chạy lệnh gulp thẳng lên.

Vì vậy, thay vì:

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

Cứ làm đi:

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

Hoặc bạn có thể bọc mã sau đó trong một hàm "bình thường" và gọi nó bất cứ khi nào bạn muốn.

- Lấy cảm hứng từ câu trả lời này từ một chủ đề tương tự .

Tôi vẫn không biết làm thế nào điều này thực sự giải quyết câu hỏi trong tầm tay.

Nếu tôi có 4 nhiệm vụ với các phụ thuộc được xác định giữa chúng

A B C D

trong đó A phụ thuộc vào B, v.v. như được định nghĩa bởi gulp.task('A',['B'],function A(){});và sau đó tôi đã xác định một tác vụ mới bằng cách sử dụng gulp.watch chỉ chạy các chức năng sẽ sao chép các phụ thuộc.

Ví dụ: đưa ra các nhiệm vụ này (mỗi chức năng nhiệm vụ được hiển thị thông qua tên):

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

tôi có thể viết 1)

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

mà sẽ thực thi A-> D nhưng nếu ví dụ: Bước B không thành công, nó sẽ không bao giờ nhập tác vụ (hãy nghĩ đến lỗi biên dịch hoặc kiểm tra)

hoặc tôi có thể viết 2)

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

mà sẽ không chạy A-> D cho đến khi một cái gì đó được thay đổi đầu tiên.

hoặc tôi có thể viết 3)

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

điều này sẽ gây ra sự trùng lặp (và lỗi theo thời gian) của hệ thống phân cấp phụ thuộc.

Tái bút: Trong trường hợp ai đó đang thắc mắc tại sao tôi muốn tác vụ đồng hồ của mình thực thi nếu bất kỳ tác vụ phụ thuộc nào không thành công, thường là do tôi sử dụng đồng hồ để phát triển trực tiếp. ví dụ. tôi bắt đầu tác vụ đồng hồ của mình để bắt đầu làm việc với các bài kiểm tra, v.v. và có thể mã ban đầu mà tôi bắt đầu sử dụng đã có vấn đề do đó có lỗi.

Vì vậy, tôi hy vọng rằng chạy nuốt hoặc một số tương đương sẽ ở lại trong một thời gian