Grunzen - Aufgaben erstellen

In diesem Kapitel erfahren Sie , wie Sie Aufgaben erstellen . Wann immer Sie Grunt ausführen, werden eine oder mehrere Aufgaben angegeben, die Grunt darüber informieren, was Sie möchten. Wenn Sie die Standardaufgabe angeben , wird sie standardmäßig ausgeführt.

Alias-Aufgaben

Immer wenn eine Liste von Aufgaben angegeben wird, können eine oder mehrere andere Aufgaben durch eine neue Aufgabe mit einem Alias versehen werden. Durch Ausführen des Alias werden wiederum alle in der TaskList angegebenen Aufgaben ausgeführt . Das taskList- Argument sollte ein Array von Aufgaben sein, wie unten gezeigt -

grunt.registerTask(taskName, [description, ] taskList)

Wenn Sie beispielsweise eine TaskList mit jshint- , concat- und uglify- Tasks definieren und den taskName als Standard angeben , werden alle aufgelisteten Tasks automatisch ausgeführt, wenn Grunt ohne Angabe von Tasks ausgeführt wird.

grunt.registerTask('default', ['jshint', 'concat', 'uglify']);

Sie können auch Aufgabenargumente wie unten gezeigt angeben -

grunt.registerTask('dist', ['concat:dist', 'uglify:dist']);

In der obigen Aufgabe führt der Alias dist sowohl die Aufgaben concat als auch uglify aus .

Multi Aufgaben

Wenn Sie mehrere Aufgaben ausführen, sucht Grunt in der Grunt-Konfiguration nach einer gleichnamigen Eigenschaft. Diese Aufgaben können mehrere Konfigurationen haben, die mit willkürlich benannten Zielen definiert werden .

Wenn Sie sowohl eine Aufgabe als auch ein Ziel angeben, wird nur die angegebene Zielkonfiguration verarbeitet.

grunt concat:foo

Der obige Befehl führt nur das Ziel foo aus .

Wenn Sie nur eine Aufgabe angeben, werden alle Ziele verarbeitet.

grunt concat

Der obige Befehl durchläuft alle Ziele der Concat- Aufgabe.

Wenn Sie eine Aufgabe mit grunt.task.renameTask umbenennen , wird eine Eigenschaft mit neuem Aufgabennamen von Grunt im Konfigurationsobjekt durchsucht.

grunt.initConfig({
   log: {
      foo: [1, 2, 3],
      bar: 'Welcome to tutorialspoint',
      sap: true
   }
});

grunt.registerMultiTask('log', 'Log stuff.', function() {
   grunt.log.writeln(this.target + ': ' + this.data);
});

Im obigen Beispiel protokolliert Multi-Task foo: 1,2,3, wenn Grunt durch grunt log: foo ausgeführt wurde, oder protokolliert bar: Willkommen bei tutorialspoint, wenn grunt log: bar ausgeführt wird . Es wird foo protokolliert : 1,2,3 dann bar: Willkommen bei tutorialspoint, dann sap: true, wenn Grunt als Grunzprotokoll ausgeführt wird .

Grundlegende Aufgaben

Immer wenn Sie eine grundlegende Aufgabe ausführen, durchsucht Grunt weder die Konfiguration noch die Umgebung. Stattdessen wird die angegebene Taskfunktion ausgeführt und alle durch Doppelpunkte getrennten Argumente übergeben, die als Funktionsargumente angegeben sind.

grunt.registerTask(taskName, [description, ] taskFunction)

Im folgenden Beispiel protokolliert die Task foo und testet 123, wenn Grunt über den Befehl grunt foo: testing: 123 ausgeführt wird. Immer wenn die Aufgabe ohne Argumente als grunzendes foo ausgeführt wird, protokolliert die Aufgabe foo, keine Argumente .

grunt.registerTask('foo', 'A simple task to logs stuff.', function(arg1, arg2) {
   if (arguments.length === 0) {
      grunt.log.writeln(this.name + ", no args");
   } else {
      grunt.log.writeln(this.name + ", " + arg1 + " " + arg2);
   }
});

Benutzerdefinierte Aufgaben

Wenn Sie der Multi-Task- Struktur nicht folgen möchten , können Sie Ihre benutzerdefinierte Aufgabe wie folgt definieren:

grunt.registerTask('default', 'My "default" task description.', function() {
  grunt.log.writeln('Currently running the "default" task.');
});

Es ist möglich, eine Aufgabe innerhalb einer anderen Aufgabe auszuführen, wie unten gezeigt -

grunt.registerTask('foo', 'My "foo" task.', function() {
   // Enqueue bar and baz tasks, to run after foo completes, in-order.
   grunt.task.run('bar', 'baz');
   // Or:
   grunt.task.run(['bar', 'baz']);
});

Sie können auch asynchrone Aufgaben erstellen, wie unten gezeigt -

grunt.registerTask('asyncfoo', 'My "asyncfoo" task.', function() {
   // Force task into async mode and grab a handle to the done() function.
   var done = this.async();
   // Run some sync stuff.
   grunt.log.writeln('Processing your task..');
   // Run some async stuff.
   setTimeout(function() {
      grunt.log.writeln('Finished!');
      done();
   }, 1000);
});

Sie können Aufgaben erstellen, die auf ihren Namen und ihre Argumente zugreifen können, wie unten gezeigt -

grunt.registerTask('foo', 'My task "foo" .', function(a, b) {
   grunt.log.writeln(this.name, a, b);
});

// Usage:
// grunt foo
//   logs: "foo", undefined, undefined
// grunt foo:bar
//   logs: "foo", "bar", undefined
// grunt foo:bar:baz
//   logs: "foo", "bar", "baz"

Sie können Ihre Aufgabe so erstellen, dass die Aufgaben bei jeder Protokollierung von Fehlern wie unten gezeigt fehlschlagen können.

grunt.registerTask('foo', 'My task "foo" .', function() {
   if (failureOfSomeKind) {
      grunt.log.error('This is an error message.');
   }

   // If this task had errors then fail by returning false
   if (ifErrors) { return false; }

   grunt.log.writeln('This is success message');
});

Wenn eine Aufgabe fehlschlägt, wird jede folgende Aufgabe beendet, sofern nicht --force angegeben wurde.

grunt.registerTask('foo', 'My task "foo" .', function() {
   // Fail synchronously.
   return false;
});

grunt.registerTask('bar', 'My task "bar" .', function() {
   var done = this.async();
   setTimeout(function() {
      // Fail asynchronously.
      done(false);
   }, 1000);
});

Aufgaben können für eine erfolgreiche Ausführung von anderen Aufgaben abhängig sein. Denken Sie daran, dass grunt.task.requires keine anderen Aufgaben ausführt, sondern nur prüft, ob sie ausgeführt wurden und nicht fehlgeschlagen sind.

grunt.registerTask('foo', 'My task "foo" .', function() {
   return false;
});

grunt.registerTask('bar', 'My task "bar" .', function() {
   // Fail task if foo task failed or never ran.
   grunt.task.requires('foo');
   // This code executes if the foo task executed successfully.
   grunt.log.writeln('Hello, World.. Welcome to Tutorialspoint!..');
});

// Usage:
// grunt foo bar doesn't log, because foo failed to execute.
// **Note: This is an example of space-separated sequential commands,
// (similar to executing two lines of code: `grunt foo` then `grunt bar`)
// grunt bar doesn't log, because foo never ran.

Aufgaben können sogar fehlschlagen, wenn die erforderlichen Konfigurationseigenschaften nicht gefunden werden.

grunt.registerTask('foo', 'My task "foo" .', function() {
   // Fail task if meta.name config properties is missing
   // Format 1: String 
   grunt.config.requires('meta.name');
   // or Format 2: Array
   grunt.config.requires(['meta', 'name']);
   // Log... conditionally.
   grunt.log.writeln('This only log if meta.name is defined in the config.');
});

Aufgaben können wie unten gezeigt auf die Konfigurationseigenschaften zugreifen -

grunt.registerTask('foo', 'My task "foo" .', function() {
   // Log the value of the property. Returns null if the property is undefined.
   grunt.log.writeln('The meta.name property is: ' + grunt.config('meta.name'));
   // Also logs the value of the property. Returns null if the property is undefined.
   grunt.log.writeln('The meta.name property is: ' + grunt.config(['meta', 'name']));
});