Pembangunan Aplikasi Desktop Electron · Pelajaran

Akses Sistem Fail

Pelajari cara membaca, menulis dan memanipulasi fail serta direktori secara langsung pada sistem pengguna menggunakan modul `fs` Node.js daripada proses utama.

Pelajaran 2 daripada 311 langkah

Akses Sistem Fail ialah pelajaran Pembangunan Aplikasi Desktop Electron percuma di CoddyKit. Ini ialah pelajaran 2 daripada 3. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Pembangunan Aplikasi Desktop Electron, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Pembangunan Aplikasi Desktop Electron merangkumi sejumlah 3 pelajaran.

Mengakses Fail Setempat

Aplikasi Electron boleh melakukan lebih banyak perkara berbanding halaman web. Aplikasi ini boleh berinteraksi secara terus dengan komputer pengguna, termasuk sistem failnya!

Pelajaran ini meneroka cara membaca, menulis dan mengurus fail serta direktori menggunakan modul fs Node.js.

Penerangan Modul `fs` Node.js

Modul fs (Sistem Fail) ialah ciri teras Node.js. Modul ini menyediakan kaedah untuk berinteraksi dengan sistem fail.

Membaca Fail: Mendapatkan kandungan daripada fail sedia ada.
Menulis Fail: Mencipta fail baharu atau mengemas kini fail sedia ada.
Mengurus Direktori: Mencipta, memadam atau menyenaraikan folder.

Modul ini ialah laluan anda kepada data setempat yang kekal.

`fs` & Proses Utama

Atas sebab keselamatan, anda hendaklah menggunakan modul fs terutamanya dalam proses utama Electron.

Proses utama mempunyai akses Node.js sepenuhnya, manakala proses pemapar (halaman web anda) biasanya dikotakkan. Langkah ini menghalang kandungan web berniat jahat daripada mengakses fail pengguna secara terus.

Jika proses pemapar memerlukan akses fail, proses tersebut hendaklah memintanya dengan selamat daripada proses utama melalui IPC.

Membaca Fail (`readFileSync`)

Cara paling mudah untuk membaca fail adalah secara segerak menggunakan fs.readFileSync(). Ini bermakna kod anda akan berhenti seketika sehingga fail selesai dibaca.

Tentukan laluan fail dan pengekodan (contohnya, 'utf8') untuk mendapatkan kandungan sebagai rentetan.

const fs = require('fs');
const path = require('path');

// Create a temporary file for demonstration
const tempFilePath = path.join(__dirname, 'hello.txt');
fs.writeFileSync(tempFilePath, 'Hello CoddyKit!', 'utf8');

try {
  const content = fs.readFileSync(tempFilePath, 'utf8');
  console.log('Read content:', content);
} catch (error) {
  console.error('Failed to read file:', error.message);
}

// Clean up the temporary file
fs.unlinkSync(tempFilePath);

Menulis Fail (`writeFileSync`)

Untuk menulis kandungan ke dalam fail, gunakan fs.writeFileSync(). Jika fail tersebut belum wujud, fail itu akan dicipta. Jika fail itu sudah wujud, kandungannya akan ditulis ganti.

Sentiasa kendalikan ralat yang berkemungkinan berlaku dengan blok try...catch.

const fs = require('fs');
const path = require('path');

const outputFilePath = path.join(__dirname, 'output.txt');
const dataToWrite = 'This is some new content for the file.';

try {
  fs.writeFileSync(outputFilePath, dataToWrite, 'utf8');
  console.log('File written successfully to', outputFilePath);
} catch (error) {
  console.error('Failed to write file:', error.message);
}

// Clean up the temporary file
fs.unlinkSync(outputFilePath);

Menambahkan Data (`appendFileSync`)

Jika anda mahu menambahkan kandungan pada penghujung fail sedia ada tanpa menulis gantinya, gunakan fs.appendFileSync().

Ini berguna untuk aktiviti logging atau menambahkan entri baharu pada senarai.

const fs = require('fs');
const path = require('path');

const logFilePath = path.join(__dirname, 'app.log');

// Ensure the file exists (or create it)
fs.writeFileSync(logFilePath, 'Initial log entry.\n', 'utf8');

const newLogEntry = 'Another event happened now.\n';
try {
  fs.appendFileSync(logFilePath, newLogEntry, 'utf8');
  console.log('Appended to log file.');
  console.log('Current log content:\n', fs.readFileSync(logFilePath, 'utf8'));
} catch (error) {
  console.error('Failed to append to file:', error.message);
}

// Clean up the temporary file
fs.unlinkSync(logFilePath);

Kaedah `fs` Tak Segerak

Operasi segerak boleh menyekat bebenang utama aplikasi anda dan menyebabkan UI tidak responsif. Untuk prestasi yang lebih baik, terutamanya dengan fail yang lebih besar, gunakan kaedah tak segerak.

fs.readFile() dan fs.writeFile() menggunakan panggilan balik atau Promise (dengan modul fs/promises) untuk mengendalikan penyelesaian operasi.

const fs = require('fs/promises'); // Using promise-based fs
const path = require('path');

const asyncFilePath = path.join(__dirname, 'async_data.txt');
const data = 'Data for async file.';

async function runAsyncOperations() {
  try {
    await fs.writeFile(asyncFilePath, data, 'utf8');
    console.log('Async file written.');

    const content = await fs.readFile(asyncFilePath, 'utf8');
    console.log('Async file read:', content);
  } catch (error) {
    console.error('Async operation failed:', error.message);
  } finally {
    // Clean up
    if (await fs.stat(asyncFilePath).then(() => true).catch(() => false)) {
      await fs.unlink(asyncFilePath);
    }
  }
}

runAsyncOperations();

Mencipta & Menyenaraikan Direktori

Modul fs juga membolehkan anda mengurus direktori (folder).

fs.mkdirSync(path, { recursive: true }): Mencipta direktori. recursive: true mencipta direktori induk jika diperlukan.
fs.readdirSync(path): Membaca kandungan direktori dan mengembalikan tatasusunan nama fail/direktori.
fs.rmSync(path, { recursive: true, force: true }): Mengalih keluar direktori (serta kandungannya).

const fs = require('fs');
const path = require('path');

const dirPath = path.join(__dirname, 'my_app_data');
const subDirPath = path.join(dirPath, 'logs');

try {
  // Create directories
  fs.mkdirSync(subDirPath, { recursive: true });
  console.log('Directory created:', subDirPath);

  // Write a file inside
  fs.writeFileSync(path.join(dirPath, 'config.json'), '{ "version": "1.0" }');
  fs.writeFileSync(path.join(subDirPath, 'error.log'), 'Error 1\nError 2');

  // List contents of dirPath
  const contents = fs.readdirSync(dirPath);
  console.log('Contents of', dirPath, ':', contents);

} catch (error) {
  console.error('Directory operation failed:', error.message);
} finally {
  // Clean up
  if (fs.existsSync(dirPath)) {
    fs.rmSync(dirPath, { recursive: true, force: true });
    console.log('Cleaned up directory:', dirPath);
  }
}

Laluan dengan Modul `path`

Laluan fail berbeza antara sistem pengendalian (contohnya, /home/user/file.txt pada Linux berbanding C:\Users\user\file.txt pada Windows).

Gunakan modul path terbina dalam Node.js untuk membina dan menormalkan laluan dengan boleh dipercayai merentas platform.

path.join(...segments): Menggabungkan segmen laluan.
path.resolve(...segments): Menyelesaikan jujukan laluan atau segmen laluan menjadi laluan mutlak.

const path = require('path');

const userDir = 'CoddyKitApp';
const dataFile = 'settings.json';

// Correct way to join paths
const fullPath = path.join(userDir, 'data', dataFile);
console.log('Joined path:', fullPath);

// Get absolute path (relative to current working directory)
const absolutePath = path.resolve(userDir, 'data', dataFile);
console.log('Absolute path:', absolutePath);

// Get directory name
console.log('Dir name:', path.dirname(fullPath));

// Get base name (file name with extension)
console.log('Base name:', path.basename(fullPath));

Cabaran Sistem Fail

Pertimbangkan coretan kod Node.js berikut:

const fs = require('fs');
const path = require('path');
const filePath = path.join(__dirname, 'test_file.txt');

fs.writeFileSync(filePath, 'First line.\n', 'utf8');
fs.appendFileSync(filePath, 'Second line.\n', 'utf8');
const content = fs.readFileSync(filePath, 'utf8');

console.log(content);
fs.unlinkSync(filePath); // Clean up

Jawab dalam pelajaran interaktif

Imbas Kembali Akses Sistem Fail

Anda telah mempelajari cara berinteraksi dengan sistem fail dalam Electron!

Modul fs penting untuk operasi fail.
Lakukan operasi fail terutamanya dalam proses utama demi keselamatan.
Bezakan kaedah segerak (menyekat) dengan kaedah tak segerak (tidak menyekat).
Gunakan modul path untuk pengurusan laluan merentas platform.

Pengetahuan ini membolehkan aplikasi Electron anda menyimpan dan mendapatkan semula data secara terus pada mesin pengguna.

Percuma untuk bermula

Pelajari JavaScript dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 12
Pelajaran: 47

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Akses Sistem Fail” percuma?

Ya — teks penuh “Akses Sistem Fail” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Pembangunan Aplikasi Desktop Electron, tingkat taraf kepada CoddyKit PRO. Kursus Pembangunan Aplikasi Desktop Electron merangkumi sejumlah 3 pelajaran.

Apakah yang akan saya pelajari dalam “Akses Sistem Fail”?

Pelajari cara membaca, menulis dan memanipulasi fail serta direktori secara langsung pada sistem pengguna menggunakan modul `fs` Node.js daripada proses utama. Anda berlatih Pembangunan Aplikasi Desktop Electron menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Pembangunan Aplikasi Desktop Electron?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Pembangunan Aplikasi Desktop Electron di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 3.

Berapa lamakah pelajaran “Akses Sistem Fail” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Pembangunan Aplikasi Desktop Electron ini?

Ya. Setiap pelajaran Pembangunan Aplikasi Desktop Electron menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Pembangunan Aplikasi Desktop Electron