Opret vores første opgave med Grunt

Installation og etablering af Grynte Det er noget ganske enkelt at gøre, men når vi først har alle værktøjerne og kender nogle af de grundlæggende kommandoer, spekulerer vi ofte over, hvad kan vi gøre nu? Det næste trin er meget enkelt, det er tid til at begynde at bygge opgaver.
Ideen bag en opgave er, at det er noget, der kan løse hyppige problemer eller aktiviteter, som vi altid udfører i løbet af vores arbejdsdag eller applikationsudvikling, hvor vi, hvis vi er gentagne i naturen, kan indstille parametre til disse opgaver, og dermed kan de altid fungere uden behov for at skulle lave dem fra bunden.
KravDenne vejledning anbefaler, at du kender de grundlæggende principper for JavaScript fordi vi vil bruge mange ting fra dette sprog. Et andet vigtigt krav er, at vi skal have installeret og konfigureret Grynte i vores system eller sandkasse betyder det, at vi skal have Node.js, din pakkeleder npm og selvfølgelig Grynte. Endelig skal vi have en tekstredigerer til at oprette indholdet af vores øvelser og tilstrækkelige tilladelser til at oprette filer og udføre grunt -kommandoen i konsollen frit.
En opgave er en aktivitet, der har en begyndelse, en udvikling og en ende, i Grynte en opgave er intet mere end en funktion i JavaScript som er indeholdt i filen Gruntfile.js og det når kommandoen udføres grynte i vores konsol kan vi få denne funktion til at blive udført, hvilket får dens indhold til at blive lanceret.
Opgaverne styres på en modulær måde, meget i stil med den grundlæggende forfatning af Node.jsHver gang vi definerer et nyt sæt opgaver, skal vi derfor tilføje de instruktioner, der angiver deres modularitet.
For at oprette en opgave har vi brug for en basiskode i vores fil gruntfile.js, denne kode kaldes kogeplade fordi det er gentaget, men vi kun bruger det én gang, lad os se, hvordan det ser ud:

 module.exports = function (grynt) {// her er indholdet af vores opgaver};

Når vi har placeret den kode i vores fil, har vi allerede grundlaget eller forfatningen til at kunne oprette vores opgaver. Når dette er gjort, skal vi udføre en opgave, der giver os mulighed for at skrive en besked efter konsol, til dette vil vi skrive følgende kode:

 module.exports = function (grunt) {grunt.registerTask ('default', function () {console.log ('Hej, vi har smidt en besked i Grunt.');});};

Det vi har gjort er meget let at forklare, først har vi taget objektet grynte som vi opretter med vores kode kogeplade, så i dette objekt har vi udført metoden registerTask hvad hjælper os med at fortælle Grynte at vi tilføjer en ny opgave, næste handling giver vi den et navn og derefter med en anonym funktion videregiver vi indholdet af vores opgave til den, hvilket i dette tilfælde er beskeden på konsollen.
Lad os se, hvordan dette eksempel ser ud, når opgaven udføres, for den i den mappe, hvor vi gemmer vores fil gruntfile.js vi vil udføre følgende kommando:

 grynte

Hvor skulle konsollen så give os et resultat som følgende:

Det er vigtigt at nævne, at vi bruger standardnavnet til denne opgave, fordi det er opgaven, der Grynte den søger som standard, som navnet angiver i vores fil gruntfile.js, hvis det ikke havde det navn, ville vi få en fejl ved udførelse grynte som vi ser på følgende billede:

Vores tidligere eksempel, selvom det virker, er ikke det mest anbefalede, vi har simpelthen gjort brug af konsollen Node.js men dette har ikke alle konsolens funktioner og egenskaber Grynte så hvis vi har yderligere oplysninger fra opgavemotoren, vil vi helt sikkert ikke se dem. Derfor skal vi bruge konsollen til vores opgaveautomatiseringsmotor, konceptet i filosofi er praktisk talt det samme, at vi ændrer de objekter og de funktioner, vi skal kalde.
Lad os se i følgende kode, hvordan vi kan omskrive vores kode fra det foregående eksempel for at kunne opfylde det, vi har forklaret:

 module.exports = function (grunt) {grunt.registerTask ('default', function () {grunt.log.writeln ('Denne meddelelse vises af Grunt -konsollen.');});};

Hvordan vi ser, genbruger vi kun objektet grynte initial af filen, så bruger vi dens klasse log og endelig metoden skrive, resultatet er det samme som i det foregående eksempel kun med den forskel, at vi har brugt noget mere optimalt til vores formål. Lad os se i det følgende billede, hvordan alt blev vedligeholdt korrekt:

I begyndelsen talte vi om genanvendelige opgaver, og som giver os mulighed for at spare tid, en af ​​de ting, der kan give os mulighed for at nå en tilstrækkelig grad af genbrug af opgaverne, er muligheden for at tilføje parametre til dem, med dette kan vi ændre nogle værdier I henhold til den situation, hvor vi kan befinde os, såsom at oprette brugere til et system direkte med Grynte, hvormed vi som parameter kan videregive et filnavn med listen over brugere.
I den følgende kode skal vi gøre noget meget interessant, først og fremmest skal vi se, hvordan vi opretter opgaver, der ikke er vores standardproces, med dette vil vi allerede have nøglen til at have flere opgaver i den samme fil. Parameteren, der vil modtage vores opgave, vil simpelthen blive indstillet i den anonyme funktion, på denne måde kan vi fange og behandle den i brødteksten.
Lad os se koden for at generere denne opgave, som en øvelse kan vi placere koden efter vores standardopgave for at teste, hvad vi har forklaret:

 grunt.registerTask ('sig hej', funktion (navn) {grunt.log.writeln ('Hej:' + navn + 'godmorgen i dag');});

For nu at foretage konsolopkaldet af opgaven gør vi simpelthen følgende:

 grynt sige hej: Navn

Hvordan vi kan se, placerer vi navnet på opgaven, og med et kolon adskiller vi for at videregive den nødvendige parameter, i dette tilfælde det navn, vi vil sende til opgaven, lad os se, hvordan det ser ud i vores konsol:

Hvad sker der nu, hvis vores opgave har brug for os til at videregive to eller flere parametre, blot ved at tilføje dem adskilt af kommaer som en funktion JavaScript normalt, og når vi kalder dem i konsollen, kan vi placere dem med den samme adskillelsesmåde, lad os se en kode, hvor vi udfører en opgave, der viser os dette:

 grunt.registerTask ('tilføj', funktion (værdi1, værdi2) {var sum = tal (værdi1) + tal (værdi2); grunt.log.writeln ('Resultatet af tilføjelse' + værdi1 + ' +' + værdi2 + ' er: '+ sum);});

Lad os nu se, hvordan det ser ud, når vi kører gennem konsollen dette eksempel med opkaldet og svaret:

Noget interessant, som vi kunne lægge mærke til, er, at vi bruger JavaScript Flad og enkel at definere behandlingen, brugen af ​​dette sprog er meget vigtig, da vi på denne måde vil kunne udvide vores kapacitet til alt, hvad vi kan opnå på tidspunktet for opbygningen af ​​vores opgaver med Grynte.
Det er muligt at bruge advarsler i vores opgaver, med dette kan vi validere lidt de parametre, der modtages fra brugeren, for eksempel er vores tidligere opgave en sum, men hvis vi sætter noget andet end et tal, vil vores operation mislykkes, så vi kan gør følgende: ved hjælp af metoden advare () Vi validerer, at begge parametre er tal, og hvis de ikke er det, lancerer vi en advarsel:

 grunt.registerTask ('tilføj', funktion (værdi1, værdi2) {hvis (isNaN (tal (værdi1)))) {grunt.warn ('Den første værdi' + værdi1 + 'skal være et tal.');} hvis ( isNaN (tal (værdi2))) {grunt.warn ('Den anden værdi' + værdi2 + 'skal være et tal.');} Var sum = tal (værdi1) + tal (værdi2); grunt.log.writeln ( 'Resultatet af at tilføje' + værdi1 + ' +' + værdi2 + 'er:' + sum);});

I vores omskrevne kode har vi valideret, at hvis resultatet af konverteringen til Nummer () af parametrene er ikke et nummer lancere metoden advare () eller advarsel, dette bryder tråden og viser meddelelsen, så vi kan undgå en defekt opgave. Lad os se, hvordan dette ser ud i vores konsol, når opgaven udføres:

Som vi også bemærker kendskabet til sproget JavaScript Det er meget vigtigt, så hvis vi er under det niveau, vi ønsker at nå, skal vi øve og prøve at lave så mange øvelser som muligt for at forbedre vores færdigheder.
Med dette har vi afsluttet denne vejledning, da vi ser oprettelsen af ​​opgaver med Grynte Det er ikke meget komplekst, snarere dets logik på tidspunktet for at definere dem hjælper os med at lette forståelsen af ​​brugen af ​​værktøjet. Den sande kompleksitet er i definitionen af ​​vores egen logik i øjeblikket for at vide, hvad vores opgave vil gøre, og hvordan vi kan gøre den så genanvendelig som muligt, da hvis den ikke er det, vil vi arbejde forgæves.