Maak onze eerste taak met Grunt

De installatie en inrichting van de gegrom Het is iets heel eenvoudigs om te doen, maar als we eenmaal alle tools hebben en enkele basiscommando's kennen, vragen we ons vaak af, wat kunnen we nu doen? De volgende stap is heel eenvoudig, het is tijd om te beginnen met het bouwen van taken.
Het idee achter een taak is dat het iets is dat veelvoorkomende problemen of activiteiten kan oplossen die we altijd uitvoeren tijdens onze werkdag of applicatieontwikkeling, waarbij we, omdat we repetitief van aard zijn, parameters voor deze taken kunnen instellen en dus altijd kunnen werken zonder dat je ze helemaal opnieuw hoeft te maken.
VereistenIn deze zelfstudie wordt aanbevolen dat u de basisprincipes kent van: JavaScript omdat we veel dingen uit deze taal zullen gebruiken. Een andere essentiële vereiste is dat we moeten hebben geïnstalleerd en geconfigureerd gegrom in ons systeem of in onze sandbox, betekent dit dat we moeten hebben: Node.js, uw pakketbeheerder npm en natuurlijk gegrom. Ten slotte moeten we een teksteditor hebben om de inhoud van onze oefeningen te maken en voldoende rechten om bestanden te maken en het grunt-commando vrijelijk in de console uit te voeren.
Een taak is een activiteit die een begin, een ontwikkeling en een einde heeft, in gegrom een taak is niets meer dan een functie in JavaScript die is opgenomen in het bestand Gruntfile.js en dat bij het uitvoeren van de opdracht grom in onze console kunnen we deze functie laten uitvoeren, waardoor de inhoud wordt gestart.
De taken worden modulair beheerd, veel in de stijl van de basisstructuur van Node.jsDaarom moeten we elke keer dat we een nieuwe reeks taken definiëren, de instructies toevoegen die hun modulariteit aangeven.
Om een ​​taak aan te maken hebben we een basiscode nodig in ons bestand gruntfile.js, deze code heet standaardtekst omdat het repetitief is, maar we gebruiken het maar één keer, laten we eens kijken hoe het eruit ziet:

 module.exports = functie (grunt) {// hier is de inhoud van onze taken};

Als we die code eenmaal in ons bestand hebben geplaatst, hebben we al de basis of constitutie om onze taken te kunnen maken. Zodra dit is gebeurd, gaan we een taak uitvoeren waarmee we een bericht per console kunnen schrijven, hiervoor gaan we de volgende code schrijven:

 module.exports = function (grunt) {grunt.registerTask ('default', function () {console.log ('Hallo, we hebben een bericht in Grunt gegooid.');});};

Wat we hebben gedaan is heel gemakkelijk uit te leggen, eerst hebben we het object genomen grom die we maken met onze code standaardtekst, dan hebben we in dit object de methode uitgevoerd registrerenTaak wat helpt ons om te vertellen gegrom dat we een nieuwe taak toevoegen, de volgende handeling geven we deze een naam en vervolgens geven we met een anonieme functie de inhoud van onze taak door, wat in dit geval het bericht op de console is.
Laten we eens kijken hoe dit voorbeeld eruitziet bij het uitvoeren van de taak, want het staat in de map waarin we ons bestand opslaan gruntfile.js we gaan het volgende commando uitvoeren:

 grom

Waar dan zou de console ons een resultaat moeten geven zoals het volgende:

Het is belangrijk om te vermelden dat we de standaardnaam voor deze taak gebruiken, omdat het de taak is die: gegrom het zal standaard zoeken zoals de naam aangeeft in ons bestand gruntfile.js, als het die naam niet had, zouden we een foutmelding krijgen bij het uitvoeren grom zoals we zien in de volgende afbeelding:

Ons vorige voorbeeld, hoewel het werkt, is niet het meest aanbevolen, we hebben gewoon gebruik gemaakt van de console Node.js maar dit heeft niet alle functionaliteiten en eigenschappen van de console gegrom dus als we aanvullende informatie van de taakengine hebben, zullen we deze zeker niet zien. Daarom moeten we de console van onze taakautomatiseringsengine gebruiken, het concept in de filosofie is praktisch hetzelfde, alleen dat we de objecten en de functies die we moeten aanroepen veranderen.
Laten we in de volgende code kijken hoe we onze code uit het vorige voorbeeld kunnen herschrijven om te kunnen voldoen aan wat we hebben uitgelegd:

 module.exports = function (grunt) {grunt.registerTask ('default', function () {grunt.log.writeln ('Dit bericht wordt weergegeven door de Grunt-console.');});};

Hoe we zien, hergebruiken we alleen het object grom initiaal van het bestand, dan gebruiken we zijn klasse log en tot slot de methode schrijven, het resultaat is hetzelfde als in het vorige voorbeeld, alleen met het verschil dat we iets meer optimaals hebben gebruikt voor onze doeleinden. Laten we in de volgende afbeelding zien hoe alles goed werd onderhouden:

In het begin hadden we het over herbruikbare taken en die ons in staat stellen tijd te besparen, een van de dingen die ons in staat kunnen stellen een adequate mate van hergebruik van de taken te bereiken, is de mogelijkheid om parameters eraan toe te voegen, hiermee kunnen we enkele waarden wijzigen ​​volgens de situatie waarin we ons kunnen bevinden, zoals het rechtstreeks aanmaken van gebruikers voor een systeem met gegrom, waarmee we als parameter een bestandsnaam met de lijst met gebruikers kunnen doorgeven.
In de volgende code gaan we iets heel interessants doen, allereerst gaan we zien hoe we taken kunnen maken die niet ons standaardproces zijn, hiermee hebben we al de sleutel om verschillende taken in hetzelfde bestand te hebben. De parameter die onze taak zal ontvangen, wordt eenvoudig in de anonieme functie ingesteld, op deze manier kunnen we deze vastleggen en verwerken in de hoofdtekst ervan.
Laten we de code bekijken om deze taak te genereren, als oefening kunnen we de code na onze standaardtaak plaatsen om te testen wat we hebben uitgelegd:

 grunt.registerTask ('zeg hallo', functie (naam) {grunt.log.writeln ('Hallo:' + naam + 'goedemorgen vandaag');});

Om nu de console-aanroep van de taak te doen, doen we eenvoudig het volgende:

 grunt zeg hallo: Naam

Hoe we kunnen zien, plaatsen we de naam van de taak en met een dubbele punt scheiden we om de benodigde parameter door te geven, in dit geval de naam die we naar de taak willen sturen, laten we eens kijken hoe het eruit ziet in onze console:

Wat gebeurt er nu als onze taak ons ​​nodig heeft om twee of meer parameters door te geven, gewoon in de code van dezelfde voegen we ze gescheiden door komma's toe als een functie JavaScript normaal, en wanneer we ze in de console aanroepen, kunnen we ze op dezelfde manier van scheiding plaatsen, laten we een code zien waarin we een taak uitvoeren die ons dit laat zien:

 grunt.registerTask ('toevoegen', functie (waarde1, waarde2) {var sum = Getal (waarde1) + Getal (waarde2); grunt.log.writeln ('Het resultaat van optellen' + waarde1 + '+' + waarde2 + ' is: '+ som);});

Laten we nu eens kijken hoe het eruit ziet als we dit voorbeeld door de console lopen met de oproep en het antwoord:

Iets interessants dat we konden opmerken, is dat we gebruiken JavaScript Vlak en eenvoudig om de verwerking te definiëren, het gebruik van deze taal is erg belangrijk, omdat we op deze manier onze capaciteit kunnen uitbreiden van alles wat we kunnen bereiken op het moment dat we onze taken bouwen met gegrom.
Het is mogelijk om waarschuwingen in onze taken te gebruiken, hiermee kunnen we de parameters die van de gebruiker zijn ontvangen een beetje valideren, onze vorige taak is bijvoorbeeld een som, maar als we iets anders dan een getal invoeren, zal onze bewerking zeker mislukken, dus we kunnen doe het volgende: met behulp van de methode waarschuwen () We zullen valideren dat beide parameters getallen zijn en in het geval dat dit niet het geval is, zullen we een waarschuwing lanceren:

 grunt.registerTask ('toevoegen', functie (waarde1, waarde2) {if (isNaN (Getal (waarde1))) {grunt.warn ('De eerste waarde' + waarde1 + 'moet een getal zijn.');} if ( isNaN (Getal (waarde2))) {grunt.warn ('De tweede waarde' + waarde2 + 'moet een getal zijn.');} Var sum = Getal (waarde1) + Getal (waarde 2); grunt.log.writeln ( 'Het resultaat van het optellen van '+ waarde1 +' + '+ waarde2 +' is: '+ som);});

In onze herschreven code hebben we gevalideerd dat als het resultaat van de conversie naar Nummer () van de parameters is geen getal start de methode waarschuwen () of waarschuwing, dit verbreekt de draad en geeft het bericht weer, zodat we een foutieve taak kunnen vermijden. Laten we eens kijken hoe dit eruit ziet in onze console bij het uitvoeren van de taak:

Zoals we ook merken aan de kennis van de taal JavaScript Het is erg belangrijk, dus als we onder het niveau zitten dat we willen bereiken, moeten we oefenen en proberen zoveel mogelijk oefeningen te doen om onze vaardigheden te verbeteren.
Hiermee hebben we deze tutorial voltooid, omdat we het maken van taken zien met gegrom Het is niet erg complex, maar de logica ervan bij het definiëren ervan helpt ons om het gebruik van de tool beter te begrijpen. De echte complexiteit zit in de definitie van onze eigen logica op het moment dat we weten wat onze taak zal doen en hoe we deze zo herbruikbaar mogelijk kunnen maken, want als dat niet het geval is, zullen we tevergeefs werken.