A brief analysis of the Node.js string search function

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

WBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWB

Release： 2016-05-16 16:37:47

Original

1999 people have browsed it

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

}

Copy after login

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

Pictured:

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

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

Copy after login

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

Copy after login

3. Parse path

var path = require('path');

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

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

Copy after login

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

Copy after login

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

Copy after login

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

Copy after login

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 }

Copy after login

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

});

Copy after login

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

Copy after login

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

Copy after login

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

Copy after login