Penjelasan terperinci tentang operasi fail Node.js_node.js

Node mempunyai set API strim data yang boleh memproses fail seperti strim rangkaian Ia sangat mudah digunakan, tetapi ia hanya membenarkan pemprosesan fail secara berurutan dan tidak boleh membaca dan menulis fail secara rawak. Oleh itu, beberapa operasi sistem fail peringkat rendah perlu digunakan.

Bab ini merangkumi asas pemprosesan fail, termasuk cara membuka fail, membaca sebahagian daripada fail, menulis data dan menutup fail.

Banyak API fail Node adalah hampir replika API fail yang sepadan dalam UNIX (POSIX Sebagai contoh, cara menggunakan deskriptor fail adalah seperti dalam UNIX Deskriptor fail dalam Node juga merupakan nombor integer entiti. Indeks ke dalam jadual deskriptor fail proses.

Terdapat 3 deskriptor fail khas - 1, 2 dan 3. Mereka mewakili input standard, output standard dan deskriptor fail ralat standard masing-masing. Input standard, seperti namanya, ialah strim baca sahaja yang digunakan oleh proses untuk membaca data daripada konsol atau saluran proses. Output standard dan ralat standard ialah deskriptor fail yang digunakan hanya untuk mengeluarkan data Ia sering digunakan untuk mengeluarkan data ke konsol, proses lain atau fail. Ralat standard bertanggungjawab untuk output maklumat ralat, dan output standard bertanggungjawab untuk output proses biasa.

Setelah proses dimulakan, deskriptor fail ini sebenarnya tidak mempunyai fail fizikal yang sepadan. Anda tidak boleh membaca dan menulis data pada kedudukan rawak, (Nota Penterjemah: Teks asal ialah Anda boleh menulis dan membaca dari kedudukan tertentu dalam fail. Bergantung pada konteks, pengarang mungkin terlepas "tidak"), anda hanya boleh mengendalikan rangkaian seperti Data dibaca dan dikeluarkan secara berurutan seperti aliran data, dan data bertulis tidak boleh diubah suai.

Fail biasa tidak tertakluk kepada sekatan ini Contohnya, dalam Node, anda boleh membuat fail yang hanya boleh menambahkan data pada ekor, dan anda juga boleh membuat fail yang membaca dan menulis lokasi rawak.

Hampir semua operasi berkaitan fail melibatkan pemprosesan laluan fail Bab ini mula-mula akan memperkenalkan fungsi alat ini, dan kemudian menerangkan secara mendalam operasi membaca, menulis dan data

.

Memproses laluan fail

Laluan fail dibahagikan kepada laluan relatif dan laluan mutlak, yang digunakan untuk mewakili fail tertentu. Anda boleh menggabungkan laluan fail, mengekstrak maklumat nama fail dan juga mengesan sama ada fail wujud.

Dalam Node, anda boleh menggunakan rentetan untuk memproses laluan fail, tetapi itu akan merumitkan masalah Contohnya, jika anda ingin menyambungkan bahagian laluan yang berlainan, sesetengah bahagian berakhir dengan "/" dan ada yang tidak, dan pemisah laluan adalah berbeza Sistem pengendalian juga mungkin berbeza, jadi apabila anda menyambungkannya, kod akan menjadi sangat bertele-tele dan menyusahkan.

Nasib baik, Node mempunyai modul yang dipanggil laluan, yang boleh membantu anda menyeragamkan, menyambung, menghuraikan laluan, menukar daripada laluan mutlak kepada laluan relatif, mengekstrak pelbagai bahagian maklumat daripada laluan dan mengesan sama ada fail itu wujud. Secara umum, modul laluan sebenarnya hanyalah beberapa pemprosesan rentetan, dan ia tidak pergi ke sistem fail untuk pengesahan (kecuali untuk fungsi path.exists).

Penstandardan laluan

Selalunya idea yang baik untuk menormalkan laluan sebelum menyimpan atau menggunakannya. Sebagai contoh, laluan fail yang diperoleh oleh input pengguna atau fail konfigurasi, atau laluan yang disambungkan oleh dua atau lebih laluan, secara amnya harus diseragamkan. Anda boleh menggunakan fungsi normalize modul laluan untuk menormalkan laluan, dan ia juga boleh mengendalikan "..", "." Contohnya:

Salin kod Kod adalah seperti berikut:

var path = memerlukan('path');

path.normalize('/foo/bar//baz/asdf/quux/..');

// => '/foo/bar/baz/asdf'

Laluan sambungan

Menggunakan fungsi path.join(), anda boleh menyambungkan mana-mana bilangan rentetan laluan Hanya hantar semua rentetan laluan ke fungsi join() dalam urutan:

Salin kod Kod adalah seperti berikut:

                var path = require('path');

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

                                     // => '/foo/bar/baz/asdf'

Seperti yang anda lihat, path.join() akan menormalkan laluan secara dalaman secara automatik.

Menghuraikan laluan

Gunakan path.resolve() untuk menyelesaikan berbilang laluan ke laluan mutlak. Fungsinya adalah seperti menjalankan operasi "cd" pada laluan ini satu demi satu Tidak seperti parameter arahan cd, laluan ini boleh menjadi fail, dan mereka tidak perlu benar-benar wujud - kaedah path.resolve() tidak mengakses. sistem fail asas Tentukan sama ada laluan itu wujud, ia hanyalah beberapa manipulasi rentetan.

Contohnya:

Salin kod Kod adalah seperti berikut:

                var path = require('path');

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

                                 // => /foo/bar/baz

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

                                // => /tmp/file

Jika hasil penghuraian bukan laluan mutlak, path.resolve() akan menambahkan direktori kerja semasa sebagai laluan ke hadapan hasil penghuraian, contohnya:

Salin kod Kod adalah seperti berikut:

Path.resolve('wwwroot', 'static_files/png/', '../gif/image.gif');
// Jika direktori kerja semasa ialah /home/myself/node,
akan dikembalikan // => /home/myself/node/wwwroot/static_files/gif/image.gif'

Kira laluan relatif dua laluan mutlak

path.relative() boleh memberitahu anda cara untuk melompat dari satu alamat mutlak ke alamat yang lain, seperti:

Salin kod Kod adalah seperti berikut:

              var path = require('path');

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

                                    // => ../../impl/bbb

Ekstrak data daripada laluan

Ambil laluan "/foo/bar/myfile.txt" sebagai contoh Jika anda ingin mendapatkan semua kandungan direktori induk (/foo/bar), atau baca fail lain dalam direktori yang sama, untuk ini. , anda mesti menggunakan path.dirname(filePath) mendapatkan bahagian direktori laluan fail, seperti:

Salin kod Kod adalah seperti berikut:

                var path = require('path');

path.dirname('/foo/bar/baz/asdf/quux.txt');

                                // => /foo/bar/baz/asdf

Atau, jika anda ingin mendapatkan nama fail daripada laluan fail, yang merupakan bahagian terakhir laluan fail, anda boleh menggunakan fungsi path.basename:

Salin kod Kod adalah seperti berikut:

                  var laluan = memerlukan('path');

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

                                                                                                                                                                                                                                                                                                                                            

Laluan fail juga mungkin mengandungi sambungan fail, yang biasanya merupakan bahagian rentetan selepas aksara "." terakhir dalam nama fail.

path.basename juga boleh menerima rentetan sambungan sebagai parameter kedua, supaya nama fail yang dikembalikan akan mengalih keluar sambungan secara automatik dan hanya mengembalikan bahagian nama fail:

Salin kod Kod adalah seperti berikut:

                var path = require('path');

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

                                                                                                                                                                                                                                                                                                                        

Untuk melakukan ini, anda perlu mengetahui sambungan fail terlebih dahulu Anda boleh menggunakan path.extname() untuk mendapatkan sambungan:

Salin kod Kod adalah seperti berikut:

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

                                         // => '.html'

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

                                                                                                                                                                                                                                                // =>

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

                                                                                                                                                                                                                                                // =>

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

                                                                                                              // => =>

Periksa sama ada laluan itu wujud

Setakat ini, operasi pemprosesan laluan yang dinyatakan di atas tidak ada kaitan dengan sistem fail asas, ia hanyalah beberapa operasi rentetan. Walau bagaimanapun, kadangkala anda perlu menentukan sama ada laluan fail wujud Sebagai contoh, kadangkala anda perlu menentukan sama ada fail atau direktori wujud, dan kemudian menciptanya jika ia tidak wujud Anda boleh menggunakan path.exsits():

Salin kod

Kod adalah seperti berikut:                 var path = require('path');

path.exists('/etc/passwd', function(wujud) {

console.log('wujud:', wujud);

// = & gt;

             });

path.exists('/does_not_exist', function(exists) {

console.log('wujud:', wujud);

                                                                                                                                                                                                                                                                                                                     

             });

Nota: Bermula dari versi Node 0.8, wujud telah dialihkan daripada modul laluan ke modul fs dan ditukar kepada fs.exists Kecuali untuk ruang nama, tiada perkara lain yang berubah:

Salin kod Kod adalah seperti berikut:

                  var fs = memerlukan('fs');

                                                             fs.exists('/does_not_exist', fungsi(wujud) {

console.log('wujud:', wujud);

                                                                                                                                                                                                                                                                                                                     

             });

path.exists() ialah operasi I/O, kerana ia tidak segerak, jadi ia memerlukan fungsi panggil balik Apabila operasi I/O kembali, fungsi panggil balik ini dipanggil dan hasilnya dihantar kepadanya. Anda juga boleh menggunakan laluan versi segeraknya.existsSync(), yang mempunyai fungsi yang sama, kecuali ia tidak memanggil fungsi panggil balik, tetapi mengembalikan hasilnya secara langsung:

Salin kod Kod adalah seperti berikut:

              var path = require('path');
path.existsSync('/etc/passwd');

                    // =>

pengenalan modul fs

Modul fs mengandungi semua fungsi yang berkaitan untuk pertanyaan dan pemprosesan fail Dengan fungsi ini, anda boleh menanyakan maklumat fail, membaca, menulis dan menutup fail. Import modul fs seperti ini:

Salin kod Kod adalah seperti berikut:

        var fs = memerlukan(‘fs’)

Maklumat fail pertanyaan

Kadangkala anda mungkin perlu mengetahui saiz fail, tarikh penciptaan atau kebenaran dan maklumat fail lain Anda boleh menggunakan fungsi fs.stath untuk menanyakan maklumat meta fail atau direktori:

Salin kod Kod adalah seperti berikut:

                  var fs = memerlukan('fs');

                                                         fs.stat('/etc/passwd', function(err, stats) {

if (err) { throw err;}

console.log(stats);

            });

Coretan kod ini akan mempunyai output yang serupa dengan yang berikut

Salin kod Kod adalah seperti berikut:

{ dev: 234881026,

ino: 95028917,

mod: 33188,

npautan: 1,

uid: 0,

gid: 0,

rdev: 0,

saiz: 5086,

blksisaiz: 4096,

blok: 0,

masa: Jumaat, 18 Nov 2011 22:44:47 GMT,

mtime: Kha, 08 Sep 2011 23:50:04 GMT,

masa: Kha, 08 Sep 2011 23:50:04 GMT }

1. Panggilan fs.stat() akan menghantar contoh kelas statistik sebagai parameter kepada fungsi panggil baliknya Anda boleh menggunakan contoh statistik seperti berikut:

2.stats.isFile() - Mengembalikan benar jika ia ialah fail standard, bukan direktori, soket, pautan simbolik atau peranti, sebaliknya palsu
3.stats.isDiretory() - Mengembalikan benar jika ia adalah direktori, jika tidak palsu
4.stats.isBlockDevice() - Mengembalikan benar jika ia adalah peranti blok Dalam kebanyakan sistem UNIX, peranti blok biasanya terletak dalam direktori /dev
5.stats.isChracterDevice() - Mengembalikan benar jika ia ialah peranti aksara
6.stats.isSymbolickLink() - Mengembalikan benar jika ia adalah pautan fail
7.stats.isFifo() - Mengembalikan benar jika ia adalah FIFO (jenis khas paip bernama UNIX)
8.stats.isSocket() - jika ia ialah soket UNIX (TODO: googe it)

Buka fail

Sebelum membaca atau memproses fail, anda mesti menggunakan fungsi fs.open untuk membuka fail Kemudian fungsi panggil balik yang anda sediakan akan dipanggil dan mendapatkan deskriptor fail ini untuk membaca kemudian ke fail yang telah dibuka ini:

Salin kod Kod adalah seperti berikut:

                  var fs = memerlukan('fs');

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

             });

Parameter pertama fs.open ialah laluan fail, dan parameter kedua ialah beberapa teg yang digunakan untuk menunjukkan mod untuk membuka fail Teg ini boleh menjadi r, r, w, w, a atau a. Di bawah ialah penerangan tentang teg ini (dari halaman fopen dokumentasi UNIX)

1.r - Buka fail dalam mod baca sahaja, kedudukan awal aliran data adalah pada permulaan fail

2.r - Buka fail dalam mod baca-tulis, kedudukan awal aliran data adalah pada permulaan fail
3.w - Jika fail wujud, panjang fail akan dikosongkan kepada 0, iaitu kandungan fail akan hilang. Jika ia tidak wujud, cuba ciptakannya. Kedudukan awal aliran data adalah pada permulaan fail
4.w - Buka fail dalam mod baca-tulis Jika fail tidak wujud, cuba buatnya Jika fail wujud, tetapkan panjang fail kepada 0, iaitu kandungan fail akan hilang. Kedudukan awal aliran data adalah pada permulaan fail
5.a - Buka fail dalam mod tulis sahaja Jika fail itu tidak wujud, cuba buatnya Kedudukan awal aliran data adalah di hujung fail hujung fail.
6.a - Buka fail untuk membaca dan menulis Jika fail tidak wujud, cuba buatnya Kedudukan awal aliran data adalah di hujung fail daripada fail.

Baca fail

Setelah fail dibuka, anda boleh mula membaca kandungan fail, tetapi sebelum anda memulakan, anda mesti membuat penimbal untuk meletakkan data terlebih dahulu. Objek penimbal ini akan dihantar ke fungsi fs.read sebagai parameter dan diisi dengan data oleh fs.read.

Salin kod Kod adalah seperti berikut:

var fs = memerlukan('fs');

fs.open('./my_file.txt', 'r', fungsi dibuka(err, fd) {

jika (err) { buang err }

var readBuffer = Penampan baharu(1024),

bufferOffset = 0,

bufferLength = readBuffer.length,

Kedudukan fail = 100;

fs.read(fd,

         baca Penampan,

         bufferOffset,

         panjang penimbal,

         Kedudukan fail,

         fungsi baca(err, readBytes) {

                   if (err) { throw err; }

                   console.log('baca sahaja ' readBytes ' bait');

                   jika (readBytes > 0) {

                            console.log(readBuffer.slice(0, readBytes));

                   }

});

});

上面代码尝试打开一个文件，当成功打开后(调用opened函数)，开始趯求从文為求从文為始读取随后1024个字节的数据（第11行）。

fs.read()的最后一个参数是个回调函数（第16行），当下面三种情况：发生时，行行），当下面三种情况：发生时，境行

1.有错误发生

2.成功读取了数据
3.没有数据可读

如果有错误发生，第一个参数（err）会为回调函数提供一个包含错参数（err）会为回调函数提供一个包含错丯个包含错误信家数为null。如果成功读取了数据，第二个参数（readBytes）会指明被读到缓冲区里数据的大小，如果值是0，则表示到达了文件末尾。

注意：一旦把缓冲区对象传递给fs.open()，缓冲对象的控制权就转移给给了read，呰耶和华被调用，缓冲区对象的控制权才会回到你手里。因此在这之前，不要读写或者让其它函数调用使用这个缓冲区对象；冲区对象；吽听完整的数据，更糟的情况是，你可能会并发地往这个缓冲区对象里写数据。

写文件

通过传递给fs.write()传递一个包含数据的缓冲对象，来往一个已打开的文件里家

复制代码 代码如下:

var fs = memerlukan('fs');

fs.open('./my_file.txt', 'a', fungsi dibuka(err, fd) {

    if (err) { throw err; }

    var writeBuffer = Penampan baharu('menulis rentetan ini'),

    bufferPosition = 0,

    bufferLength = writeBuffer.length, filePosition = null;

    fs.write( fd,

        tulis Penampan,

        kedudukan penimbal,

        panjang penimbal,

        Kedudukan fail,

        fungsi ditulis(err, ditulis) {

           jika (err) { throw err; }

           console.log('menulis ' ditulis ' bait');

        });

});

Dalam contoh ini, baris ke-2 kod (Nota Penterjemah: Teks asal ialah 3) cuba membuka fail dalam mod tambahan (a), dan kemudian baris ke-7 kod (Nota Penterjemah: Teks asal ialah 9) menulis data ke fail. Objek penimbal perlu disertakan dengan beberapa maklumat sebagai parameter:

1. Data penimbal
2. Di manakah data yang hendak ditulis bermula dari dalam penimbal
3. Panjang data yang hendak ditulis
4. Lokasi manakah dalam fail tersebut untuk data ditulis?
5. Fungsi panggil balik tulis

yang dipanggil apabila operasi selesai

Dalam contoh ini, parameter filePostion adalah batal, yang bermaksud bahawa fungsi tulis akan menulis data ke lokasi semasa penuding fail Kerana fail dibuka dalam mod tambahan, penuding fail berada di penghujung fail.

Sama seperti operasi baca, jangan sekali-kali menggunakan objek penimbal masuk semasa pelaksanaan fs.write Setelah fs.write mula melaksanakan, ia memperoleh kawalan ke atas objek penimbal itu. Anda hanya boleh menunggu sehingga fungsi panggil balik dipanggil sebelum anda boleh menggunakannya semula.

Tutup fail

Anda mungkin perasan bahawa tiada satu pun daripada contoh dalam bab ini setakat ini mempunyai kod untuk menutup fail. Kerana ia adalah contoh kecil dan mudah yang digunakan sekali sahaja, sistem pengendalian memastikan semua fail ditutup apabila proses Node tamat.

Walau bagaimanapun, dalam aplikasi sebenar, sebaik sahaja anda membuka fail, anda ingin memastikan anda akhirnya menutupnya. Untuk melakukan ini, anda perlu menjejaki semua deskriptor fail terbuka tersebut dan kemudian menutupnya dengan memanggil fs.close(fd[,panggilan balik]) apabila ia tidak lagi digunakan. Sangat mudah untuk terlepas deskriptor fail jika anda tidak berhati-hati. Contoh berikut menyediakan fungsi yang dipanggil openAndWriteToSystemLog, menunjukkan cara menutup fail dengan berhati-hati:

Salin kod Kod adalah seperti berikut:

var fs = memerlukan('fs');
fungsi openAndWriteToSystemLog(writeBuffer, panggil balik){
fs.open('./my_file', 'a', function opened(err, fd) {
If (err) { return callback(err); function notifyError(err) {
                  fs.close(fd, function() {
                 panggil balik(err);
            });
}
        var bufferOffset = 0,
        bufferLength = writeBuffer.length,
         filePosition = null;
             fs.write( fd, writeBuffer, bufferOffset, bufferLength, FilePosition,
             fungsi menulis (err, ditulis) {
If (err) { return notifyError(err);                           fs.close(fd, function() {
                    panggil balik(err);
                });
            }
);
});
}
openAndWriteToSystemLog(
Penampan baharu('menulis rentetan ini'),
Fungsi selesai(err) {
Jika (err) {
console.log("ralat semasa membuka dan menulis:", err.message);
             kembali;
}
console.log('Semua dilakukan tanpa ralat');
}
);

Di sini, fungsi yang dipanggil openAndWriteToSystemLog disediakan, yang menerima objek penimbal yang mengandungi data yang akan ditulis dan fungsi panggil balik yang dipanggil selepas operasi selesai atau ralat berlaku Jika ralat berlaku, fungsi panggil balik pertama Parameter akan mengandungi objek ralat.

Beri perhatian kepada fungsi dalaman notifyError, yang akan menutup fail dan melaporkan ralat yang berlaku.

Nota: Pada ketika ini, anda tahu cara menggunakan operasi atom peringkat rendah untuk membuka, membaca, menulis dan menutup fail. Walau bagaimanapun, Node juga mempunyai satu set pembina yang lebih maju yang membolehkan anda bekerja dengan fail dengan cara yang lebih mudah.

Sebagai contoh, jika anda ingin menggunakan cara selamat untuk membenarkan dua atau lebih operasi tulis menambah data pada fail secara serentak, maka anda boleh menggunakan WriteStream.

Selain itu, jika anda ingin membaca kawasan tertentu fail, pertimbangkan untuk menggunakan ReadStream. Kedua-dua kes penggunaan ini akan diperkenalkan dalam Bab 9 "Arus Pembacaan dan Penulisan Data".

Ringkasan

Apabila anda menggunakan fail, anda perlu memproses dan mengekstrak maklumat laluan fail dalam kebanyakan kes Dengan menggunakan modul laluan, anda boleh menggabungkan laluan, menyeragamkan laluan, mengira perbezaan laluan dan menukar laluan relatif kepada laluan mutlak. Anda boleh mengekstrak sambungan, nama fail, direktori dan komponen laluan lain bagi laluan fail yang ditentukan.

Node menyediakan satu set API peringkat rendah dalam modul fs untuk mengakses sistem fail API peringkat rendah menggunakan deskriptor fail untuk mengendalikan fail. Anda boleh membuka fail dengan fs.open, menulis ke fail dengan fs.write, membaca fail dengan fs.read dan menutup fail dengan fs.close.

Anda harus sentiasa menggunakan logik pengendalian ralat yang betul untuk menutup fail apabila ralat berlaku - memastikan deskriptor fail terbuka ditutup sebelum panggilan kembali.