Skapa vår första uppgif.webpt med Grunt

Installation och etablering av Grymta Det är något ganska enkelt att göra, men när vi väl har alla verktyg och känner till några av de grundläggande kommandona undrar vi ofta, vad kan vi göra nu? Nästa steg är väldigt enkelt, det är dags att börja bygga uppgif.webpter.
Tanken bakom en uppgif.webpt är att det är något som kan lösa vanliga problem eller aktiviteter som vi alltid utför under vår arbetsdag eller applikationsutveckling, där vi, genom att vara repetitiva i naturen, kan ställa in parametrar för dessa uppgif.webpter och därmed kan de alltid fungera utan att behöva göra dem från grunden.
KravDenna handledning rekommenderar att du känner till de grundläggande grunderna för JavaScript eftersom vi kommer att använda många saker från detta språk. Ett annat viktigt krav är att vi måste ha installerat och konfigurerat Grymta i vårt system eller sandlåda betyder det att vi måste ha Node.js, din pakethanterare npm och naturligtvis Grymta. Slutligen måste vi ha en textredigerare för att skapa innehållet i våra övningar och tillräckliga behörigheter för att skapa filer och utföra grunt -kommandot i konsolen fritt.
En uppgif.webpt är en aktivitet som har en början, en utveckling och ett slut, i Grymta en uppgif.webpt är inget annat än en funktion i JavaScript som finns i filen Gruntfile.js och det när du utför kommandot grymta i vår konsol kan vi få denna funktion att köras, vilket gör att dess innehåll lanseras.
Uppgif.webpterna hanteras på ett modulärt sätt, ungefär i stil med den grundläggande konstitutionen för Node.jsVarje gång vi definierar en ny uppsättning uppgif.webpter måste vi därför lägga till instruktionerna som anger deras modularitet.
För att skapa en uppgif.webpt behöver vi en baskod i vår fil gruntfile.js, denna kod kallas Kokplatta eftersom det är repetitivt, men vi bara använder det en gång, låt oss se hur det ser ut:

 module.exports = function (grunt) {// här är innehållet i våra uppgif.webpter};

När vi har placerat den koden i vår fil har vi redan grunden eller konstitutionen för att kunna skapa våra uppgif.webpter. När detta är gjort ska vi göra en uppgif.webpt som gör att vi kan skriva ett meddelande per konsol, för detta kommer vi att skriva följande kod:

 module.exports = function (grunt) {grunt.registerTask ('default', function () {console.log ('Hej, vi har kastat ett meddelande i Grunt.');});};

Det vi har gjort är väldigt enkelt att förklara, först har vi tagit objektet grymta som vi skapar med vår kod Kokplatta, då har vi i detta objekt kört metoden registerTask vad hjälper oss att berätta Grymta att vi lägger till en ny uppgif.webpt, nästa akt ger vi den ett namn och sedan med en anonym funktion skickar vi innehållet i vår uppgif.webpt till den, vilket i detta fall är meddelandet på konsolen.
Låt oss se hur det här exemplet ser ut när vi utför uppgif.webpten, för det i mappen där vi sparar vår fil gruntfile.js vi kommer att utföra följande kommando:

 grymta

Var ska då konsolen ge oss ett resultat som följande:

Det är viktigt att nämna att vi använder standardnamnet för den här uppgif.webpten eftersom det är uppgif.webpten som Grymta det kommer att söka som standard som namnet anger i vår fil gruntfile.js, om det inte hade det namnet skulle vi få ett fel vid körning grymta som vi ser i följande bild:

Vårt tidigare exempel, även om det fungerar, är inte det mest rekommenderade, vi har helt enkelt använt konsolen Node.js men detta har inte alla funktioner och egenskaper hos konsolen Grymta så om vi har ytterligare information från uppgif.webptsmotorn kommer vi säkert inte att se den. Det är därför vi måste använda konsolen för vår uppgif.webptsautomatiseringsmotor, konceptet i filosofi är praktiskt taget detsamma bara att vi ändrar objekt och funktioner som vi måste kalla.
Låt oss se i följande kod hur vi kan skriva om vår kod från föregående exempel för att kunna uppfylla det vi har förklarat:

 module.exports = function (grunt) {grunt.registerTask ('default', function () {grunt.log.writeln ('Det här meddelandet visas av Grunt -konsolen.');});};

Hur vi ser återanvänder vi bara objektet grymta initial av filen, sedan använder vi dess klass logga och slutligen metoden skrivit, resultatet är detsamma som i föregående exempel endast med den skillnaden att vi har använt något mer optimalt för våra ändamål. Låt oss se i följande bild hur allt underhållits korrekt:

I början pratade vi om återanvändbara uppgif.webpter och som gör att vi kan spara tid, en av de saker som kan göra det möjligt för oss att nå en tillräcklig grad av återanvändning av uppgif.webpterna är möjligheten att lägga till parametrar till dem, med detta kan vi ändra några värden Beroende på situationen där vi kan befinna oss, till exempel att skapa användare för ett system direkt med Grymta, med vilket vi kan skicka ett filnamn med en lista med användare som parameter.
I följande kod kommer vi att göra något mycket intressant, först och främst ska vi se hur vi skapar uppgif.webpter som inte är vår standardprocess, med detta kommer vi redan att ha nyckeln till att ha flera uppgif.webpter i samma fil. Parametern som kommer att ta emot vår uppgif.webpt kommer helt enkelt att ställas in i den anonyma funktionen, på så sätt kan vi fånga upp och bearbeta den i kroppen av den.
Låt oss se koden för att generera denna uppgif.webpt, som en övning kan vi placera koden efter vår standarduppgif.webpt för att testa vad vi har förklarat:

 grunt.registerTask ('säg hej', funktion (namn) {grunt.log.writeln ('Hej:' + namn + 'god morgon idag');});

För att göra konsoluppropet för uppgif.webpten gör vi helt enkelt följande:

 grymt säga hej: Namn

Hur vi kan se placerar vi namnet på uppgif.webpten och med ett kolon separerar vi för att passera den nödvändiga parametern, i det här fallet namnet som vi vill skicka till uppgif.webpten, låt oss se hur det ser ut i vår konsol:

Vad händer nu om vår uppgif.webpt behöver oss att skicka två eller flera parametrar, helt enkelt i samma kod lägger vi till dem separerade med kommatecken som en funktion JavaScript normalt, och när vi ringer dem i konsolen kan vi placera dem med samma sätt att separera, låt oss se en kod där vi utför en uppgif.webpt som visar oss detta:

 grunt.registerTask ('add', function (value1, value2) {var sum = Number (value1) + Number (value2); grunt.log.writeln ('Resultatet av att lägga till' + value1 + ' +' + value2 + ' är: '+ summa);});

Låt oss nu se hur det ser ut när vi kör igenom konsolen detta exempel med samtalet och svaret:

Något intressant som vi kunde märka är att vi använder JavaScript Platt och enkelt att definiera bearbetningen, användningen av detta språk är mycket viktigt eftersom vi på så sätt kommer att kunna utöka vår kapacitet till allt vi kan uppnå vid byggandet av våra uppgif.webpter med Grymta.
Det är möjligt att använda varningar i våra uppgif.webpter, med detta kan vi validera lite parametrarna som tas emot från användaren, till exempel är vår tidigare uppgif.webpt en summa men om vi sätter något annat än ett tal kommer vår operation säkert att misslyckas, så vi kan gör följande: med hjälp av metoden varna () Vi bekräftar att båda parametrarna är siffror och om de inte är det kommer vi att starta en varning:

 grunt.registerTask ('add', function (value1, value2) {if (isNaN (Number (value1)))) {grunt.warn ('The first value' + value1 + 'must be a number.');} if ( isNaN (Number (värde2))) {grunt.warn ('Det andra värdet' + värde2 + 'måste vara ett tal.');} Var sum = Number (värde1) + Tal (värde2); grunt.log.writeln ( 'Resultatet av att lägga till' + value1 + ' +' + ' + value2 +' är: ' + sum);});

I vår omskrivna kod har vi validerat att om resultatet av konverteringen till Siffra () av parametrarna är inte ett nummer starta metoden varna () eller varning, detta bryter tråden och visar meddelandet, så att vi kan undvika en felaktig uppgif.webpt. Låt oss se hur detta ser ut i vår konsol när vi utför uppgif.webpten:

Som vi också märker kunskaperna i språket JavaScript Det är mycket viktigt så om vi är under den nivå vi vill nå måste vi träna och försöka göra så många övningar som möjligt för att förbättra våra färdigheter.
Med detta har vi avslutat denna handledning, eftersom vi ser skapandet av uppgif.webpter med Grymta Det är inte särskilt komplext, utan dess logik vid tidpunkten för att definiera dem hjälper oss att underlätta förståelsen av användningen av verktyget. Den sanna komplexiteten ligger i definitionen av vår egen logik när vi vet vad vår uppgif.webpt kommer att göra och hur vi kan göra den så återanvändbar som möjligt, eftersom om den inte är det kommer vi att arbeta förgäves.