gulp.run은 더 이상 사용되지 않습니다.

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

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

---

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

And in the comments of the answer of @Pavel Evstigneev, @joemaller mentions that we can use run-sequence in this scenario.

But please note that, the author of run-sequence says :

This is intended to be a temporary solution until the release of gulp 4.0 which has support for defining task dependencies in series or in parallel.

Be aware that this solution is a hack, and may stop working with a future update to gulp.

So, before gulp 4.0, we can use run-sequence, after 4.0, we can just use gulp.

---

gulp 4

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

I Like gulp4 !

---

If you need to maintain the order of running tasks you can define dependencies as described here - you just need to return stream from the dependency:

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

Define the task that depends on it:

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

And use it from watch:

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

Now the dependecy task will complete before depends runs (for example your 'jasmine' and 'embed' tasks would be dependencies and you'd have another task 'server' that would depend on them). No need for any hacks.

---

To run a task before starting to watch, instead of using gulp.run() or gulp.start() just run the gulp command straight up.

So instead of:

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

Just do:

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

Or you can wrap that latter code in a "normal" function and call it whenever you want.

-- Inspired by this answer from a similar thread.

---

In Gulp 4 the only thing that seems to be working for me is:

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

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

---

I still dont see how this actually solves the question at hand.

If i have 4 tasks with dependencies defined between them

A,B,C,D

where A depends on B, etc as defined by gulp.task('A',['B'],function A(){}); and then i defined a new task using gulp.watch running just the functions would duplicate the dependencies.

e.g given these tasks (each tasks function exposed via name):

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

i can write 1)

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

which would execute A->D but if e.g Step B fails it would never enter the task (think of compile or test error)

or i can write 2)

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

which would not run A->D until something was changed first.

or i can write 3)

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

which would cause duplication (and errors over time) of the dependency hierarchy.

PS: In case someone is wondering why i would want my watch task to execute if any of the dependent tasks fail that is usually because i use watch for live development. eg. i start my watch task to begin working on tests etc. and it can be that the initial code i start out with already has issues thus errors.

So i would hope that gulp run or some equivalent stays for some time

참고URL : https://stackoverflow.com/questions/21905875/gulp-run-is-deprecated-how-do-i-compose-tasks