A brief analysis of Node.js string search function

The requirements are as follows:

There are about 40 M of files in the entire directory, and there are countless files. As time goes by, I can't remember which file the string is in, so. The powerful, blinding Node.js debuted:

There is no difference between installing Node.js in Windows and installing ordinary software. After installing, open the shortcut to 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"

As shown in the picture:

Print out the file path, finish the work. The speed is really fierce, blinding the eyes. . . If you use Java full text search, you will be miserable...

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. Path

 var path = require('path');path.resolve('/foo/bar', './baz'); ->/foo/bar/bazpath.resolve('/foo/bar', '/tmp/file/'); ->/tmp/file

4. Find relative paths between two relative paths

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

5. Extract the 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 the second parameter in the basename, and 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 way to get the suffix name for us:

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

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

path.extname('/a/bc/.'); // => ''

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

(2), file processing

var fs = require('fs');

1. Determine whether the file exists

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

The above interface is asynchronous, so there are callback functions, which can handle various operations in the callback. If you need to synchronize operations, you can use the following method:

fs.existsSync(path);

2. Read file status information

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

The content of the console output states is 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 }

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

 stats.isFile();stats.isDirectory();stats.isBlockDevice();stats.isCharacterDevice();stats.isSymbolicLink();stats.isFifo();stats.isSocket();.Read and write files 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 the file

w+: Rewrite the file, create it if the file does not exist

a: Read and write files, add them at the end of the file

a+: Read and write files, create them if the file does not exist

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

Here 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 a close operation after all these operations are completed, that is, close(); The following is an encapsulated method, which includes the post-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');});