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

Les exigences sont les suivantes :

Il y a environ 40 Mo dans tout le répertoire, et il y a d'innombrables fichiers Parce que cela fait longtemps, je ne me souviens pas dans quel fichier se trouve la chaîne, donc. Le puissant et aveuglant Node.js fait ses débuts :

Installer Node.js sous Windows n'est pas différent de l'installation d'un logiciel ordinaire. Après l'installation, ouvrez le raccourci de Node.js, ou directement cmd, vous savez.

Créez findString.js

var path = require("path");

var fs = require("fs");


var filePath = process.argv[2];

var lookingForString = process.argv[3];

recursiveReadFile(filePath);


function recursiveReadFile(fileName){

if(!fs.existsSync(fileName)) return;

if(isFile(fileName)){

check(fileName);

}

if(isDirectory(fileName)){

var files = fs.readdirSync(fileName);

files.forEach(function(val,key){

var temp = path.join(fileName,val);

if(isDirectory(temp)) recursiveReadFile(temp);

if (isFile(temp)) check(temp);

})

}

}

function check(fileName){

var data = readFile(fileName);

var exc = new RegExp(lookingForString);

if(exc.test(data))

console.log(fileName);


}

function isDirectory(fileName){

if(fs.existsSync(fileName)) return fs.statSync(fileName).isDirectory();

}

function isFile(fileName){

if(fs.existsSync(fileName)) return fs.statSync(fileName).isFile();

}

function readFile(fileName){

if(fs.existsSync(fileName)) return fs.readFileSync(fileName,"utf-8");

}

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

Sur la photo :

Imprimez le chemin du fichier, c'est fait, et c'est fini. La vitesse est vraiment féroce et aveuglante. . . Si vous utilisez la recherche en texte intégral Java, vous aurez des problèmes...

Nodejs recherche, lit et écrit des fichiers

(1), traitement du chemin

1. Tout d'abord, nous devons faire attention à la normalisation des chemins de fichiers. nodejs nous fournit le module Path 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 existe également le chemin de fusion de jointure :

var path = require('path');

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

3. Analyser le chemin

var path = require('path');

path.resolve('/foo/bar', './baz'); ->/foo/bar/baz

path.resolve('/foo/bar', '/tmp/file/'); ->/tmp/file

4. Trouver un chemin relatif entre deux chemins relatifs

var path = require('path');

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

5.Chemin d'extraction

var path = require('path');

path.dirname('/foo/bar/baz/asdf/quux.txt'); ->/foo/bar/baz/asdf

=================

var path = require('path');

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

Vous pouvez même supprimer le nom du suffixe, passez simplement le deuxième paramètre dans basename, 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 dans le chemin du fichier, et il nous est impossible de coder en dur le suffixe pour obtenir les résultats souhaités,

Il existe donc une méthode qui peut nous aider à obtenir le nom du suffixe :

chemin.extname('/a/b/index.html'); // => '.html'

path.extname('/a/b.c/index'); // =>

chemin.extname('/a/b.c/.'); // =>

chemin.extname('/a/b.c/d.'); // => '.'

(2), traitement des fichiers

var fs = require('fs');

1. Déterminez si le fichier existe

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

L'interface ci-dessus fonctionne de manière asynchrone, il existe donc une fonction de rappel, dans laquelle nos différentes opérations peuvent être traitées. Si des opérations synchrones sont requises, la méthode suivante peut être utilisée :

fs.existsSync(chemin);

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

fs.stat(path, function(err, stats) {
  if (err) { throw err;}
  console.log(stats);
});

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,
 size: 5086,
 blksize: 4096,
blocks: 0,
atime: Fri, 18 Nov 2011 22:44:47 GMT,
mtime: Thu, 08 Sep 2011 23:50:04 GMT,
ctime: Thu, 08 Sep 2011 23:50:04 GMT }

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.isFifo();
stats.isSocket();
.读写文件

fs.open('/path/to/file', 'r', function(err, fd) {

// todo

});

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

r : lecture seule

r : Lire et écrire

w : Réécrire le fichier

w : Réécrire le fichier ou le créer s'il n'existe pas

a : Lire et écrire des fichiers, ajouter

à la fin du fichier

a : lire et écrire des fichiers, créer si le fichier n'existe pas

Ce qui suit est un petit exemple de lecture d'un fichier :

 var fs = require('fs');
 fs.open('./nodeRead.html', 'r', function opened(err, fd) {
 if (err) { throw err }
   var readBuffer = new Buffer(1024),
   bufferOffset = 0,
   bufferLength = readBuffer.length,
   filePosition = 100;
   fs.read(fd,
     readBuffer,
    bufferOffset,
    bufferLength,
    filePosition,
    function read(err, readBytes) {
    if (err) { throw err; }
    console.log('just read ' + readBytes + ' bytes');
    if (readBytes > 0) {
      console.log(readBuffer.slice(0, readBytes));
    }
  });
});

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

 var fs = require('fs');
 fs.open('./my_file.txt', 'a', function opened(err, fd) {
   if (err) { throw err; }
   var writeBuffer = new Buffer('hello, world!'),
   bufferPosition = 0,
   bufferLength = writeBuffer.length, filePosition = null;
   fs.write( fd,
     writeBuffer,
     bufferPosition,
    bufferLength,
    filePosition,
    function(err, written) {
      if (err) { throw err; }
      console.log('wrote ' + written + ' bytes');
  });
});

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

 var fs = require('fs');
 function openAndWriteToSystemLog(writeBuffer, callback) {
   fs.open('./my_file', 'a', function(err, fd) {
     if (err) { return callback(err); }
     function notifyError(err) {
       fs.close(fd, function() {
         callback(err);
       });
     }
    var bufferOffset = 0,
    bufferLength = writeBuffer.length,
    filePosition = null;
    fs.write( fd, writeBuffer, bufferOffset, bufferLength, filePosition,function(err, written) {
      if (err) { return notifyError(err); }
      fs.close(fd, function() {
        callback(err);
      });
    });
  });
}
openAndWriteToSystemLog(new Buffer('writing this string'),function(err) {
  if (err) {
    console.log("error while opening and writing:", err.message);
    return;
  }
  console.log('All done with no errors');
});