Erstelle unsere erste Aufgabe mit Grunt

Die Installation und Einrichtung der Grunzen Es ist ziemlich einfach, aber wenn wir alle Werkzeuge haben und einige der grundlegenden Befehle kennen, fragen wir uns oft, was wir jetzt tun können. Der nächste Schritt ist sehr einfach, es ist Zeit, mit dem Erstellen von Aufgaben zu beginnen.
Die Idee hinter einer Aufgabe ist, dass sie häufige Probleme oder Aktivitäten lösen kann, die wir während unseres Arbeitstages oder der Anwendungsentwicklung immer wieder ausführen, wobei wir diese Aufgaben aufgrund ihrer sich wiederholenden Natur parametrisieren können und somit immer funktionieren können ohne sie von Grund auf neu erstellen zu müssen.
AnforderungenDieses Tutorial empfiehlt, dass Sie die grundlegenden Grundlagen von JavaScript weil wir viele Dinge aus dieser Sprache verwenden werden. Eine weitere wesentliche Voraussetzung ist, dass wir installiert und konfiguriert haben müssen Grunzen in unserem System oder unserer Sandbox bedeutet dies, dass wir haben müssen Node.js, dein Paketmanager npm und natürlich Grunzen. Schließlich benötigen wir einen Texteditor, um den Inhalt unserer Übungen zu erstellen und ausreichende Berechtigungen, um Dateien zu erstellen und den Grunt-Befehl in der Konsole frei auszuführen.
Eine Aufgabe ist eine Tätigkeit, die einen Anfang, eine Entwicklung und ein Ende hat Grunzen eine Aufgabe ist nichts anderes als eine Funktion in JavaScript was in der Datei enthalten ist Gruntfile.js und das beim Ausführen des Befehls grunzen in unserer Konsole können wir diese Funktion ausführen lassen, wodurch ihr Inhalt gestartet wird.
Die Aufgaben werden modular geregelt, ganz im Stil der Grundverfassung von Node.jsDaher müssen wir jedes Mal, wenn wir einen neuen Aufgabensatz definieren, die Anweisungen hinzufügen, die ihre Modularität angeben.
Um eine Aufgabe zu erstellen, benötigen wir einen Basiscode in unserer Datei gruntfile.js, dieser Code heißt Boilerplate weil es sich wiederholt, wir es jedoch nur einmal verwenden, sehen wir uns an, wie es aussieht:

 module.exports = function (grunt) {// hier ist der Inhalt unserer Aufgaben};

Sobald wir diesen Code in unserer Datei abgelegt haben, haben wir bereits die Grundlage oder Konstitution, um unsere Aufgaben erstellen zu können. Sobald dies erledigt ist, werden wir eine Aufgabe ausführen, die es uns ermöglicht, eine Nachricht über die Konsole zu schreiben. Dazu schreiben wir den folgenden Code:

 module.exports = function (grunt) {grunt.registerTask ('default', function () {console.log ('Hallo, wir haben eine Nachricht in Grunt geworfen.');});};

Was wir gemacht haben ist ganz einfach zu erklären, zuerst haben wir das Objekt genommen grunzen die wir mit unserem Code erstellen Boilerplate, dann haben wir in diesem Objekt die Methode ausgeführt registrierenAufgabe was hilft uns zu erzählen Grunzen dass wir eine neue Aufgabe hinzufügen, als nächstes geben wir ihr einen Namen und übergeben ihr dann mit einer anonymen Funktion den Inhalt unserer Aufgabe, in diesem Fall die Nachricht auf der Konsole.
Sehen wir uns an, wie dieses Beispiel aussieht, wenn die Aufgabe ausgeführt wird, und zwar in dem Ordner, in dem wir unsere Datei speichern gruntfile.js Wir werden den folgenden Befehl ausführen:

 grunzen

Wo dann die Konsole uns ein Ergebnis wie das folgende liefern sollte:

Es ist wichtig zu erwähnen, dass wir den Standardnamen für diese Aufgabe verwenden, da dies die Aufgabe ist, die Grunzen es wird standardmäßig so suchen, wie sein Name in unserer Datei anzeigt gruntfile.js, wenn es nicht diesen Namen hätte, würden wir bei der Ausführung einen Fehler bekommen grunzen wie wir im folgenden Bild sehen:

Unser vorheriges Beispiel funktioniert zwar, ist aber nicht das empfehlenswerteste, wir haben einfach die Konsole verwendet Node.js diese hat aber nicht alle Funktionalitäten und Eigenschaften der Konsole Grunzen Wenn wir also zusätzliche Informationen von der Task-Engine haben, werden wir sie sicherlich nicht sehen. Aus diesem Grund müssen wir die Konsole unserer Task-Automatisierungs-Engine verwenden, das Konzept in der Philosophie ist praktisch dasselbe, nur dass wir die Objekte und die Funktionen ändern, die wir aufrufen müssen.
Sehen wir uns im folgenden Code an, wie wir unseren Code aus dem vorherigen Beispiel umschreiben können, um das zu erfüllen, was wir erklärt haben:

 module.exports = function (grunt) {grunt.registerTask ('default', function () {grunt.log.writeln ('Diese Nachricht wird von der Grunt-Konsole angezeigt.');});};

Wie wir sehen, verwenden wir nur das Objekt wieder grunzen Initiale der Datei, dann verwenden wir ihre Klasse Protokoll und schließlich die Methode schreiben, das Ergebnis ist das gleiche wie im vorherigen Beispiel, nur mit dem Unterschied, dass wir etwas Optimaleres für unsere Zwecke verwendet haben. Sehen wir uns im folgenden Bild an, wie alles richtig gepflegt wurde:

Am Anfang haben wir über wiederverwendbare Aufgaben gesprochen, die es uns ermöglichen, Zeit zu sparen. Eines der Dinge, die es uns ermöglichen, einen angemessenen Wiederverwendungsgrad der Aufgaben zu erreichen, ist die Möglichkeit, ihnen Parameter hinzuzufügen, mit denen wir einige Werte ändern können ​​je nach der Situation, in der wir uns befinden können, z. B. beim Erstellen von Benutzern für ein System direkt mit Grunzen, mit dem wir als Parameter einen Dateinamen mit der Liste der Benutzer übergeben können.
Im folgenden Code werden wir etwas sehr Interessantes tun. Zuerst werden wir sehen, wie wir Aufgaben erstellen, die nicht unser Standardprozess sind. Damit haben wir bereits den Schlüssel, um mehrere Aufgaben in derselben Datei zu haben. Der Parameter, der unsere Aufgabe erhält, wird einfach in der anonymen Funktion gesetzt, auf diese Weise können wir sie im Hauptteil erfassen und verarbeiten.
Sehen wir uns den Code zum Generieren dieser Aufgabe an. Als Übung können wir diesen Code nach unserer Standardaufgabe platzieren, um zu testen, was wir erklärt haben:

 grunt.registerTask ('Hallo sagen', Funktion (Name) {grunt.log.writeln ('Hallo:' + Name + 'Guten Morgen heute');});

Um nun den Konsolenaufruf der Aufgabe durchzuführen, gehen wir einfach wie folgt vor:

 Grunzen Hallo sagen: Name

Wie wir sehen, platzieren wir den Namen der Aufgabe und trennen uns mit einem Doppelpunkt, um den erforderlichen Parameter zu übergeben, in diesem Fall den Namen, den wir an die Aufgabe senden möchten, sehen wir uns an, wie es in unserer Konsole aussieht:

Was passiert nun, wenn wir für unsere Aufgabe zwei oder mehr Parameter übergeben müssen, fügen wir sie einfach im Code desselben durch Kommas getrennt als Funktion hinzu JavaScript normal, und wenn wir sie in der Konsole aufrufen, können wir sie mit der gleichen Trennung platzieren. Sehen wir uns einen Code an, in dem wir eine Aufgabe ausführen, die uns Folgendes zeigt:

 grunt.registerTask ('add', function (value1, value2) {var sum = Number (value1) + Number (value2); grunt.log.writeln ('Das Ergebnis der Addition' + value1 + '+' + value2 + ' ist: '+ Summe);});

Sehen wir uns nun an, wie es aussieht, wenn wir dieses Beispiel mit dem Aufruf und der Antwort durch die Konsole laufen lassen:

Etwas Interessantes, das uns aufgefallen ist, ist, dass wir JavaScript Die Verarbeitung ist flach und einfach zu definieren. Die Verwendung dieser Sprache ist sehr wichtig, da wir auf diese Weise unsere Kapazitäten auf alles erweitern können, was wir zum Zeitpunkt der Erstellung unserer Aufgaben mit erreichen können Grunzen.
Es ist möglich, Warnungen in unseren Aufgaben zu verwenden, damit können wir die vom Benutzer erhaltenen Parameter ein wenig validieren, zum Beispiel ist unsere vorherige Aufgabe eine Summe, aber wenn wir etwas anderes als eine Zahl eingeben, wird unsere Operation sicherlich fehlschlagen, also können wir mach folgendes: mit Hilfe der Methode warnen () Wir werden überprüfen, ob beide Parameter Zahlen sind, und falls dies nicht der Fall ist, geben wir eine Warnung aus:

 grunt.registerTask ('add', function (value1, value2) {if (isNaN (Number (value1))) {grunt.warn ('Der erste Wert' + value1 + 'muss eine Zahl sein.');} if ( isNaN (Zahl (Wert2))) {grunt.warn ('Der zweite Wert' + Wert2 + 'muss eine Zahl sein.');} Var Summe = Zahl (Wert1) + Zahl (Wert2); grunt.log.writeln ( 'Das Ergebnis der Addition von '+ Wert1 +' + '+ Wert2 +' ist: '+ Summe);});

In unserem umgeschriebenen Code haben wir validiert, dass das Ergebnis der Konvertierung in Nummer () der Parameter ist keine Zahl Starten Sie die Methode warnen () oder Warnung, dies unterbricht den Thread und zeigt die Meldung an, damit wir eine fehlerhafte Aufgabe vermeiden können. Sehen wir uns an, wie dies in unserer Konsole aussieht, wenn die Aufgabe ausgeführt wird:

Da merken wir auch die Sprachkenntnisse JavaScript Es ist sehr wichtig, dass wir, wenn wir unter dem Niveau sind, das wir erreichen wollen, üben und versuchen müssen, so viele Übungen wie möglich zu machen, um unsere Fähigkeiten zu verbessern.
Damit haben wir dieses Tutorial beendet, da wir die Erstellung von Aufgaben mit sehen Grunzen Es ist nicht sehr komplex, sondern seine Logik zum Zeitpunkt der Definition hilft uns, das Verständnis für die Verwendung des Tools zu erleichtern. Die wahre Komplexität liegt in der Definition unserer eigenen Logik in dem Moment, in dem wir wissen, was unsere Aufgabe tun wird und wie wir sie so gut wie möglich wiederverwendbar machen können, denn wenn dies nicht der Fall ist, werden wir vergebens arbeiten.