gulp.run está obsoleto. ¿Cómo redacto tareas?


97

Aquí hay una tarea compuesta que no sé cómo reemplazarla con dependencias de tareas.

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

El registro de cambios correspondiente https://github.com/gulpjs/gulp/blob/master/CHANGELOG.md#35 [desaprobar gulp.run]

Respuestas:


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

Ya no necesita pasar una función (aunque todavía puede) para ejecutar tareas. Puede darle al reloj una variedad de nombres de tareas y lo hará por usted.


13
¿Qué sucede si quiero ejecutar alguna tarea antes de comenzar a mirar? Por ejemplo, quiero mirar scripts, pero también tiene sentido forzar la ejecución de esta tarea de inmediato (sin esperar hasta que cambie algún archivo de script).
Monseñor

4
¿Y hay alguna forma de pasar argumentos a esas tareas?
Dr. Ernie

7
@rachel irrelevante para la pregunta que hizo Monsingor.
Mark Amery

6
@Monsingor Para lograrlo, puede definir una nueva tarea que ejecute una lista de tareas. Por ejemplo, suelo definir la siguiente tarea predeterminada gulp.task('default', ['build', 'watch']);, que primero se compila y luego comienza a mirar.
Bastiaan van den Berg

1
@BastiaanvandenBerg Pensé que las tareas de gulp estaban diseñadas para ejecutarse en paralelo. Por lo tanto, aunque enumere la compilación primero, no tiene que terminar antes de que se active la tarea de observación. Recibo del OP que quieren asegurarse de que la compilación haya finalizado antes de que comience la visualización.
Sean Ryan

85

O puedes hacer esto:

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

3
¿Es seguro usar esto? No lo veo mencionado en los documentos de la API (enlace) .
Felix Rabe

4
.startes un método de orquestador. Dado que Gulp hereda de eso, debería funcionar. Estoy activando una tarea de tragar desde una función que no es de tragar (watchify) y parece que funciona.
joemaller

24
gulp.startse eliminará en la próxima versión: github.com/gulpjs/gulp/issues/505#issuecomment-45379280
yckart

13
@yckart entonces, ¿qué usamos para ejecutar una tarea?
Chovy

6
Al revisar esto, la mayoría de los usos de gulp-startse pueden reemplazar con run-sequence npmjs.com/package/run-sequence
joemaller

25

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

gulp.start()nunca tuvo la intención de ser una API pública ni se usó. Y como se indicó anteriormente en los comentarios, la administración de tareas se reemplazará en la próxima versión ... por gulp.start()lo que se romperá.

La verdadera intención del diseño de gulp es crear funciones regulares de Javascript y solo realizar la tarea de llamarlas.

Ejemplo:

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

12

Perdóname por resucitar una vieja pregunta. La respuesta aceptada no aborda el problema de ejecutar tareas antes de configurar los relojes. La siguiente respuesta usa gulp.start, que desaparece. La tercera respuesta señala que se deben usar funciones regulares, pero el ejemplo parece extraño. Hice algunas búsquedas pero no encontré un ejemplo simple.

Aquí está mi solución. La idea es definir funciones js regulares y luego registrarlas como tareas. Las funciones se pueden llamar directamente si es necesario o desde dentro de un reloj.

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

Soy nuevo en tragar. Por favor, avíseme si he pasado por alto algo obvio.


Esto también hace que sea más fácil crear tareas de "compilación" y tareas de "reconstrucción", donde ambas llaman a la función que hace el trabajo, pero la última también depende de la tarea "limpia".
Seth

1
¿No tiene esto también el mismo problema que una tarea de trago normal, en el sentido de que el JS pasará a las gulp.watchtareas definidas watchTask()antes de que buildTask()se confirme que está completo? Siento que esto sigue siendo una condición de carrera y no garantiza la construcción antes de la visualización.
Sean Ryan

7

trago 4

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

¡Me gusta gulp4!


La mejor respuesta después de buscar mucho. Gracias.
AminFarajzadeh

5

Como @dman menciona eso, gulp.startserá descartado en la próxima versión. También se puede ver en este número de gulp .

Y en los comentarios de la respuesta de @Pavel Evstigneev, @joemaller menciona que podemos usar run-sequence en este escenario.

Pero tenga en cuenta que, el autor de run-sequence dice:

Se pretende que sea una solución temporal hasta el lanzamiento de gulp 4.0, que tiene soporte para definir dependencias de tareas en serie o en paralelo.

Tenga en cuenta que esta solución es un truco y puede dejar de funcionar con una actualización futura de gulp.

Entonces, antes de gulp 4.0, podemos usar run-sequence , después de 4.0, simplemente podemos usar gulp.


3

Si necesita mantener el orden de las tareas en ejecución, puede definir las dependencias como se describe aquí ; solo necesita devolver el flujo de la dependencia:

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

Defina la tarea que depende de ella:

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

Y úsalo desde el reloj:

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

Ahora la dependecytarea se completará antes de dependsejecutarse (por ejemplo, sus tareas 'jazmín' e 'incrustación' serían dependencias y tendría otro 'servidor' de tareas que dependería de ellas). No es necesario ningún truco.


No estoy seguro si no está fuera de tema, porque solo responde preguntas de comentarios que deberían ser preguntas separadas
Killah

2

En Gulp 4, lo único que parece funcionar para mí es:

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

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

1

Para ejecutar una tarea antes de comenzar a mirar, en lugar de usar gulp.run () o gulp.start (), simplemente ejecute el comando gulp directamente.

Entonces en lugar de:

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

Solo haz:

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

O puede envolver ese último código en una función "normal" y llamarlo cuando lo desee.

- Inspirado por esta respuesta de un hilo similar .


0

Todavía no veo cómo esto realmente resuelve la pregunta en cuestión.

Si tengo 4 tareas con dependencias definidas entre ellas

A B C D

donde A depende de B, etc., según lo definido por gulp.task('A',['B'],function A(){}); y luego definí una nueva tarea usando gulp.watch ejecutando solo las funciones duplicaría las dependencias.

por ejemplo, dadas estas tareas (cada función de tareas expuesta a través del nombre):

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

puedo escribir 1)

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

que ejecutaría A-> D pero si, por ejemplo, el Paso B falla, nunca entraría en la tarea (piense en un error de compilación o prueba)

o puedo escribir 2)

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

que no ejecutaría A-> D hasta que se cambiara algo primero.

o puedo escribir 3)

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

lo que causaría duplicación (y errores a lo largo del tiempo) de la jerarquía de dependencias.

PD: En caso de que alguien se pregunte por qué querría que se ejecute mi tarea de vigilancia si alguna de las tareas dependientes falla, generalmente se debe a que uso la vigilancia para el desarrollo en vivo. p.ej. Comienzo mi tarea de reloj para comenzar a trabajar en pruebas, etc. y puede ser que el código inicial con el que comienzo ya tenga problemas, por lo tanto, errores.

Así que espero que gulp run o algo equivalente se quede por algún tiempo


¿A qué respuesta existente se dirige esta refutación?
Mogsdad
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.