Une brève discussion sur la façon d'utiliser le nœud pour améliorer l'efficacité du travail

Cet article vous montrera comment utiliser Node au travail et comment l'utiliser pour améliorer l'efficacité du travail. J'espère qu'il vous sera utile !

Dans le projet de travail, vous devez vous appuyer sur des fichiers externes. Ce fichier est maintenu par d'autres équipes, construit à l'aide de jenkins, et le produit de build est poussé vers [Amazon S3](aws.amazon.com/pm. /serv-s3/…), nous devons télécharger manuellement le fichier depuis S3, puis le copier dans le projet. L'ensemble du processus peut être automatisé.

De plus, nous avons également rencontré un problème sérieux : le chemin du produit de build dont nous avons besoin dans S3 est similaire à 'a/b//c/', l'extra / est en fait un dossier nommé '/', ce dossier peut être reconnu normalement à l'aide du navigateur S3 de Windows. Sous Mac, c'est probablement parce que '/' est considéré comme un séparateur de fichiers. Par conséquent, plusieurs outils GUI ont été essayés mais le répertoire ne peut pas être reconnu normalement. Les développeurs Mac en ont toujours besoin. pour l'utiliser dans les produits de téléchargement de la machine virtuelle Windows, ce processus est extrêmement inutile et dénué de sens. [Apprentissage recommandé : "Tutoriel Nodejs"]

Étant donné qu'Amazon fournit un accès API, j'ai pensé à implémenter un script pour terminer le travail de téléchargement des mises à jour.

Tri des processus

Script inutilisé :

Script utilisé :

jenkins → Nom du produit → Exécuter le script

De cette façon, il peut être complété directement, vous pouvez enregistrer le processus manuel et aucun « / » n'apparaîtra problème de bug.

Développement

Connectez-vous à AWS

Ici, nous utilisons le aws-sdk fourni par Amazon, utilisons le client S3, transmettons l'accessKeyId et le secretAccessKey pour nous connecter :

import S3 from "aws-sdk/clients/s3";
const s3 = new S3({ credentials: { accessKeyId, secretAccessKey } });

Téléchargez le fichier

L'aws-sdk fournit un bucket et un fichier ajouts Supprimez et modifiez l'interface. Ici, nous pouvons obtenir le nom du fichier du produit construit par Jenkins à l'avance. Ici, nous devons télécharger le fichier en fonction du nom et de l'emplacement du fichier :

const rs = s3
  .getObject({ Bucket: "your bucket name", Key: "file dir + path" })
  .createReadStream();

Bucket est l'emplacement du bucket où le fichier est stocké. La clé est les informations de chemin du fichier dans S3, le chemin complet équivalent au nom du répertoire + nom du fichier.

Ici, nous pouvons obtenir un ReadStream, puis utiliser node.js pour écrire directement dans le local :

const ws = fs.createWriteStream(path.join(__dirname, outputfilename));
rs.pipe(ws);

Extract

Utilisez l'outil node-tar pour le décompresser et l'installer directement :

npm install tar

extract L'alias est x, utilisez-le directement ici méthode tar.x, cette méthode peut traiter directement ReadStream, décompresser les données d'origine et les écrire dans le fichier, afin que nous puissions passer directement le ReadStream dans tar.x sans enregistrer le fichier .tar original :

- const ws = fs.createWriteStream(path.join(__dirname, outputfilename));
- rs.pipe(ws);
+ rs.pipe(tar.x({ C: path.join(__dirname, outputfilename) }));

Ici L'opération pipe renverra l'objet stream, et nous pourrons écouter la méthode finish pour gérer le processus suivant :

const s = rs.pipe(tar.x({ C: path.join(__dirname, outputfilename) }));
s.on('finish', () => {
	// do something ...
})

Flatten Directory

Le fichier d'origine a des sous-dossiers, et nous devons les déplacer vers la couche la plus externe, nous avons donc besoin pour faire une opération de dossier plat.

L'API associée à fs est utilisée ici pour la lecture. L'API fs est divisée en deux types : synchrone et asynchrone. Le nom de la fonction API synchrone se termine par Sync. La fonction asynchrone est par défaut le premier style d'erreur de rappel. est fourni sous l'API fs/promises, vous pouvez l'utiliser selon vos besoins.

Comme notre répertoire n'a qu'un seul calque, nous n'effectuons qu'un seul calque d'aplatissement. S'il y a plusieurs calques, nous pouvons utiliser la récursivité pour y parvenir :

async function flatten(dir) {
  const fileAndDirs = await fsp.readdir(dir);
  const dirs = fileAndDirs.filter((i) =>
    fs.lstatSync(path.join(dir, i)).isDirectory()
  );
  for (const innerDir of dirs) {
    const innerFile = await fsp.readdir(path.join(dir, innerDir));
    await Promise.all([
      innerFile
        .filter((item) => fs.lstatSync(path.join(dir, innerDir, item)).isFile())
        .map((item) =>
          fsp.rename(path.join(dir, innerDir, item), path.join(dir, item))
        ),
    ]);
    remove(path.join(dir, innerDir));
  }
}

Copier vers l'emplacement cible

puis le copier dans notre répertoire de projet. . Pour copier, appelez simplement l'API copyFile, pour les fichiers inutiles, utilisez des expressions régulières pour configurer la liste noire d'exclusion :

async function copy(from, to) {
  const files = await fsp.readdir(from);
  await Promise.all(
    files
      .filter((item) => !exclude.test(item))
      .map((item) => fsp.copyFile(path.join(from, item), path.join(to, item)))
  );
}

Fichier de configuration

En utilisation réelle, le fichier de configuration doit être séparé du code. Les accessKeyId et secretAccessKey doivent être ici. configuré par chaque utilisateur. , il est donc placé dans un fichier de configuration séparé. Ce fichier est créé localement par l'utilisateur, et le contenu de configuration correspondant est lu dans le programme principal :

// config.js
module.exports = {
  s3: {
    accessKeyId: 'accessKeyId',
    secretAccessKey: 'secretAccessKey',
  }
};
// main.js
if (!fs.existsSync('config.js')) {
  console.error('please create a config file');
  return;
}
const config = require(path.resolve(__dirname, 'config.js'));

Passer les paramètres

Le nom du fichier pour chaque téléchargement. doit être transmis lors de l'appel et écrit dans le fichier sera fréquemment modifié, il est donc transmis directement en tant que paramètre ici.

Vous pouvez le lire via process.argv dans node.js. argv est un tableau. Le premier élément de ce tableau est le chemin d'installation du nœud. Le deuxième élément est le chemin du script actuellement exécuté. Le début est un paramètre personnalisé, il doit donc démarrer à partir de process.argv[2]. Si vous avez des exigences complexes en matière de paramètres de ligne de commande, vous pouvez utiliser une bibliothèque d'analyse de paramètres de ligne de commande telle que commander. Puisque cet exemple ne nécessite qu'un seul paramètre, vous pouvez le lire directement ici :

const filename = process.argv[2];
if (!filename) {
	console.error('please run script with params');
	return;
}

至此，一个可用的命令行工具就完成了。

总结

node.js 可以开发后端，但是 node.js 意义最大的地方绝不是使用 JS 开发后端。对前端开发者而言，node.js 真正的价值在于它是一个非常实用的工具，前端工具 Webpack、rollup、dev-server 等都是 node 创造的价值，由于 NPM 丰富的生态，使用 node 可以快速完成脚本的开发，处理开发中遇到的一些工具链与效率的问题很有效，在工作中遇到问题时可以考虑尝试。

更多编程相关知识，请访问：编程入门！！

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!