Crie nossa primeira tarefa com o Grunt

A instalação e estabelecimento do Grunhido É algo muito simples de fazer, mas uma vez que temos todas as ferramentas e sabemos alguns dos comandos básicos, muitas vezes nos perguntamos: o que podemos fazer agora? O próximo passo é muito simples, é hora de começar a construir tarefas.
A ideia por trás de uma tarefa é que seja algo que pode resolver problemas frequentes ou atividades que sempre realizamos durante a nossa jornada de trabalho ou desenvolvimento de aplicativos, onde, sendo de natureza repetitiva, podemos definir parâmetros para essas tarefas e, portanto, sempre podem funcionar sem a necessidade de fazer do zero.
RequisitosEste tutorial recomenda que você conheça os fundamentos básicos de JavaScript porque usaremos muitas coisas desta linguagem. Outro requisito essencial é que devemos ter instalado e configurado Grunhido em nosso sistema ou sandbox, isso significa que devemos ter Node.js, seu gerenciador de pacotes npm e claro Grunhido. Finalmente, devemos ter um editor de texto para criar o conteúdo de nossos exercícios e permissões suficientes para criar arquivos e executar o comando grunt no console livremente.
Uma tarefa é uma atividade que tem um começo, um desenvolvimento e um fim, em Grunhido uma tarefa nada mais é do que uma função em JavaScript que está contido no arquivo Gruntfile.js e que ao executar o comando grunhido em nosso console podemos fazer esta função ser executada, fazendo com que seu conteúdo seja lançado.
As tarefas são gerenciadas de forma modular, muito no estilo da constituição básica de Node.jsPortanto, cada vez que definimos um novo conjunto de tarefas, devemos adicionar as instruções que indicam sua modularidade.
Para criar uma tarefa, precisamos de um código base em nosso arquivo gruntfile.js, este código é chamado chapa de ebulição porque é repetitivo, porém só usamos uma vez, vamos ver como fica:

 module.exports = function (grunt) {// aqui está o conteúdo de nossas tarefas};

Depois de colocar esse código em nosso arquivo, já temos a base ou constituição para poder criar nossas tarefas. Feito isso, vamos fazer uma tarefa que nos permite escrever uma mensagem por console, para isso vamos escrever o seguinte código:

 module.exports = function (grunt) {grunt.registerTask ('default', function () {console.log ('Olá, lançamos uma mensagem no Grunt.');});};

O que fizemos é muito fácil de explicar, primeiro pegamos o objeto grunhido que criamos com nosso código chapa de ebulição, então, neste objeto, executamos o método registerTask o que nos ajuda a contar Grunhido que estamos adicionando uma nova tarefa, no próximo ato damos um nome a ela e então com uma função anônima passamos o conteúdo de nossa tarefa para ela, que neste caso é a mensagem no console.
Vamos ver como fica este exemplo ao executar a tarefa, para ele na pasta onde salvamos nosso arquivo gruntfile.js vamos executar o seguinte comando:

 grunhido

Onde, então, o console deve nos dar um resultado como o seguinte:

É importante mencionar que usamos o nome padrão para esta tarefa porque é a tarefa que Grunhido ele irá pesquisar por padrão conforme seu nome indica em nosso arquivo gruntfile.js, se não tivesse esse nome, obteríamos um erro ao executar grunhido como vemos na imagem a seguir:

Nosso exemplo anterior, embora funcione, não é o mais recomendado, simplesmente usamos o console Node.js mas isso não tem todas as funcionalidades e propriedades do console Grunhido portanto, se tivermos qualquer informação adicional do mecanismo de tarefas, certamente não a veremos. É por isso que devemos usar o console do nosso motor de automação de tarefas, o conceito em filosofia é praticamente o mesmo, apenas que mudamos os objetos e as funções que devemos chamar.
Vamos ver no código a seguir como podemos reescrever nosso código do exemplo anterior para poder cumprir o que vimos explicando:

 module.exports = function (grunt) {grunt.registerTask ('default', function () {grunt.log.writeln ('Esta mensagem é exibida pelo console do Grunt.');});};

Como vemos, só reutilizamos o objeto grunhido inicial do arquivo, então usamos sua classe registro e finalmente o método Writeln, o resultado é o mesmo do exemplo anterior, apenas com a diferença de que usamos algo mais ideal para nossos propósitos. Vamos ver na imagem a seguir como tudo foi devidamente mantido:

No início falamos de tarefas reutilizáveis ​​e que nos permitem poupar tempo, uma das coisas que nos pode permitir atingir um grau adequado de reutilização das tarefas é a possibilidade de adicionar parâmetros às mesmas, com isso podemos alterar alguns valores De acordo com a situação em que podemos nos encontrar, como criar usuários para um sistema diretamente com Grunhido, com o qual podemos passar como parâmetro um nome de arquivo com a lista de usuários.
No código a seguir vamos fazer algo muito interessante, primeiro vamos ver como criar tarefas que não são o nosso processo padrão, com isso já teremos a chave para ter várias tarefas no mesmo arquivo. O parâmetro que receberá nossa tarefa será simplesmente definido na função anônima, desta forma podemos capturá-la e processá-la no corpo dela.
Vamos ver o código para gerar esta tarefa, como um exercício, podemos colocar o referido código após a nossa tarefa padrão para testar o que explicamos:

 grunt.registerTask ('diga olá', função (nome) {grunt.log.writeln ('Olá:' + nome + 'bom dia hoje');});

Agora, para fazer a chamada do console da tarefa, simplesmente fazemos o seguinte:

 grunhido diga olá: Nome

Como podemos ver colocamos o nome da tarefa e com dois pontos separamos para passar o parâmetro necessário, neste caso o nome que queremos enviar para a tarefa, vamos ver como fica em nosso console:

Agora o que acontece se nossa tarefa precisar que passemos dois ou mais parâmetros, simplesmente no código da mesma estamos adicionando-os separados por vírgulas como uma função JavaScript normal, e ao chamá-los no console podemos colocá-los da mesma forma de separação, vamos ver um código onde realizamos uma tarefa que nos mostra isso:

 grunt.registerTask ('adicionar', função (valor1, valor2) {var soma = Número (valor1) + Número (valor2); grunt.log.writeln ('O resultado da adição' + valor1 + '+' + valor2 + ' é: '+ soma);});

Agora vamos ver como fica quando executamos no console este exemplo com a chamada e a resposta:

Algo interessante que pudemos notar é que usamos JavaScript Plano e simples de definir o processamento, o uso desta linguagem é muito importante, pois desta forma poderemos estender nossa capacidade de tudo o que podemos realizar na hora de construir nossas tarefas com Grunhido.
É possível usar avisos em nossas tarefas, com isso podemos validar um pouco os parâmetros recebidos do usuário, por exemplo nossa tarefa anterior é uma soma mas se colocarmos algo diferente de um número certamente nossa operação irá falhar, então podemos faça o seguinte: com a ajuda do método avisar () Validaremos se ambos os parâmetros são números e caso não sejam, lançaremos um aviso:

 grunt.registerTask ('adicionar', função (valor1, valor2) {if (isNaN (Número (valor1))) {grunt.warn ('O primeiro valor' + valor1 + 'deve ser um número.');} if ( isNaN (Number (value2))) {grunt.warn ('O segundo valor' + value2 + 'deve ser um número.');} Var sum = Number (value1) + Number (value2); grunt.log.writeln ( 'O resultado da adição de' + valor1 + '+' + valor2 + 'é:' + soma);});

Em nosso código reescrito, validamos que se o resultado da conversão para Número () dos parâmetros não é um número para lançar o método avisar () ou aviso, isso interrompe o thread e exibe a mensagem, para que possamos evitar uma tarefa com falha. Vamos ver como fica em nosso console ao executar a tarefa:

Como também notamos o conhecimento da língua JavaScript É muito importante, pois se estamos abaixo do nível que queremos atingir, devemos praticar e tentar fazer o máximo de exercícios possível para melhorar nossas habilidades.
Com isso terminamos este tutorial, pois vemos a criação de tarefas com Grunhido Não é muito complexo, pelo contrário, a sua lógica na hora de defini-los ajuda a facilitar a compreensão do uso da ferramenta. A verdadeira complexidade está na definição da nossa própria lógica no momento de saber o que vai fazer a nossa tarefa e como podemos torná-la o mais reutilizável possível, pois do contrário estaremos trabalhando em vão.