Analisis ringkas fungsi carian rentetan Node.js_node.js

Keperluan adalah seperti berikut:

Terdapat kira-kira 40 M dalam keseluruhan direktori, dan terdapat banyak fail Kerana ia telah lama berlalu, saya tidak dapat mengingati fail rentetan itu, jadi. Node.js yang berkuasa dan membutakan membuat penampilan pertamanya:

Memasang Node.js di bawah Windows tidak berbeza dengan memasang perisian biasa Selepas pemasangan, buka pintasan Node.js, atau terus cmd, anda tahu.

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

}

Dua parameter: parameter pertama ialah "nama folder" dan parameter kedua ialah "rentetan yang anda cari"

Gambar:

Cetak laluan fail, selesai, dan panggilnya sehari. Kelajuannya sungguh garang dan menyilaukan. . . Jika anda menggunakan carian teks penuh java, anda akan menghadapi masalah...

Nodejs mencari, membaca dan menulis fail

(1), pemprosesan laluan

1. Pertama sekali, kita perlu memberi perhatian kepada normalisasi laluan fail memberikan kita modul Path Kaedah normolize boleh membantu kita menormalkan laluan:

var path = require('path');

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

2. Sudah tentu terdapat juga laluan gabungan:

var path = require('path');

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

3. Menghuraikan laluan

var path = require('path');

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

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

4 Cari laluan relatif antara dua laluan relatif

var path = require('path');

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

5. Laluan pengekstrakan

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

Anda juga boleh mengalih keluar nama akhiran, hanya masukkan parameter kedua dalam nama asas, parameter ialah nama akhiran, contohnya:

laluan var = memerlukan('laluan');

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

Sudah tentu mungkin terdapat pelbagai fail berbeza dalam laluan fail, dan adalah mustahil untuk kita mengeraskan akhiran untuk mendapatkan hasil yang kita inginkan,

Jadi ada kaedah yang boleh membantu kita mendapatkan nama akhiran:

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), pemprosesan fail

var fs = memerlukan('fs');

1. Tentukan sama ada fail itu wujud

fs.exists(laluan, fungsi(wujud) {});

Antara muka di atas beroperasi secara tidak segerak, jadi terdapat fungsi panggil balik, di mana pelbagai operasi kami boleh diproses Jika operasi segerak diperlukan, kaedah berikut boleh digunakan:

fs.existsSync(path);

2. Baca maklumat status fail

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

Kandungan keadaan keluaran konsol adalah kira-kira seperti berikut:

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

Pada masa yang sama, statistik juga mempunyai beberapa kaedah, seperti:

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

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

// todo

});

Parameter kedua ialah jenis operasi:

r : baca sahaja

r : Baca dan tulis

w : Tulis semula fail

w : Tulis semula fail atau buatnya jika ia tidak wujud

a: Baca dan tulis fail, tambahkan

di hujung fail

a: baca dan tulis fail, buat jika fail itu tidak wujud

Berikut ialah contoh kecil membaca fail:

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

Berikut ialah contoh kecil menulis fail:

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

Untuk operasi baca dan tulis fail, kita jangan lupa untuk melakukan operasi penutupan selepas operasi ini selesai, iaitu close(); mudah digunakan:

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