A brief analysis of the Node.js string search function_node.js

The requirements are as follows:

There are about 40 M in the entire directory, and there are countless files. Because it has been a long time, I can’t remember which file the string is in, so. The powerful and blinding Node.js makes its debut:

Installing Node.js under windows is no different from installing ordinary software. After installation, open the shortcut of Node.js, or directly cmd, you know.

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

}

Two parameters: the first parameter is "folder name" and the second parameter is "the string you are looking for"

Pictured:

Print out the file path, done, and call it a day. The speed is really fierce and blinding. . . If you use java full text search, you will be in trouble...

Nodejs search, read and write files

(1), path processing

1. First of all, we need to pay attention to the normalization of file paths. nodejs provides us with the Path module. The normolize method can help us normalize the path:

var path = require('path');

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

2. Of course there is also the join merge path:

var path = require('path');

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

3. Parse path

var path = require('path');

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

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

4. Find a relative path between two relative paths

var path = require('path');

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

5. Extraction path

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

You can even remove the suffix name, just pass in the second parameter in basename, the parameter is the suffix name, for example:

var path = require('path');

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

Of course there may be various different files in the file path, and it is impossible for us to hardcode the suffix to get the results we want,

So there is a method that can help us get the suffix name:

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

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

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

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

(2), file processing

var fs = require('fs');

1. Determine whether the file exists

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

The above interface operates asynchronously, so there is a callback function, in which our various operations can be processed. If synchronous operations are required, the following method can be used:

fs.existsSync(path);

2. Read file status information

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

The contents of the console output states are roughly as follows:

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

At the same time, stats also has some methods, such as:

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

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

// todo

});

The second parameter is the operation type:

r : read-only

r : Read and write

w : Rewrite file

w : Rewrite the file or create it if it does not exist

a: Read and write files, append

at the end of the file

a: read and write files, create if the file does not exist

The following is a small example of reading a file:

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

The following is a small example of writing a file:

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

For file read and write operations, we should not forget to perform the closing operation after these operations are completed, that is, close(); The following is an encapsulated method, which includes the later closing operation of the file, which is convenient to use:

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