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

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

WBOY

Libérer： 2016-05-16 16:37:47

original

1991 Les gens l'ont consulté

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");

}

Copier après la connexion

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 :

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

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

Copier après la connexion

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

Copier après la connexion

3. Analyser le chemin

var path = require('path');

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

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

Copier après la connexion

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

Copier après la connexion

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

Copier après la connexion

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);
});

Copier après la connexion

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 }

Copier après la connexion

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

});

Copier après la connexion

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));
    }
  });
});

Copier après la connexion

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');
  });
});

Copier après la connexion

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');
});

Copier après la connexion