gulp.run은 더 이상 사용되지 않습니다. 작업을 어떻게 작성합니까?

다음은 작업 종속성으로 대체하는 방법을 모르는 구성된 작업입니다.

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

해당 변경 로그 https://github.com/gulpjs/gulp/blob/master/CHANGELOG.md#35 [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']);
});

작업을 실행하기 위해 더 이상 함수를 전달할 필요가 없습니다. watch에 작업 이름 배열을 제공 할 수 있으며이 작업을 수행합니다.

또는 다음과 같이 할 수 있습니다.

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

출처 : https://github.com/gulpjs/gulp/issues/755

gulp.start()공개 API가 아니거나 사용되지 않았습니다. 위에서 언급했듯이 작업 관리는 다음 릴리스에서 대체됩니다 gulp.start().

꿀꺽 꿀꺽 디자인의 진정한 의도는 일반 자바 스크립트 함수를 만들고이를 호출하는 작업 만 만드는 것입니다.

예:

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

오래된 질문을 부활시킨 것을 용서하십시오. 허용되는 답변은 시계를 설정하기 전에 작업 실행 문제를 해결하지 않습니다. 다음 답변은 사라지는 gulp.start를 사용합니다. 세 번째 대답은 일반 함수를 사용해야하지만 예제는 이상하게 보입니다. 나는 약간의 검색을했지만 간단한 예를 찾지 못했습니다.

여기 내 해결책이 있습니다. 아이디어는 일반 js 함수를 정의한 다음 작업으로 등록하는 것입니다. 그런 다음 필요한 경우 직접 또는 시계 내에서 함수를 호출 할 수 있습니다.

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

나는 꿀꺽 꿀꺽 마시기 처음입니다. 내가 명백한 것을 간과했다면 알려주십시오.

꿀꺽 4

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

나는 gulp4를 좋아한다!

@dman이 언급했듯이 gulp.start다음 버전에서는 폐기됩니다. 또한 gulp의 이번 호 에서 볼 수 있습니다 .

그리고 @Pavel Evstigneev의 답변에 대한 의견에서 @joemaller는 이 시나리오에서 실행 시퀀스 를 사용할 수 있다고 언급합니다 .

그러나 run-sequence의 저자는 다음과 같이 말합니다.

이것은 직렬 또는 병렬로 작업 종속성을 정의하는 것을 지원하는 gulp 4.0이 릴리스 될 때까지 임시 솔루션으로 사용하기위한 것입니다.

이 솔루션은 해킹이며 향후 gulp 업데이트 작업을 중단 할 수 있습니다.

따라서 gulp 4.0 이전에는 run-sequence를 사용할 수 있고 4.0 이후에는 gulp를 사용할 수 있습니다.

실행중인 작업의 순서를 유지해야하는 경우 여기에 설명 된대로 종속성을 정의 할 수 있습니다 . 종속성에서 스트림을 반환하기 만하면됩니다.

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

종속 된 작업을 정의합니다.

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

시계에서 사용 :

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

이제 dependecy작업이 depends실행 되기 전에 완료 됩니다 (예를 들어 'jasmine'및 'embed'작업은 종속성이되고 이에 종속되는 다른 작업 '서버'가 있습니다). 해킹이 필요 없습니다.

Gulp 4에서 나를 위해 일하는 유일한 것은 다음과 같습니다.

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

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

감시를 시작하기 전에 작업을 실행하려면 gulp.run () 또는 gulp.start ()를 사용하는 대신 gulp 명령을 바로 실행하십시오.

그래서 대신 :

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

그냥 해:

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

또는 후자의 코드를 "일반"함수로 래핑하고 원할 때마다 호출 할 수 있습니다.

- 유사한 스레드에서이 답변에서 영감을 얻었습니다 .

나는 이것이 실제로 당면한 질문을 어떻게 해결하는지 아직 보지 못한다.

종속성이 정의 된 4 개의 작업이있는 경우

A, B, C, D

여기서 A는에서 정의한대로 B 등에 gulp.task('A',['B'],function A(){});의존하고 함수 만 실행하는 gulp.watch를 사용하여 새 작업을 정의하면 종속성이 복제됩니다.

예를 들어 다음과 같은 작업이 주어집니다 (각 작업 기능은 이름을 통해 노출됨).

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

나는 쓸 수있다 1)

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

A-> D를 실행하지만 예를 들어 단계 B가 실패하면 작업에 들어 가지 않습니다 (컴파일 또는 테스트 오류를 ​​생각해보십시오).

또는 2)

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

어떤 것이 먼저 변경 될 때까지 A-> D를 실행하지 않습니다.

또는 3)

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

이는 종속성 계층 구조의 중복 (및 시간 경과에 따른 오류)을 유발합니다.

추신 : 누군가가 내가 라이브 개발을 위해 시계를 사용하기 때문에 종속 작업이 실패하면 왜 내 시계 작업을 실행 해야하는지 궁금해하는 경우. 예. 나는 테스트 작업을 시작하기 위해 시계 작업을 시작하고 시작하는 초기 코드에 이미 문제가 있으므로 오류가 발생할 수 있습니다.

그래서 나는 꿀꺽 꿀꺽 마시거나 그와 동등한 것이 얼마 동안 머물기를 바랍니다.