Panduan Node.js, Bagian 9: Bekerja dengan Sistem File

Hari ini, di bagian kesembilan dari terjemahan tutorial Node.js, kita akan berbicara tentang bekerja dengan file. Secara khusus, kita akan berbicara tentang modul fs dan path - tentang deskriptor file, tentang path file, tentang mendapatkan informasi tentang file, tentang membaca dan menulisnya, tentang bekerja dengan direktori.

Bekerja dengan deskriptor file di Node.js

Sebelum Anda dapat berinteraksi dengan file yang terletak di sistem file server Anda, Anda perlu mendapatkan deskriptor file.

Deskriptor dapat diperoleh dengan menggunakan metode asynchronous open() dari modul fs untuk membuka file:

 const fs = require('fs') fs.open('/Users/flavio/test.txt', 'r', (err, fd) => { //fd -    }) 

Perhatikan parameter kedua, r , yang digunakan saat memanggil metode fs.open() . Ini adalah flag yang memberi tahu sistem bahwa file sedang dibuka untuk dibaca. Berikut adalah beberapa flag yang sering digunakan ketika bekerja dengan ini dan beberapa metode lain:

• r+ - buka file untuk membaca dan menulis.
• w+ - buka file untuk membaca dan menulis dengan mengatur stream pointer ke awal file. Jika file tidak ada, itu dibuat.
• a - buka file untuk ditulis dengan mengatur stream pointer ke akhir file. Jika file tidak ada, itu dibuat.
• a+ - - buka file untuk membaca dan menulis dengan mengatur stream pointer ke akhir file. Jika file tidak ada, itu dibuat.

File dapat dibuka menggunakan metode sinkron fs.openSync() , yang alih-alih memberikan deskriptor file di callback, mengembalikannya:

 const fs = require('fs') try { const fd = fs.openSync('/Users/flavio/test.txt', 'r') } catch (err) { console.error(err) } 

Setelah menerima deskriptor menggunakan salah satu metode di atas, Anda dapat melakukan operasi yang diperlukan dengannya.

File data

Setiap file memiliki set data yang terkait dengannya, Anda dapat memeriksa data ini menggunakan Node.js. Secara khusus, ini dapat dilakukan dengan menggunakan metode stat() dari modul fs .

Metode ini disebut, meneruskan path ke file ke sana, dan setelah Node.js menerima informasi yang diperlukan tentang file, itu akan memanggil callback yang dilewatkan ke metode stat() . Begini tampilannya:

 const fs = require('fs') fs.stat('/Users/flavio/test.txt', (err, stats) => { if (err) {   console.error(err)   return } //      `stats` }) 

Node.js memiliki kemampuan untuk mengambil informasi file secara sinkron. Dengan pendekatan ini, utas utama diblokir sampai properti file diperoleh:

 const fs = require('fs') try { const stats = fs.statSync ('/Users/flavio/test.txt') } catch (err) { console.error(err) } 

Informasi tentang file akan masuk ke dalam stats konstan. Apa informasi ini? Bahkan, objek yang sesuai memberi kita sejumlah besar properti dan metode yang berguna:

• Metode .isFile() dan .isDirectory() masing-masing memungkinkan untuk mengetahui apakah file yang diselidiki adalah file atau direktori biasa.
• Metode .isSymbolicLink() memberi tahu Anda jika file adalah tautan simbolik.
• Ukuran file dapat ditemukan menggunakan properti .size .

Ada metode lain di sini, tetapi ini adalah yang paling banyak digunakan. Berikut cara menggunakannya:

 const fs = require('fs') fs.stat('/Users/flavio/test.txt', (err, stats) => { if (err) {   console.error(err)   return } stats.isFile() //true stats.isDirectory() //false stats.isSymbolicLink() //false stats.size //1024000 //= 1MB }) 

File paths di Node.js dan modul path

Jalur file adalah alamat tempat di sistem file tempat ia berada.

Di Linux dan macOS, path mungkin terlihat seperti ini:

 /users/flavio/file.txt 

Di Windows, jalur tampak sedikit berbeda:

 C:\users\flavio\file.txt 

Perbedaan dalam format jalur rekaman ketika menggunakan sistem operasi yang berbeda harus dicatat, mengingat sistem operasi yang digunakan untuk menggunakan server Node.js.

Node.js memiliki modul path standar yang dirancang untuk bekerja dengan jalur file. Sebelum menggunakan modul ini dalam suatu program, itu harus terhubung:

 const path = require('path') 

▍ Mendapatkan informasi jalur file

Jika Anda memiliki path ke file, kemudian menggunakan kemampuan modul path , Anda bisa, dalam bentuk yang nyaman untuk persepsi dan pemrosesan lebih lanjut, cari tahu detail tentang path ini. Ini terlihat seperti ini:

 const notes = '/users/flavio/notes.txt' path.dirname(notes) // /users/flavio path.basename(notes) // notes.txt path.extname(notes) // .txt 

Di sini, di baris notes , jalur file disimpan. Metode modul path berikut digunakan untuk menguraikan path :

• dirname() - mengembalikan direktori induk file.
• basename() - mengembalikan nama file.
• extname() - mengembalikan ekstensi file.

Anda dapat mengetahui nama file tanpa ekstensi dengan memanggil metode .basename() dan meneruskannya argumen kedua yang mewakili ekstensi:

 path.basename(notes, path.extname(notes)) //notes 

▍Bekerja dengan jalur file

Beberapa bagian jalur dapat digabungkan menggunakan metode path.join() :

 const name = 'flavio' path.join('/', 'users', name, 'notes.txt') //'/users/flavio/notes.txt' 

Anda dapat menemukan path absolut ke file berdasarkan path relatif ke sana menggunakan metode path.resolve() :

 path.resolve('flavio.txt') //'/Users/flavio/flavio.txt'       

Dalam hal ini, Node.js cukup menambahkan /flavio.txt ke jalur yang mengarah ke direktori kerja saat ini. Jika, saat memanggil metode ini, Anda meneruskan parameter lain yang mewakili jalur ke folder, metode menggunakannya sebagai basis untuk menentukan jalur absolut:

 path.resolve('tmp', 'flavio.txt') // '/Users/flavio/tmp/flavio.txt'       

Jika jalur dilewati sebagai parameter pertama dimulai dengan garis miring, ini berarti bahwa itu adalah jalur absolut.

 path.resolve('/etc', 'flavio.txt') // '/etc/flavio.txt' 

Berikut adalah metode lain yang bermanfaat - path.normalize() . Ini memungkinkan Anda untuk menemukan jalur nyata ke file menggunakan jalur yang berisi kualifikasi jalur relatif seperti titik ( . ), Dua poin ( .. ), atau dua garis miring:

 path.normalize('/users/flavio/..//test.txt') // /users/test.txt 

Metode resolve() dan normalize() tidak memeriksa keberadaan direktori. Mereka hanya menemukan jalur berdasarkan data yang diberikan kepada mereka.

Membaca File di Node.js

Cara termudah untuk membaca file di Node.js adalah dengan menggunakan metode fs.readFile() , meneruskannya path ke file dan callback, yang akan dipanggil dengan transfer data file (atau objek kesalahan) ke sana:

 fs.readFile('/Users/flavio/test.txt', (err, data) => { if (err) {   console.error(err)   return } console.log(data) }) 

Jika perlu, Anda dapat menggunakan versi sinkron dari metode ini - fs.readFileSync() :

 const fs = require('fs') try { const data = fs.readFileSync('/Users/flavio/test.txt') console.log(data) } catch (err) { console.error(err) } 

Secara default, encoding utf8 digunakan saat membaca file, tetapi encoding juga dapat diatur secara independen dengan mengirimkan parameter yang sesuai ke metode.

Metode fs.readFile() dan fs.readFileSync() membaca seluruh isi file ke dalam memori. Ini berarti bekerja dengan file besar menggunakan metode ini akan secara serius mempengaruhi konsumsi memori aplikasi Anda dan akan mempengaruhi kinerjanya. Jika Anda perlu bekerja dengan file seperti itu, yang terbaik adalah menggunakan stream.

Menulis File ke Node.js

Di Node.js, lebih mudah menulis file menggunakan metode fs.writeFile() :

 const fs = require('fs') const content = 'Some content!' fs.writeFile('/Users/flavio/test.txt', content, (err) => { if (err) {   console.error(err)   return } //   }) 

Ada juga versi sinkron dari metode yang sama - fs.writeFileSync() :

 const fs = require('fs') const content = 'Some content!' try { const data = fs.writeFileSync('/Users/flavio/test.txt', content) //   } catch (err) { console.error(err) } 

Metode-metode ini, secara default, mengganti konten file yang ada. Anda dapat mengubah perilaku standar mereka menggunakan bendera yang sesuai:

 fs.writeFile('/Users/flavio/test.txt', content, { flag: 'a+' }, (err) => {}) 

Bendera dapat digunakan di sini, yang telah kami cantumkan di bagian deskriptor. Detail tentang bendera dapat ditemukan di sini .

Lampirkan data ke file

Metode fs.appendFile() (dan versi fs.appendFileSync() , fs.appendFileSync() ) mudah digunakan untuk melampirkan data ke akhir file:

 const content = 'Some content!' fs.appendFile('file.log', content, (err) => { if (err) {   console.error(err)   return } //! }) 

Tentang menggunakan utas

Di atas, kami menjelaskan metode yang, saat menulis ke file, menulis seluruh jumlah data yang ditransfer ke dalamnya, setelah itu, jika versi sinkronnya digunakan, mereka mengembalikan kontrol ke program, dan jika versi asinkron digunakan, mereka memanggil panggilan balik. Jika keadaan ini tidak sesuai dengan Anda, akan lebih baik menggunakan stream.

Bekerja dengan direktori di Node.js

Modul fs menyediakan pengembang dengan banyak metode mudah yang dapat digunakan untuk bekerja dengan direktori.

▍Periksa keberadaan folder

Untuk memeriksa apakah direktori tersebut ada dan apakah Node.js dapat mengaksesnya, dengan izin yang diberikan, Anda dapat menggunakan metode fs.access() .

▍Buat folder baru

Untuk membuat folder baru, Anda dapat menggunakan metode fs.mkdir() dan fs.mkdirSync() :

 const fs = require('fs') const folderName = '/Users/flavio/test' try { if (!fs.existsSync(dir)){   fs.mkdirSync(dir) } } catch (err) { console.error(err) } 

▍Membaca isi folder

Untuk membaca konten folder, Anda dapat menggunakan metode fs.readdir() dan fs.readdirSync() . Contoh ini membaca konten folder - yaitu, informasi tentang file dan subdirektori apa yang dikandungnya dan mengembalikan jalur relatifnya:

 const fs = require('fs') const path = require('path') const folderPath = '/Users/flavio' fs.readdirSync(folderPath) 

Ini adalah bagaimana Anda bisa mendapatkan path lengkap ke file:

 fs.readdirSync(folderPath).map(fileName => { return path.join(folderPath, fileName) } 

Hasil dapat disaring untuk mendapatkan hanya file dan dikecualikan dari output direktori:

 const isFile = fileName => { return fs.lstatSync(fileName).isFile() } fs.readdirSync(folderPath).map(fileName => { return path.join(folderPath, fileName)).filter(isFile) } 

▍ Ganti nama folder

Anda dapat menggunakan metode fs.rename() dan fs.renameSync() untuk mengganti nama folder. Parameter pertama adalah jalur folder saat ini, yang kedua adalah yang baru:

 const fs = require('fs') fs.rename('/Users/flavio', '/Users/roger', (err) => { if (err) {   console.error(err)   return } // }) 

Anda dapat mengganti nama folder menggunakan metode sinkron fs.renameSync() :

 const fs = require('fs') try { fs.renameSync('/Users/flavio', '/Users/roger') } catch (err) { console.error(err) } 

▍ Hapus folder

Untuk menghapus folder, Anda dapat menggunakan metode fs.rmdir() atau fs.rmdirSync() . Perlu dicatat bahwa menghapus folder di mana ada sesuatu adalah tugas yang sedikit lebih rumit daripada menghapus folder kosong. Jika Anda perlu menghapus folder tersebut, gunakan paket fs-extra , yang sangat populer dan didukung dengan baik. Ini adalah pengganti untuk modul fs , memperluas kemampuannya.

Metode remove() dari paket fs-extra dapat menghapus folder yang sudah memiliki sesuatu.

Anda dapat menginstal modul ini sebagai berikut:

 npm install fs-extra 

Berikut ini adalah contoh penggunaannya:

 const fs = require('fs-extra') const folder = '/Users/flavio' fs.remove(folder, err => { console.error(err) }) 

Metodenya dapat digunakan dalam bentuk janji:

 fs.remove(folder).then(() => { // }).catch(err => { console.error(err) }) 

Konstruksi async / await juga dapat diterima:

 async function removeFolder(folder) { try {   await fs.remove(folder)   // } catch (err) {   console.error(err) } } const folder = '/Users/flavio' removeFolder(folder) 

Modul fs

Di atas, kita telah menemukan beberapa metode modul fs yang digunakan ketika bekerja dengan sistem file. Bahkan, mengandung banyak hal yang lebih bermanfaat. Ingatlah bahwa itu tidak perlu diinstal, untuk menggunakannya dalam program, cukup untuk menghubungkannya:

 const fs = require('fs') 

Setelah itu, Anda akan memiliki akses ke metodenya, di antaranya kami perhatikan berikut ini, beberapa di antaranya sudah Anda ketahui:

• fs.access() : memeriksa keberadaan file dan kemampuan untuk mengaksesnya berdasarkan izin.
• fs.appendFile() : fs.appendFile() data ke file. Jika file tidak ada, itu akan dibuat.
• fs.chmod() : mengubah izin untuk file yang diberikan. Metode serupa: fs.lchmod() , fs.fchmod() .
• fs.chown() : mengubah pemilik dan grup untuk file yang diberikan. Metode serupa: fs.fchown() , fs.lchown() .
• fs.close() : menutup deskriptor file.
• fs.copyFile() : menyalin file.
• fs.createReadStream() : membuat aliran untuk membaca file.
• fs.createWriteStream() : membuat aliran penulisan file.
• fs.link() : membuat tautan keras baru ke file.
• fs.mkdir() : membuat direktori baru.
• fs.mkdtemp() : membuat direktori sementara.
• fs.open() : membuka file.
• fs.readdir() : membaca isi direktori.
• fs.readFile() : membaca isi file. Metode serupa: fs.read() .
• fs.readlink() : membaca nilai tautan simbolik.
• fs.realpath() : menyelesaikan jalur file relatif yang dibuat menggunakan karakter . dan .. , di jalur penuh.
• fs.rename() : mengganti nama file atau folder.
• fs.rmdir() : menghapus folder.
• fs.stat() : mengembalikan informasi file. Metode serupa: fs.fstat() , fs.lstat() .
• fs.symlink() : membuat tautan simbolis baru ke file.
• fs.truncate() : memotong file dengan panjang yang ditentukan. Metode serupa: fs.ftruncate() .
• fs.unlink() : menghapus file atau tautan simbolik.
• fs.unwatchFile() : menonaktifkan pemantauan perubahan file.
• fs.utimes() : mengubah timestamp file. Metode serupa: fs.futimes() .
• fs.watchFile() : Mengaktifkan pemantauan perubahan file. Metode serupa: fs.watch() .
• fs.writeFile() : menulis data ke file. Metode serupa: fs.write() .

Fitur menarik dari modul fs adalah kenyataan bahwa semua metodenya, secara default, asinkron, tetapi ada juga versi sinkronnya, yang namanya diperoleh dengan menambahkan kata Sync ke nama metode asinkron.

Sebagai contoh:

• fs.rename()
• fs.renameSync()
• fs.write()
• fs.writeSync()

Menggunakan metode sinkron secara serius mempengaruhi cara kerja program.

Node.js 10 menyediakan dukungan eksperimental untuk API berbasis janji ini.

Jelajahi metode fs.rename() . Ini adalah versi asinkron dari metode ini menggunakan callback:

 const fs = require('fs') fs.rename('before.json', 'after.json', (err) => { if (err) {   return console.error(err) } // }) 

Saat menggunakan versi sinkronnya, konstruk try/catch digunakan untuk menangani kesalahan:

 const fs = require('fs') try { fs.renameSync('before.json', 'after.json') // } catch (err) { console.error(err) } 

Perbedaan utama antara opsi-opsi ini untuk menggunakan metode ini adalah bahwa dalam kasus kedua, skrip akan diblokir sampai operasi file selesai.

Modul jalur

Modul jalur, yang juga kami bicarakan beberapa fiturnya, berisi banyak alat bermanfaat yang memungkinkan Anda berinteraksi dengan sistem file. Seperti yang telah disebutkan, Anda tidak perlu menginstalnya, karena itu adalah bagian dari Node.js. Untuk menggunakannya, cukup menghubungkannya:

 const path = require('path') 

Properti path.sep dari modul ini menyediakan karakter yang digunakan untuk memisahkan segmen path ( \ pada Windows dan / di Linux dan macOS), dan properti path.delimiter memberikan karakter yang digunakan untuk memisahkan beberapa path ( ; pada Windows dan : di Linux) dan macOS).

Mari kita pertimbangkan dan ilustrasikan beberapa metode modul path .

▍path.basename ()

Mengembalikan fragmen terakhir dari jalan. Dengan meneruskan parameter kedua ke metode ini, Anda dapat menghapus ekstensi file.

 require('path').basename('/test/something') //something require('path').basename('/test/something.txt') //something.txt require('path').basename('/test/something.txt', '.txt') //something 

▍path.dirname ()

Mengembalikan bagian jalur yang mewakili nama direktori:

 require('path').dirname('/test/something') // /test require('path').dirname('/test/something/file.txt') // /test/something 

▍path.extname ()

Mengembalikan bagian jalur yang mewakili ekstensi file:

 require('path').extname('/test/something') // '' require('path').extname('/test/something/file.txt') // '.txt' 

▍path.isAbsolute ()

Mengembalikan nilai true jika path absolut:

 require('path').isAbsolute('/test/something') // true require('path').isAbsolute('./test/something') // false 

▍path.join ()

Menghubungkan beberapa bagian jalan:

 const name = 'flavio' require('path').join('/', 'users', name, 'notes.txt') //'/users/flavio/notes.txt' 

▍path.normalalize ()

Mencoba mencari jalur nyata berdasarkan jalur yang berisi karakter yang digunakan untuk membangun jalur relatif seperti . , .. dan // :

 require('path').normalize('/users/flavio/..//test.txt') ///users/test.txt 

▍path.parse ()

Mengonversi jalur ke objek yang propertinya mewakili bagian individual jalur:

• root : direktori root.
• dir : path file mulai dari direktori root
• base : nama file dan ekstensi.
• name : name file.
• ext : ekstensi file.

Berikut ini contoh menggunakan metode ini:

 require('path').parse('/users/test.txt') 

Sebagai hasil karyanya, objek berikut diperoleh:

 { root: '/', dir: '/users', base: 'test.txt', ext: '.txt', name: 'test' } 

▍path.relative ()

Dibawa, sebagai argumen, 2 cara. Mengembalikan jalur relatif dari jalur pertama ke yang kedua, berdasarkan direktori kerja saat ini:

 require('path').relative('/Users/flavio', '/Users/flavio/test.txt') //'test.txt' require('path').relative('/Users/flavio', '/Users/flavio/something/test.txt') //'something/test.txt' 

▍path.resolve ()

Menemukan jalur absolut berdasarkan jalur relatif yang dilewatkan ke sana:

 path.resolve('flavio.txt') //'/Users/flavio/flavio.txt'      . 

Ringkasan

Hari ini kita melihat modul path dan Node.js fs yang digunakan untuk bekerja dengan sistem file. Pada bagian selanjutnya dari seri ini, di mana itu berakhir, kita akan membahas os , events , modul http , berbicara tentang bekerja dengan stream dan dengan sistem manajemen basis data di Node.js.

Pembaca yang budiman! Paket npm apa yang Anda gunakan saat bekerja dengan sistem file di Node.js?