Une brève analyse de la fonction de recherche de chaîne Node.js

Les exigences sont les suivantes:

Il y a environ 40 m de fichiers dans l'ensemble du répertoire, et il y a d'innombrables fichiers. Au fil du temps, je ne me souviens pas dans quel fichier se trouve la chaîne, donc. Le puissant et aveuglant Node.js a fait ses débuts:

Il n'y a pas de différence entre l'installation de Node.js dans Windows et l'installation de logiciels ordinaires. Après l'installation, ouvrez le raccourci sur Node.js, ou directement CMD, vous savez.

Créer findstring.js

 var path = require ("path"); var fs = require ("fs"); var filepath = process.argv [2]; var lookForstring = process.argv [3]; récursiveReadfile (filepath); function récursivereadfile (filename) {if (! fs.ExistSync (filename))) return; if (isfile (nom de fichier)) {check (nom de fichier);} if (isDirectory (nom de fichier)) {var files = fs.readdirsrync (nom de fichier); files.ForEach (fonction (val, key) {var temp = path.join (filename, val); if (isdirectory (temp)) récursiveReadFile (temp); if (isdirectory) récursiveReadFile (temp); if (isdirectory) récursiveReadFile (temp); if (temp Check (temp);})}} Fonction Check (nom de fichier) {var data = readFile (nom de fichier); var exc = new regexp (lookForstring); if (excc.test (data)) console.log (fichier);} fonction isdirectory (filename) {if (fs.existSSync (filename)) fsatSync (filename) .isDirectory ();} fonction isfile (filename) {if (fs.existSync (fichier nom)) return fsatSync (nom de fichier) .isfile ();} fonction readfile (filename) {if (fsSistSync (filename)) readfile fs.readfilesync (nom de fichier, "utf-8");}

Deux paramètres: le premier paramètre est "nom de dossier" et le deuxième paramètre est "la chaîne que vous recherchez"

Comme indiqué dans l'image:

Imprimez le chemin du fichier, terminez le travail. La vitesse est vraiment féroce, aveuglant les yeux. . . Si vous utilisez la recherche en texte intégral Java, vous serez misérable ...

Nodejs Recherche, lire et écrire des fichiers

(1), traitement du chemin

1. Tout d'abord, nous devons faire attention à la normalisation des chemins de fichier. NodeJS nous fournit le module de chemin. La méthode normolize peut nous aider à normaliser le chemin:

 var path = require ('path'); path.normalize ('/ foo / bar / nor / faz / ..'); -> / foo / bar / nor

2. Bien sûr, il y a aussi le chemin de fusion de jointure:

 var path = require ('path'); path.join ('/ foo', 'bar', 'baz / asdf', 'quux', '..'); -> / foo / bar / baz / asdf

3. Chemin

 var path = require ('path'); path.resolve ('/ foo / bar', './baz'); -> / foo / bar / bazpath.resolve ('/ foo / bar', '/ tmp / file /'); -> / tmp / fichier

4. Trouvez des chemins relatifs entre deux chemins relatifs

 var path = require ('path'); path.relative ('/ data / orandea / test / aaa', '/ data / orandea / impl / bbb'); -> ../../ impl / bbb

5. Extraire le chemin

 var path = require ('path'); path.dirname ('/ foo / bar / baz / asdf / quux.txt'); -> / foo / bar / baz / asdf ========================================== VAR PATH = BIENS ('PATH')

Vous pouvez même supprimer le nom du suffixe, il suffit de passer le deuxième paramètre dans le nom de base, et le paramètre est le nom du suffixe, par exemple:

var path = require ('path');

path.basename ('/ foo / bar / baz / asdf / quux.html', '.html'); -> quux

Bien sûr, il peut y avoir différents fichiers différents dans le chemin du fichier, et il est impossible pour nous de cocoter le suffixe pour obtenir les résultats que nous voulons.

Il y a donc un moyen d'obtenir le nom du suffixe pour nous:

path.ExtName ('/ a / b / index.html'); // => '.html'

path.ExtName ('/ a / bc / index'); // => ''

path.ExtName ('/ a / bc /.'); // => ''

path.ExtName ('/ a / bc / d.'); // => '.'

(2), traitement des fichiers

var fs = require ('fs');

1. Déterminez si le fichier existe

fs.exists (path, fonction (existe) {});

L'interface ci-dessus est asynchrone, il existe donc des fonctions de rappel, qui peuvent gérer diverses opérations dans le rappel. Si vous devez synchroniser les opérations, vous pouvez utiliser la méthode suivante:

fs.existSync (chemin);

2. Lire les informations sur l'état du fichier

 fsat (path, fonction (err, statts) {if (err) {throw err;} console.log (statts);});

Le contenu des états de sortie de la console est à peu près le suivant:

 {dev: 234881026, INO: 95028917, mode: 33188, nlink: 1, uid: 0, gid: 0, rdev: 0, taille: 5086, blkSize: 4096, blocs: 0, atime: Fri, 18 nov 2011 22:44:47 gmt, mtime: thu, 08 SEP 2011 2:50:04 gmt, Mtime: Thu, 08 SEP 2011:50:0:04 Gmt, Mtime: Thu, 08 SEP 2011:

Dans le même temps, les statistiques ont également certaines méthodes, telles que:

 stats.isfile (); stats.isdirectory (); stats.isblockdevice (); stats.isCharacterDevice (); stats.issymboliclink (); stats.isfo (); stats.issocket ();.

Le deuxième paramètre est le type d'opération:

R: Lire uniquement

R +: lire et écrire

W: réécrire le fichier

W +: réécrivez le fichier, créez-le si le fichier n'existe pas

R: Lisez et écrivez des fichiers, ajoutez-les à la fin du fichier

A +: Lisez et écrivez des fichiers, créez-les si le fichier n'existe pas

Voici un petit exemple de lecture d'un fichier:

 var fs = require ('fs'); fs.open ('./ noderead.html', 'r', fonction ouverte (err, fd) {if (err) {throw err} var readbuffer = new tamper (1024), tamperoffset = 0, bufferLength = readbuffer.length, fileposposition = 100; fs.read (fd, readbuffer readBytes) {if (err) {throw err;} console.log ("juste read '+ readBytes +' bytes ');

Voici un petit exemple d'écriture d'un fichier:

 var fs = require ('fs'); fs.open ('./ my_file.txt', 'a', fonction ouverte (err, fd) {if (err) {throw err;} var writebuffer = new tamper ('Hello, world!'), bufferPosition = 0, bufferLength = writeBuffer.Length, fileSposition = null; fs.write (fd, writebuffer, tampon function (err, écrit) {if (err) {throw err;} console.log ('write' + écrit + 'bytes');});});

Pour les opérations de lecture et d'écriture de fichiers, nous ne devons pas oublier d'effectuer une opération étroite une fois toutes ces opérations terminées, c'est-à-dire close (); Ce qui suit est une méthode encapsulée, qui comprend l'opération post-fermeture du fichier, qui est pratique à utiliser:

 var fs = require ('fs'); fonction openandwriteToSystemLog (writeBuffer, callback) {fs.open ('./ my_file', 'a', fonction (err, fd) {if (err) {return callback (err);} function notifyerror (err)} WriteBuffer.Length, FileSposition = null; }); openAndWriteToSystemLog (new Buffer ('Writing This String'), fonction (err) {if (err) {console.log ("Erreur lors de l'ouverture et de l'écriture:", err.Message); return;} console.log ('tout fait sans erreurs');});