Eine kurze Analyse der Node.js-String-Suchfunktion_node.js

Die Anforderungen lauten wie folgt:

Das gesamte Verzeichnis enthält ungefähr 40 MB und unzählige Dateien. Da es schon lange her ist, kann ich mich nicht erinnern, in welcher Datei sich die Zeichenfolge befindet. Das leistungsstarke und blendende Node.js feiert sein Debüt:

Die Installation von Node.js unter Windows unterscheidet sich nicht von der Installation normaler Software. Öffnen Sie nach der Installation die Verknüpfung von Node.js oder direkt cmd.

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

}

Zwei Parameter: Der erste Parameter ist „Ordnername“ und der zweite Parameter ist „die gesuchte Zeichenfolge“

Im Bild:

Drucken Sie den Dateipfad aus, fertig, und machen Sie Feierabend. Die Geschwindigkeit ist wirklich heftig und blendend. . . Wenn Sie die Java-Volltextsuche verwenden, werden Sie in Schwierigkeiten geraten...

NodeJS sucht, liest und schreibt Dateien

(1), Pfadverarbeitung

1. Zunächst müssen wir auf die Normalisierung von Dateipfaden achten. Die Methode „Normolize“ kann uns dabei helfen, den Pfad zu normalisieren

var path = require('path');

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

2. Natürlich gibt es auch den Join-Merge-Pfad:

var path = require('path');

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

3. Parse-Pfad

var path = require('path');

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

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

4. Finden Sie einen relativen Pfad zwischen zwei relativen Pfaden

var path = require('path');

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

5. Extraktionspfad

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

Sie können sogar den Suffixnamen entfernen, indem Sie einfach den zweiten Parameter in Basisname übergeben. Der Parameter ist der Suffixname, zum Beispiel:

var path = require('path');

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

Natürlich können sich im Dateipfad verschiedene Dateien befinden, und es ist für uns unmöglich, das Suffix fest zu codieren, um die gewünschten Ergebnisse zu erzielen,

Es gibt also eine Methode, die uns helfen kann, den Suffixnamen zu erhalten:

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

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

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

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

(2), Dateiverarbeitung

var fs = require('fs');

1. Stellen Sie fest, ob die Datei vorhanden ist

fs.exists(path, function(exists) {});

Die obige Schnittstelle arbeitet asynchron, daher gibt es eine Callback-Funktion, in der unsere verschiedenen Operationen verarbeitet werden können. Wenn synchrone Operationen erforderlich sind, kann die folgende Methode verwendet werden:

fs.existsSync(path);

2. Dateistatusinformationen lesen

Der Inhalt der Konsolenausgabezustände ist ungefähr wie folgt:

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

Gleichzeitig verfügt die Statistik auch über einige Methoden, wie zum Beispiel:

 { 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 }

Der zweite Parameter ist der Operationstyp:

stats.isFile();
stats.isDirectory();
stats.isBlockDevice();
stats.isCharacterDevice();
stats.isSymbolicLink();
stats.isFifo();
stats.isSocket();
.读写文件

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

// todo

});

r: schreibgeschützt

r: Lesen und schreiben

w: Datei neu schreiben

w: Schreiben Sie die Datei neu oder erstellen Sie sie, wenn sie nicht existiert

a: Dateien lesen und schreiben,

am Ende der Datei anhängen

a: Dateien lesen und schreiben, erstellen, wenn die Datei nicht existiert

Das Folgende ist ein kleines Beispiel für das Lesen einer Datei:

Das Folgende ist ein kleines Beispiel für das Schreiben einer Datei:

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

Bei Lese- und Schreibvorgängen für Dateien sollten wir nicht vergessen, den Schließvorgang nach Abschluss dieser Vorgänge auszuführen, d. h. close(); Das Folgende ist eine gekapselte Methode, die den späteren Schließvorgang der Datei umfasst ist bequem zu verwenden:

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