Comment transmettre les paramètres de ligne de commande aux tâches Gulp

Points de base

La simplicité de Gulp.js est l'une de ses fonctionnalités les plus attrayantes, permettant aux développeurs d'écrire des fonctions de tâche dans
• et de les exécuter à partir de la ligne de commande. Cependant, il ne prend pas en charge les paramètres de ligne de commande de commande aux tâches à utiliser. gulpfile.js
Bien que les tâches Gulp ne nécessitent généralement pas de paramètres, les paramètres peuvent être utiles dans certains cas. Par exemple, passer des informations d'identification FTP en tant que paramètres peut améliorer la sécurité et empêcher les informations sensibles à code dur.
• La propriété
dans
• node.js renvoie un tableau contenant le processus, le script et tous les paramètres de ligne de commande. Ce tableau peut être analysé dans process.argv pour créer un objet contenant des valeurs de paramètres. gulpfile.js
Bien que les tâches Gulp ne nécessitent pas toujours des paramètres de réception, il est très utile dans certains cas. Le code d'analyse des paramètres peut être utilisé dans n'importe quel processus de ligne de commande Node.js, et le module commandant fournit des fonctionnalités plus puissantes pour les projets non GULP.

j'aime beaucoup gulp.js, et une enquête récente montre que près de 44% des développeurs frontaux utilisent des tâches Gulp.

La simplicité de Gulp est l'une de ses caractéristiques les plus attrayantes. Vous pouvez écrire des fonctions de tâche dans

: gulpfile.js

gulp.task('doSomething', () => {
  // 执行某些操作
});

Utilisez ensuite

pour exécuter la tâche de la ligne de commande. Les tâches peuvent être aussi simples ou complexes que vous le souhaitez et peuvent contenir d'autres sous-tâches. gulp doSomething

Cependant, il est impossible de transmettre des paramètres de ligne de commande qui peuvent être utilisés dans cette tâche, tels que:

gulp doSomething --option1 "my string" --option2 123 --option3

(où

est égal à option3) true

Ces paramètres seront transmis à l'application Gulp elle-même, pas à votre tâche. Gulp ne comprend pas ces valeurs, ils ne sont donc pas disponibles dans

et ne peuvent pas être vérifiés ou utilisés dans vos fonctions de tâche. gulpfile.js

Les tâches Gulp nécessitent-elles des paramètres?

Ce n'est généralement pas nécessaire - sinon, la fonction de passage des paramètres aux tâches serait ajoutée il y a des années! Les tâches gulp sont écrites en javascript, vous pouvez donc définir des valeurs par défaut dans votre code.

Vous pouvez également analyser les variables d'environnement, telles que

. Par exemple, vous pouvez vérifier si la valeur est définie sur la production ou similaire sur le serveur en direct. Ce paramètre peut ensuite être utilisé pour déterminer s'il faut réduire le fichier source JavaScript pendant l'exécution de la tâche, par exemple: NODE_ENV

// 这是开发版本吗？
const devBuild = ((process.env.NODE_ENV || 'development').trim().toLowerCase() === 'development');

// Gulp 插件
const stripdebug = require('gulp-strip-debug');  // 删除调试代码
const uglify = require('gulp-uglify');           // 压缩

// 构建 JavaScript
gulp.task('js', () => {
  let jsbuild = gulp.src('src/js/*')
    .pipe(some-plugin1())
    .pipe(some-plugin2());

  // 生产服务器任务
  if (!devBuild) {
    jsbuild = jsbuild
      .pipe(stripdebug())
      .pipe(uglify());
  }

  return jsbuild.pipe(gulp.dest('build/js/'));
});

Vous pouvez maintenant définir

sur Linux / Mac, ou gulp js sur Windows avant d'exécuter la tâche export NODE_ENV=production. Il supprime ensuite les instructions NODE_ENV=production et console.log avant de compresser le fichier JavaScript. debugger

Enfin, si vous voulez que la tâche effectue des actions légèrement différentes, vous pouvez créer une nouvelle tâche. Les tâches peuvent être liées entre elles pour s'exécuter en séquence au besoin, par exemple:

gulp.task('doSomething', () => {
  // 执行某些操作
});

Run gulp doSomething1 La première tâche sera effectuée. L'exécution gulp doSomething2 effectuera les deux tâches dans l'ordre, car doSomething1 est définie comme une dépendance dans un tableau facultatif après le nom de la tâche.

devrions-nous considérer les paramètres?

Évitez d'utiliser des paramètres lorsqu'il existe de meilleures alternatives. Votre paramètre --option1 peut devenir une option de ligne de commande valide dans la prochaine version Gulp avec des conséquences négatives.

En d'autres termes, il y a toujours des circonstances particulières ...

1.

Vous devez généralement éviter les informations d'identification du code dur telles que les ID et les mots de passe dans

. Considérez la tâche suivante qui utilise le plugin vinyl-FTP pour déployer des fichiers sur le serveur: gulpfile.js

gulp doSomething --option1 "my string" --option2 123 --option3

(Authentic, FTP n'est pas un bon moyen de déployer, mais de nombreux développeurs l'utilisent toujours, et c'est peut-être la seule option sur certains hôtes.)

Il y a plusieurs problèmes avec cette méthode:

L'hôte FTP, l'ID utilisateur, le mot de passe et le chemin sont codés en dur dans le fichier. Si le code est stocké dans un référentiel GitHub public et peut être consulté, cloné et géré par n'importe qui, il peut entraîner des problèmes de sécurité.
Tout développeur peut fonctionner à partir de n'importe quel appareil à tout moment
2. . Ce n'est pas idéal pour les grandes équipes qui souhaitent contrôler le temps de déploiement. gulp deploy
Si les informations d'identification changent, vous devez mettre à jour manuellement
3. pour vous assurer que la tâche de déploiement est toujours valide. gulpfile.js

2.

Gulp peut être utilisé à des fins autres que les tâches de site Web typiques. Par exemple, vous pouvez avoir des tâches courantes pour effacer les dossiers, créer des bases de données, transférer des fichiers, etc. Des contenus codés en dur tels que les noms de base de données ou de dossiers réduiront le praticité de ces tâches.

3.

Imaginez une tâche complexe impliquant des dizaines de plugins. S'il n'est pas pratique de le diviser en plusieurs sous-tâches, il peut devenir difficile de modifier

directement pour ajouter des options de configuration avant d'exécuter la tâche.

Vous pouvez penser à des circonstances plus spéciales (les commentaires sont les bienvenus!) gulpfile.js

comment transmettre des paramètres à votre tâche gulp.js

La propriété

dans

node.js renvoie un tableau contenant le processus, le script et tous les paramètres de ligne de commande. Par exemple,

renvoie le tableau suivant (les valeurs peuvent varier en fonction de votre système d'exploitation et de vos paramètres):

process.argv gulp task1 --a 123 --b "my string" --c Ce tableau peut être analysé dans

. Le code suivant crée un objet nommé

// 这是开发版本吗？
const devBuild = ((process.env.NODE_ENV || 'development').trim().toLowerCase() === 'development');

// Gulp 插件
const stripdebug = require('gulp-strip-debug');  // 删除调试代码
const uglify = require('gulp-uglify');           // 压缩

// 构建 JavaScript
gulp.task('js', () => {
  let jsbuild = gulp.src('src/js/*')
    .pipe(some-plugin1())
    .pipe(some-plugin2());

  // 生产服务器任务
  if (!devBuild) {
    jsbuild = jsbuild
      .pipe(stripdebug())
      .pipe(uglify());
  }

  return jsbuild.pipe(gulp.dest('build/js/'));
});

avec des valeurs de paramètres:

gulpfile.js arg Cette fonction boucle via le tableau

. Lorsqu'il rencontre une valeur commençant par un ou plusieurs tirets, il crée une nouvelle valeur nommée dans l'objet

gulp.task('doSomething1', () => {
  return gulp.src('src/*')
    .pipe(some-plugin1())
    .pipe(gulp.dest('build/'));
});

// 首先运行 doSomething1
gulp.task('doSomething2', ['doSomething1'], () => {
  // 执行其他操作
  return gulp.src('src/*')
    .pipe(some-plugin2())
    .pipe(gulp.dest('build/'));
});

, qui est défini sur

. Lorsqu'il rencontre une valeur sans tableau de bord, il définit la valeur nommée précédente (si disponible) sur la chaîne. process.argv

Lorsque nous exécutons gulp task1 --a 123 --b "my string" --c, l'objet arg est défini sur:

gulp.task('doSomething', () => {
  // 执行某些操作
});

Par conséquent, nous pouvons vérifier et utiliser ces valeurs selon les besoins.

Supposons que arg est défini en haut de gulpfile.js, nous pouvons réécrire notre tâche de déploiement FTP afin que nous puissions passer:

• ID utilisateur comme --user ou --u Paramètre
• mot de passe as --password ou --p Paramètre

gulp doSomething --option1 "my string" --option2 123 --option3

Le déploiement ne se produit que lorsque nous exécutons la tâche avec les informations d'identification FTP appropriées, par exemple:

// 这是开发版本吗？
const devBuild = ((process.env.NODE_ENV || 'development').trim().toLowerCase() === 'development');

// Gulp 插件
const stripdebug = require('gulp-strip-debug');  // 删除调试代码
const uglify = require('gulp-uglify');           // 压缩

// 构建 JavaScript
gulp.task('js', () => {
  let jsbuild = gulp.src('src/js/*')
    .pipe(some-plugin1())
    .pipe(some-plugin2());

  // 生产服务器任务
  if (!devBuild) {
    jsbuild = jsbuild
      .pipe(stripdebug())
      .pipe(uglify());
  }

  return jsbuild.pipe(gulp.dest('build/js/'));
});

Résumé

Comme nous l'avons vu, en utilisant une petite quantité de code personnalisé, les paramètres peuvent être transmis aux tâches Gulp. Bien que votre tâche ne nécessite généralement pas de paramètres de réception, nous voyons qu'il est très utile dans certains cas. C'est certainement une bonne technique que vous devriez maîtriser dans votre boîte à outils.

Le code d'analyse des paramètres peut être utilisé dans n'importe quel processus de ligne de commande Node.js. Cependant, si vous en avez besoin dans un projet non GULP, le module Commander offre des fonctionnalités plus puissantes.

J'espère que vous trouverez cela utile. Bien sûr, ce n'est pas parce que vous pouvez transmettre des paramètres aux tâches Gulp. Si vous trouvez d'autres cas d'utilisation pour cette approche, faites-le moi savoir dans les commentaires.

Cet article a été examiné par Tim Severien. Merci à tous les pair de sitepoint pour avoir obtenu le contenu de sitepoint à son meilleur!

Les questions fréquemment posées sur le passage des paramètres aux tâches Gulp (FAQ)

Comment transmettre des paramètres aux tâches Gulp à partir de la ligne de commande?

Les tableaux peuvent être utilisés pour transmettre des paramètres aux tâches Gulp à partir de la ligne de commande. Ce tableau contient des paramètres de ligne de commande passés lors du démarrage du processus Node.js. Les deux premiers éléments de ce tableau sont le chemin d'accès à l'exécutable Node.js et le chemin du fichier Gulp. Tout autre paramètre sera ajouté à ce tableau à partir de la troisième position. Vous pouvez accéder à ces paramètres dans la tâche Gulp en indexant le tableau

.

process.argv Puis-je utiliser des packages pour gérer les paramètres de ligne de commande dans Gulp? process.argv

Oui, vous pouvez utiliser des packages comme Yargs ou minimistes pour gérer les paramètres de ligne de commande dans Gulp. Ces packages analysent les paramètres de ligne de commande dans des formats plus faciles à utiliser, ce qui les rend plus faciles à utiliser dans les tâches Gulp. Par exemple, si vous utilisez Yargs, vous pouvez accéder aux propriétés de l'objet

comme paramètre de ligne de commande.

Comment utiliser les drapeaux dans les tâches Gulp? yargs.argv

Le drapeau peut être passé de la ligne de commande à la tâche Gulp en précédant le nom du drapeau. Par exemple, vous pouvez transmettre le drapeau "Production" à une tâche Gulp comme suit:

. Dans votre tâche Gulp, vous pouvez vérifier si ce drapeau est défini à l'aide d'un package comme

ou yargs ou minimiste.

Puis-je transmettre plusieurs paramètres à une tâche Gulp?

Oui, vous pouvez transmettre plusieurs paramètres pour gloquer les tâches à partir de la ligne de commande. Ces paramètres sont ajoutés au tableau process.argv dans l'ordre où ils sont passés. Vous pouvez accéder à ces paramètres dans la tâche Gulp en indexant le tableau process.argv.

Comment utiliser les paramètres de ligne de commande dans les tâches Gulp?

peut utiliser les paramètres de ligne de commande dans les tâches Gulp en accédant à process.argv des tableaux ou des packages tels que les yargs ou minimistes. Vous pouvez utiliser ces paramètres pour contrôler le comportement des tâches Gulp. Par exemple, vous pouvez utiliser l'indicateur "Production" pour compresser le code dans une tâche de construction.

Puis-je utiliser des variables d'environnement dans les tâches Gulp?

Oui, vous pouvez utiliser des variables d'environnement dans les tâches Gulp. Ces variables sont accessibles via l'objet process.env. Ceci est utile si vous souhaitez transmettre des informations sensibles telles que les clés d'API pour gloquer les tâches sans les exposer dans les paramètres de ligne de commande.

Comment gérer les erreurs dans les tâches de Gulp?

Le .on('error') peut être utilisé pour gérer les erreurs dans les tâches de Gulp. Cette méthode prend une fonction de rappel qui sera appelée lorsqu'une erreur se produit. Dans cette fonction de rappel, vous pouvez enregistrer les erreurs et mettre fin à la tâche pour empêcher Gulp de se bloquer.

Puis-je exécuter plusieurs tâches Gulp dans l'ordre?

Oui, vous pouvez exécuter plusieurs tâches Gulp dans l'ordre de l'utilisation de la méthode gulp.series(). Cette méthode prend un tableau de noms de tâches et les exécute dans l'ordre défini.

Puis-je exécuter plusieurs tâches Gulp en parallèle?

Oui, vous pouvez exécuter plusieurs tâches Gulp en parallèle en utilisant la méthode gulp.parallel(). Cette méthode prend un tableau de noms de tâches et exécute toutes les tâches en même temps.

Comment définir la tâche de gulp par défaut?

La tâche de Gulp par défaut peut être définie à l'aide de la méthode gulp.task() en utilisant "par défaut" comme nom de tâche. Cette tâche est exécutée lorsque vous exécutez la commande gulp sans aucun nom de tâche. Vous pouvez utiliser cette tâche pour exécuter une série d'autres tâches par défaut.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!