Normalmente, podemos executar a tarefa gulp no console através de algo parecido gulp mytask. Existe alguma maneira que eu possa passar parâmetro para gulp task? Se possível, por exemplo, mostre como isso pode ser feito.

É um recurso que os programas não podem ficar sem. Você pode tentar yargs .

npm install --save-dev yargs

Você pode usá-lo assim:

gulp mytask --production --test 1234

No código, por exemplo:

var argv = require('yargs').argv;
var isProduction = (argv.production === undefined) ? false : true;

Para seu entendimento:

> gulp watch
console.log(argv.production === undefined);  <-- true
console.log(argv.test === undefined);        <-- true

> gulp watch --production
console.log(argv.production === undefined);  <-- false
console.log(argv.production);                <-- true
console.log(argv.test === undefined);        <-- true
console.log(argv.test);                      <-- undefined

> gulp watch --production --test 1234
console.log(argv.production === undefined);  <-- false
console.log(argv.production);                <-- true
console.log(argv.test === undefined);        <-- false
console.log(argv.test);                      <-- 1234

Espero que você possa levá-lo daqui.

Há outro plugin que você pode usar, minimista. Há outro post onde há bons exemplos para yargs e minimist: ( É possível passar uma sinalização para o Gulp para que ele execute tarefas de maneiras diferentes? )

Se você quiser evitar adicionar dependências extras, achei os nós process.argvúteis:

gulp.task('mytask', function() {
    console.log(process.argv);
});

Então, o seguinte:

gulp mytask --option 123

deve exibir:

[ 'node', 'path/to/gulp.js', 'mytask', '--option', '123']

Se você tiver certeza de que o parâmetro desejado está na posição correta, os sinalizadores não serão necessários. ** Basta usar (neste caso):

var option = process.argv[4]; //set to '123'

MAS: como a opção pode não estar definida ou estar em uma posição diferente, considero que uma idéia melhor seria algo como:

var option, i = process.argv.indexOf("--option");
if(i>-1) {
    option = process.argv[i+1];
}

Dessa forma, você pode lidar com variações em várias opções, como:

//task should still find 'option' variable in all cases
gulp mytask --newoption somestuff --option 123
gulp mytask --option 123 --newoption somestuff
gulp mytask --flag --option 123

** Edit: true para scripts de nó, mas o gulp interpreta qualquer coisa sem um "-" inicial como outro nome de tarefa. Portanto, o uso gulp mytask 123falhará porque o gulp não consegue encontrar uma tarefa chamada '123'.

Passar um parâmetro para o gulp pode significar algumas coisas:

• Da linha de comando para o gulpfile (já exemplificado aqui).
• Do corpo principal do script gulpfile.js para tarefas de gulp.
• De uma tarefa de gole para outra tarefa de gole.

Aqui está uma abordagem da passagem de parâmetros do gulpfile principal para uma tarefa gulp. Movendo a tarefa que precisa do parâmetro para seu próprio módulo e agrupando-a em uma função (para que um parâmetro possa ser passado) .:

// ./gulp-tasks/my-neat-task.js file
module.exports = function(opts){

  opts.gulp.task('my-neat-task', function(){
      console.log( 'the value is ' + opts.value );
  });

};

//main gulpfile.js file

//...do some work to figure out a value called val...
var val = 'some value';

//pass that value as a parameter to the 'my-neat-task' gulp task
require('./gulp-tasks/my-neat-task.js')({ gulp: gulp, value: val});

Isso pode ser útil se você tiver muitas tarefas de gulp e quiser passar algumas configurações ambientais úteis. Não tenho certeza se ele pode funcionar entre uma tarefa e outra.

Há uma receita oficial de gole para isso usando minimist .

https://github.com/gulpjs/gulp/blob/master/docs/recipes/pass-arguments-from-cli.md

O básico está usando o minimist para separar os argumentos cli e combiná-los com opções conhecidas:

var options = minimist(process.argv.slice(2), knownOptions);

O que analisaria algo como

$ gulp scripts --env development

Informações mais completas na receita.

Se você deseja usar parâmetros de ambiente e outros utilitários, como também o log, pode usar o gulp-util

/* 
  $npm install gulp-util --save-dev
  $gulp --varName 123
*/
var util = require('gulp-util');
util.log(util.env.varName);

Atualizar

Agora o gulp-util está obsoleto. Você pode usar o minimist .

var argv = require('minimist')(process.argv.slice(2));
console.dir(argv);

A resposta de @ Ethan funcionaria completamente. Da minha experiência, a maneira mais nó é usar variáveis ​​de ambiente. É uma maneira padrão de configurar programas implantados em plataformas de hospedagem (por exemplo, Heroku ou Dokku).

Para passar o parâmetro da linha de comando, faça o seguinte:

Desenvolvimento: gulp dev

Produção: NODE_ENV=production gulp dev

A sintaxe é diferente, mas muito Unix, e é compatível com Heroku, Dokku, etc.

Você pode acessar a variável em seu código em process.env.NODE_ENV

MYAPP=something_else gulp dev

definiria

process.env.MYAPP === 'something_else'

Essa resposta pode lhe dar outras idéias.

Aqui está minha amostra de como eu o uso. Para a tarefa css / less. Pode ser aplicado para todos.

var cssTask = function (options) {
  var minifyCSS = require('gulp-minify-css'),
    less = require('gulp-less'),
    src = cssDependencies;

  src.push(codePath + '**/*.less');

  var run = function () {
    var start = Date.now();

    console.log('Start building CSS/LESS bundle');

    gulp.src(src)
      .pipe(gulpif(options.devBuild, plumber({
        errorHandler: onError
      })))
      .pipe(concat('main.css'))
      .pipe(less())
      .pipe(gulpif(options.minify, minifyCSS()))
      .pipe(gulp.dest(buildPath + 'css'))
      .pipe(gulpif(options.devBuild, browserSync.reload({stream:true})))
      .pipe(notify(function () {
        console.log('END CSS/LESS built in ' + (Date.now() - start) + 'ms');
      }));
  };

  run();

  if (options.watch) {
    gulp.watch(src, run);
  }
};

gulp.task('dev', function () {
  var options = {
    devBuild: true,
    minify: false,
    watch: false
  };

  cssTask (options);
});

Aqui está outra maneira sem módulos extras:

Eu precisava adivinhar o ambiente a partir do nome da tarefa, tenho uma tarefa 'dev' e uma tarefa 'prod'.

Quando eu corro gulp prod, deve ser definido como ambiente de prod. Quando eu corro gulp devou qualquer outra coisa, deve ser definido como ambiente de desenvolvimento.

Para isso, basta verificar o nome da tarefa em execução:

devEnv = process.argv[process.argv.length-1] !== 'prod';

Se você usa gulp com yargs, observe o seguinte:

Se você possui uma tarefa 'customer' e não deseja usar o yargs build na verificação de parâmetros para os comandos necessários:

.command("customer <place> [language]","Create a customer directory") chame-o com:

gulp customer --customer Bob --place Chicago --language english

yargs sempre emitirá um erro, indicando que não há comandos suficientes atribuídos à chamada, mesmo que você tenha !! -

Experimente e adicione apenas um dígito ao comando (para torná-lo diferente do nome da tarefa gulp) ... e ele funcionará:

.command("customer1 <place> [language]","Create a customer directory")

Isso é porque o gulp parece acionar a tarefa, antes que o yargs possa verificar esse parâmetro necessário. Me custou horas extras para descobrir isso.

Espero que isso ajude você..

Sei que estou atrasado para responder a essa pergunta, mas gostaria de acrescentar algo à resposta de @ Ethan, a resposta mais votada e aceita.

Podemos usar yargspara obter o parâmetro da linha de comando e, com isso, também podemos adicionar nosso próprio alias para alguns parâmetros como follow.

var args = require('yargs')
    .alias('r', 'release')
    .alias('d', 'develop')
    .default('release', false)
    .argv;

Consulte este link para obter mais detalhes. https://github.com/yargs/yargs/blob/HEAD/docs/api.md

A seguir está o uso do alias, conforme fornecido na documentação de yargs. Também podemos encontrar mais yargsfunções lá e tornar a experiência de passagem da linha de comando ainda melhor.

.alias (chave, alias)

Defina os nomes das chaves como equivalentes, de forma que as atualizações em uma chave sejam propagadas para aliases e vice-versa.

Opcionalmente .alias () pode levar um objeto que mapeia chaves para aliases. Cada chave deste objeto deve ser a versão canônica da opção e cada valor deve ser uma sequência ou uma matriz de sequências.

Basta carregá-lo em um novo objeto no processo .. process.gulp = {}e fazer com que a tarefa procure lá.