Periksa secara sinkron apakah file / direktori ada di Node.js


1209

Bagaimana cara saya memeriksa, menggunakan node.js , jika ada file atau direktori?


58
Operasi sinkron sangat bagus untuk melakukan operasi file / direktori satu kali sebelum mengembalikan modul. Misalnya, bootstrap file konfigurasi.
jocull

1
@PaulDraper dengan cache hangat tidak benar dalam semua kasus.
mikemaccana

12
Tidak peduli kinerjanya, kadang-kadang Anda hanya ingin menjalankannya secara sinkron untuk pengalaman pengembang. Misalnya, jika Anda menggunakan Node untuk skrip pemrosesan data yang oleh desain harus diblokir, dalam hal itu async existshanya menambahkan panggilan balik yang tidak perlu.
Kunok

3
Pasti memberi +1 pada pernyataan Kunok. Di sisa kode saya, saya hanya membuat kode lebih rumit ketika itu merupakan hambatan di mana kecepatan sangat penting. Mengapa saya tidak menerapkan prinsip itu dalam membaca file? Di banyak bagian banyak program, kesederhanaan / keterbacaan kode bisa lebih penting daripada kecepatan eksekusi. Jika ini adalah area bottleneck saya akan menggunakan metode async agar tidak menghentikan eksekusi kode lebih lanjut. Kalau tidak ... sinkronisasi bagus. Jangan membenci sinkronisasi secara membabi buta.
BryanGrezeszak

3
Tolong ... jangan "layak dicatat" karena pengguna bertanya secara eksplisit bagaimana melakukannya secara sinkron.
jClark

Jawaban:


2241

Jawaban atas pertanyaan ini telah berubah selama bertahun-tahun. The sekarang jawabannya di sini di bagian atas, diikuti oleh berbagai jawaban selama bertahun-tahun secara kronologis:

Jawaban Saat Ini

Anda bisa menggunakan fs.existsSync():

const fs = require("fs"); // Or `import fs from "fs";` with ESM
if (fs.existsSync(path)) {
    // Do something
}

Itu sudah ditinggalkan selama beberapa tahun, tetapi tidak lagi. Dari dokumen:

Perhatikan bahwa fs.exists()sudah usang, tetapi fs.existsSync()tidak. (Parameter panggilan balik untuk fs.exists()menerima parameter yang tidak konsisten dengan panggilan balik Node.js lainnya. fs.existsSync()Tidak menggunakan panggilan balik.)

Anda telah secara spesifik meminta pemeriksaan sinkron , tetapi jika Anda dapat menggunakan pemeriksaan asinkron sebagai gantinya (biasanya terbaik dengan I / O), gunakan fs.promises.accessjika Anda menggunakan asyncfungsi atau fs.access(karena existssudah usang ) jika tidak:

Dalam suatu asyncfungsi:

try {
    await fs.promises.access("somefile");
    // The check succeeded
} catch (error) {
    // The check failed
}

Atau dengan panggilan balik:

fs.access("somefile", error => {
    if (!error) {
        // The check succeeded
    } else {
        // The check failed
    }
});

Jawaban Historis

Berikut adalah jawaban historis dalam urutan kronologis:

  • Jawaban asli dari 2010
    ( stat/ statSyncatau lstat/ lstatSync)
  • Pembaruan September 2012
    ( exists/ existsSync)
  • Pembaruan Februari 2015
    (Memperhatikan penghentian yang akan datang dari exists/ existsSync, jadi kami mungkin kembali ke stat/ statSyncatau lstat/ lstatSync)
  • Perbarui Desember 2015
    (Ada juga fs.access(path, fs.F_OK, function(){})/ fs.accessSync(path, fs.F_OK), tetapi perhatikan bahwa jika file / direktori tidak ada, itu adalah kesalahan; dokumen untuk fs.statdirekomendasikan digunakan fs.accessjika Anda perlu memeriksa keberadaan tanpa membuka)
  • Pembaruan Desember 2016
    fs.exists() masih usang tetapi fs.existsSync()tidak lagi ditinggalkan. Jadi Anda bisa menggunakannya dengan aman sekarang.

Jawaban asli dari 2010:

Anda dapat menggunakan statSyncatau lstatSync( tautan dokumen ), yang memberi Anda sebuah fs.Statsobjek . Secara umum, jika versi sinkron dari suatu fungsi tersedia, ia akan memiliki nama yang sama dengan versi async Syncdi bagian akhir. Begitu statSyncjuga dengan versi sinkron stat; lstatSyncadalah versi sinkron lstat, dll.

lstatSync memberi tahu Anda apakah sesuatu itu ada, dan jika demikian, apakah itu file atau direktori (atau dalam beberapa sistem file, tautan simbolis, perangkat blok, perangkat karakter, dll.), mis. jika Anda perlu tahu apakah itu ada dan direktori:

var fs = require('fs');
try {
    // Query the entry
    stats = fs.lstatSync('/the/path');

    // Is it a directory?
    if (stats.isDirectory()) {
        // Yes it is
    }
}
catch (e) {
    // ...
}

... dan juga, jika itu file, ada isFile; jika itu adalah perangkat blok, ada isBlockDevice, dll., dll. Perhatikan try/catch; ia melempar kesalahan jika entri tidak ada sama sekali.

Jika Anda tidak peduli apa entri itu dan hanya ingin tahu apakah itu ada, Anda dapat menggunakan path.existsSync(atau dengan yang terbaru fs.existsSync) , seperti yang dicatat oleh user618408 :

var path = require('path');
if (path.existsSync("/the/path")) { // or fs.existsSync
    // ...
}

Itu tidak memerlukan try/catchtetapi tidak memberi Anda informasi tentang apa masalahnya, hanya saja ada di sana. path.existsSyncsudah lama ditinggalkan.


Catatan: Anda telah secara jelas bertanya bagaimana cara memeriksa secara sinkron , jadi saya telah menggunakan xyzSyncversi fungsi di atas. Tetapi sedapat mungkin, dengan I / O, yang terbaik adalah menghindari panggilan sinkron. Panggilan ke subsistem I / O membutuhkan waktu yang signifikan dari sudut pandang CPU. Perhatikan betapa mudahnya menelepon lstatdaripada lstatSync:

// Is it a directory?
lstat('/the/path', function(err, stats) {
    if (!err && stats.isDirectory()) {
        // Yes it is
    }
});

Tetapi jika Anda membutuhkan versi sinkron, itu ada di sana.

Pembaruan September 2012

Jawaban di bawah ini dari beberapa tahun yang lalu sekarang agak ketinggalan zaman. Cara saat ini adalah menggunakan fs.existsSyncuntuk melakukan pemeriksaan sinkron untuk keberadaan file / direktori (atau tentu saja fs.existsuntuk pemeriksaan tidak sinkron), daripada pathversi di bawah ini.

Contoh:

var fs = require('fs');

if (fs.existsSync(path)) {
    // Do something
}

// Or

fs.exists(path, function(exists) {
    if (exists) {
        // Do something
    }
});

Perbarui Februari 2015

Dan inilah kita pada tahun 2015 dan Node docs sekarang mengatakan bahwa fs.existsSync(dan fs.exists) "akan ditinggalkan". (Karena orang-orang Node berpikir bodoh untuk memeriksa apakah ada sesuatu sebelum membukanya, itu memang benar; tetapi itu bukan satu-satunya alasan untuk memeriksa apakah ada sesuatu!)

Jadi kita mungkin kembali ke berbagai statmetode ... Sampai / kecuali ini berubah lagi, tentu saja.

Perbarui Desember 2015

Tidak tahu berapa lama sudah ada, tapi ada juga fs.access(path, fs.F_OK, ...)/fs.accessSync(path, fs.F_OK) . Dan setidaknya pada Oktober 2016, fs.statdokumentasi merekomendasikan penggunaan fs.accessuntuk melakukan pemeriksaan keberadaan ( "Untuk memeriksa apakah ada file tanpa memanipulasi sesudahnya, fs.access()disarankan." ). Tetapi perhatikan bahwa akses yang tidak tersedia dianggap kesalahan , jadi ini mungkin yang terbaik jika Anda mengharapkan file dapat diakses:

var fs = require('fs');

try {
    fs.accessSync(path, fs.F_OK);
    // Do something
} catch (e) {
    // It isn't accessible
}

// Or

fs.access(path, fs.F_OK, function(err) {
    if (!err) {
        // Do something
    } else {
        // It isn't accessible
    }
});

Perbarui Desember 2016

Anda bisa menggunakan fs.existsSync():

if (fs.existsSync(path)) {
    // Do something
}

Itu sudah ditinggalkan selama beberapa tahun, tetapi tidak lagi. Dari dokumen:

Perhatikan bahwa fs.exists()sudah usang, tetapi fs.existsSync()tidak. (Parameter panggilan balik untuk fs.exists()menerima parameter yang tidak konsisten dengan panggilan balik Node.js lainnya. fs.existsSync()Tidak menggunakan panggilan balik.)


7
path.exists dan path.existsSync keduanya telah ditinggalkan demi fs.exists dan fs.existsSync
Drew

15
"Orang-orang bodoh menganggap bodoh untuk memeriksa apakah ada sesuatu sebelum membukanya, apakah itu;" Mengapa bodoh untuk memeriksa apakah file ada?
Petr Hurtak

32
@PetrHurtak: Tidak selalu (karena ada banyak alasan untuk memeriksa keberadaan), tetapi jika Anda akan membuka file, yang terbaik adalah hanya mengeluarkan openpanggilan dan menangani pengecualian atau apa pun jika file tidak ditemukan. Lagipula, dunia nyata kacau: Jika Anda memeriksa dulu dan itu ada di sana, itu tidak berarti itu akan tetap ada ketika Anda mencoba membukanya; jika Anda memeriksa dulu dan tidak ada di sana, itu tidak berarti itu tidak akan ada di sana beberapa saat kemudian. Mengatur waktu hal-hal seperti itu tampak seperti kasus tepi, tetapi mereka muncul setiap saat . Jadi jika Anda akan membuka, tidak ada gunanya memeriksa dulu.
TJ Crowder

13
Dan di sini saya pikir itu adalah anti-pola untuk menggunakan kesalahan untuk aliran kontrol: link
argyle

4
@jeromeyers: Anda bisa, tetapi Ionică telah melakukannya untuk Anda (lihat komentar di atas ). :-)
TJ Crowder

124

Melihat sumbernya, ada versi sinkron dari path.exists- path.existsSync. Sepertinya itu terlewatkan dalam dokumen.

Memperbarui:

path.existsdan path.existsSyncsekarang sudah usang . Silakan gunakan fs.existsdanfs.existsSync .

Pembaruan 2016:

fs.exists dan fs.existsSyncjuga sudah usang . Gunakan fs.stat () atau fs.access () sebagai gantinya.

Pembaruan 2019:

gunakan fs.existsSync. Itu tidak ditinggalkan. https://nodejs.org/api/fs.html#fs_fs_existssync_path


1
path.existsSync (p) ada di 0.4.10 docs nodejs.org/docs/v0.4.10/api/path.html
Paul Beusterien

21
Sebenarnya, jawaban yang lebih baru: path.existsSync sudah usang. Sekarang disebut fs.existsSync.
Olivier Lalonde

9
Sekarang dokumen mengatakan fs.exists akan ditinggalkan. nodejs.org/api/fs.html#fs_fs_existssync_path
Greg Hornby

Saya menulis perpustakaan kecil untuk menggantikan existsfungsi lama :is-there
Ionică Bizău

6
dokumen arus (versi ~ 9) hanya dilabeli fs.existssebagai usang sementara fs.existsSynctidak!
Kunok

57

Menggunakan API yang saat ini direkomendasikan (per 2015) (per Node docs), inilah yang saya lakukan:

var fs = require('fs');

function fileExists(filePath)
{
    try
    {
        return fs.statSync(filePath).isFile();
    }
    catch (err)
    {
        return false;
    }
}

Menanggapi masalah EPERM yang diangkat oleh @broadband dalam komentar, itu memunculkan poin yang bagus. fileExists () mungkin bukan cara yang baik untuk memikirkan hal ini dalam banyak kasus, karena fileExists () tidak dapat benar-benar menjanjikan pengembalian boolean. Anda mungkin dapat menentukan secara pasti bahwa file itu ada atau tidak ada, tetapi Anda juga bisa mendapatkan kesalahan izin. Kesalahan izin tidak selalu menyiratkan bahwa file itu ada, karena Anda bisa kekurangan izin ke direktori yang berisi file yang Anda periksa. Dan tentu saja ada kemungkinan Anda bisa menemukan kesalahan lain dalam memeriksa keberadaan file.

Jadi kode saya di atas benar-benar doesFileExistAndDoIHaveAccessToIt (), tetapi pertanyaan Anda mungkin apakahFileNotExistAndCouldICreateIt (), yang akan menjadi logika yang sangat berbeda (yang perlu memperhitungkan kesalahan EPERM, antara lain).

Sementara jawaban fs.existsSync menjawab pertanyaan yang diajukan langsung di sini, itu seringkali tidak sesuai dengan yang Anda inginkan (Anda tidak hanya ingin tahu apakah "sesuatu" ada di jalur, Anda mungkin peduli apakah "benda" itu ada. yang ada adalah file atau direktori).

Intinya adalah bahwa jika Anda memeriksa untuk melihat apakah ada file, Anda mungkin melakukan itu karena Anda berniat untuk mengambil beberapa tindakan berdasarkan hasil, dan bahwa logika (pemeriksaan dan / atau tindakan selanjutnya) harus mengakomodasi ide bahwa sesuatu yang ditemukan di jalur itu mungkin berupa file atau direktori, dan bahwa Anda mungkin menemui EPERM atau kesalahan lain dalam proses pemeriksaan.


4
Bagus, saya menambahkan || isDirectory () untuk menjadikannya pemeriksa file / folder. var stats = fs.statSync (filePath); return stats.isFile () || stats.isDirectory ();
bob

4
Jika program tidak memiliki hak untuk mengakses file, ia tetap mengembalikan false walaupun ada file yaitu menghapus semua rigts dari file chmod ugo-rwx file.txt atau di Windows Klik Kanan ... Pesan pengecualian: Pengecualian fs.statSync (./ f.txt): Kesalahan: EPERM: operasi tidak diizinkan, stat 'X: \ f.txt'. Jadi kasus ini tidak dicakup oleh kode atas.
broadband

2
Wow, JS terkadang terbelakang. Jadi yakin, 97% dari waktu Anda akan menggunakan file, tetapi tidak memiliki file.exists()util sederhana untuk 3% dan bukannya memaksa kita untuk membungkus ini dalam try catch? Dapatkan nyata ... Pelacur hari ini.
expelledboy

20

Pembaruan lain

Membutuhkan jawaban untuk pertanyaan ini sendiri, saya mencari node docs, sepertinya Anda tidak boleh menggunakan fs.exists, alih-alih gunakan fs.open dan gunakan kesalahan yang dihasilkan untuk mendeteksi jika file tidak ada:

dari dokumen:

fs.exists () adalah anakronisme dan hanya ada karena alasan historis. Seharusnya hampir tidak pernah ada alasan untuk menggunakannya dalam kode Anda sendiri.

Khususnya, memeriksa apakah ada file sebelum membukanya, ini merupakan pola-anti yang membuat Anda rentan terhadap kondisi balapan: proses lain dapat menghapus file di antara panggilan ke fs.exists () dan fs.open (). Cukup buka file dan tangani kesalahannya saat tidak ada.

http://nodejs.org/api/fs.html#fs_fs_exists_path_callback


1
apakah ada cara untuk melakukannya dengan openSync, daripada terbuka
Greg Hornby

1
@GregHornby Saya membayangkan itu harus bekerja dengan cara yang sama dengan openSync
Melbourne2991

2
Bagi yang masih membutuhkan exists dan existsSyncsaya buat is-there.
Ionică Bizău

6
Penghentian ini menggangguku. Membuka file hanya untuk melihat apakah kesalahan dilemparkan atau tidak tampak seperti pemborosan sumber daya ketika semua yang dibutuhkan adalah pengetahuan tentang keberadaan file.
Josh Hansen

11

Saya menggunakan fungsi di bawah ini untuk menguji apakah ada file. Itu juga menangkap pengecualian lain. Jadi jika ada masalah hak misalnya chmod ugo-rwx filenameatau dalam Right Click -> Properties -> Security -> Advanced -> Permission entries: empty list ..fungsi Windows mengembalikan pengecualian sebagaimana mestinya. File ada tetapi kami tidak memiliki hak untuk mengaksesnya. Adalah salah untuk mengabaikan pengecualian semacam ini.

function fileExists(path) {

  try  {
    return fs.statSync(path).isFile();
  }
  catch (e) {

    if (e.code == 'ENOENT') { // no such file or directory. File really does not exist
      console.log("File does not exist.");
      return false;
    }

    console.log("Exception fs.statSync (" + path + "): " + e);
    throw e; // something else went wrong, we don't have rights, ...
  }
}

Output pengecualian, dokumentasi kesalahan simpuljs dalam file kasus tidak ada:

{
  [Error: ENOENT: no such file or directory, stat 'X:\\delsdfsdf.txt']
  errno: -4058,
  code: 'ENOENT',
  syscall: 'stat',
  path: 'X:\\delsdfsdf.txt'
}

Pengecualian jika kami tidak memiliki hak atas file tersebut, tetapi ada:

{
  [Error: EPERM: operation not permitted, stat 'X:\file.txt']
  errno: -4048,
  code: 'EPERM',
  syscall: 'stat',
  path: 'X:\\file.txt'
}

2
Benar-benar seperti ini, ini adalah salah satu dari beberapa jawaban yang terkini karena node telah mencabut 37 cara terakhir untuk melakukan ini
1mike12

Bah, Anda mengalahkan saya untuk itu. Saya bisa menghemat waktu jika saya membaca ini.
jgmjgm

5

fs.exists () sudah usang jangan menggunakannya https://nodejs.org/api/fs.html#fs_fs_exists_path_callback

Anda bisa mengimplementasikan cara simpuljs inti yang digunakan di ini: https://github.com/nodejs/node-v0.x-archive/blob/master/lib/module.js#L86

function statPath(path) {
  try {
    return fs.statSync(path);
  } catch (ex) {}
  return false;
}

ini akan mengembalikan objek statistik maka setelah Anda mendapatkan objek statistik yang bisa Anda coba

var exist = statPath('/path/to/your/file.js');
if(exist && exist.isFile()) {
  // do something
}

4

Beberapa jawaban di sini mengatakan itu fs.existsdan fs.existsSynckeduanya sudah usang. Menurut dokumen ini tidak lagi benar. Hanya fs.existsdepreksi sekarang:

Perhatikan bahwa fs.exists () sudah usang, tetapi fs.existsSync () tidak. (Parameter panggilan balik ke fs.exists () menerima parameter yang tidak konsisten dengan panggilan balik Node.js lainnya. Fs.existsSync () tidak menggunakan panggilan balik.)

Jadi Anda dapat menggunakan fs.existsSync () dengan aman untuk memeriksa apakah ada file.


3

The pathmodul tidak menyediakan versi sinkron path.existssehingga Anda harus mengelabui sekitar dengan fsmodul.

Hal tercepat yang dapat saya bayangkan adalah menggunakan fs.realpathSyncyang akan melempar kesalahan yang harus Anda tangkap, jadi Anda harus membuat fungsi pembungkus sendiri dengan mencoba / menangkap.


1

Menggunakan tes fileSystem (fs) akan memicu objek kesalahan, yang kemudian harus Anda bungkus dalam pernyataan try / catch. Simpan upaya Anda sendiri, dan gunakan fitur pengantar di cabang 0.4.x.

var path = require('path');

var dirs = ['one', 'two', 'three'];

dirs.map(function(dir) {
  path.exists(dir, function(exists) {
    var message = (exists) ? dir + ': is a directory' : dir + ': is not a directory';
    console.log(message);
  });
});

2
Path.exists sekarang berada di bawah fs sehingga fs.exists (path, callback)
Todd Moses

0

Dokumen di fs.stat()mengatakan untuk digunakan fs.access()jika Anda tidak akan memanipulasi file. Itu tidak memberikan pembenaran, mungkin lebih cepat atau kurang memeory digunakan?

Saya menggunakan simpul untuk otomatisasi linier, jadi saya pikir saya berbagi fungsi yang saya gunakan untuk menguji keberadaan file.

var fs = require("fs");

function exists(path){
    //Remember file access time will slow your program.
    try{
        fs.accessSync(path);
    } catch (err){
        return false;
    }
    return true;
}

0

diperbarui asnwer untuk orang-orang 'benar' menunjukkan itu tidak langsung menjawab pertanyaan, lebih banyak membawa opsi alternatif.

Solusi sinkronisasi:

fs.existsSync('filePath')lihat juga dokumen di sini .

Mengembalikan nilai true jika path ada, false jika tidak.

Solusi Async Promise

Dalam konteks async Anda hanya bisa menulis versi async dalam metode sinkronisasi dengan menggunakan awaitkata kunci. Anda bisa mengubah metode panggilan balik async menjadi janji seperti ini:

function fileExists(path){
  return new Promise((resolve, fail) => fs.access(path, fs.constants.F_OK, 
    (err, result) => err ? fail(err) : resolve(result))
  //F_OK checks if file is visible, is default does no need to be specified.

}

async function doSomething() {
  var exists = await fileExists('filePath');
  if(exists){ 
    console.log('file exists');
  }
}

dokumen tentang akses ().


1
OP menginginkan solusi sinkron
vdegenne

Anda harus memperbarui kode Anda kefunction asyncFileExists(path) { //F_OK checks if file is visible, is default does no need to be specified. return new Promise(function (res, rej) { fs.access( path, fs.constants.F_OK, function (err) { err ? rej(err) : res(true); }, ); }); }
pery mimon

0

Kemungkinannya adalah, jika Anda ingin tahu apakah ada file, Anda berencana untuk meminta jika ada.

function getFile(path){
    try{
        return require(path);
    }catch(e){
        return false;
    }
}

-1

Berikut ini adalah solusi pembungkus sederhana untuk ini:

var fs = require('fs')
function getFileRealPath(s){
    try {return fs.realpathSync(s);} catch(e){return false;}
}

Pemakaian:

  • Bekerja untuk direktori dan file
  • Jika item ada, ia mengembalikan path ke file atau direktori
  • Jika item tidak ada, itu mengembalikan false

Contoh:

var realPath,pathToCheck='<your_dir_or_file>'
if( (realPath=getFileRealPath(pathToCheck)) === false){
    console.log('file/dir not found: '+pathToCheck);
} else {
    console.log('file/dir exists: '+realPath);
}

Pastikan Anda menggunakan operator === untuk menguji apakah return sama dengan false. Tidak ada alasan logis bahwa fs.realpathSync () akan mengembalikan false di bawah kondisi kerja yang tepat, jadi saya pikir ini harus bekerja 100%.

Saya lebih suka melihat solusi yang tidak menghasilkan Kesalahan dan mengakibatkan hit kinerja. Dari perspektif API, fs.exists () sepertinya solusi paling elegan.


1
@Dan, terima kasih. Saya menghapus teks yang terpotong. Saya tidak ingat apa not itu. Jika itu datang saya, saya akan menambahkan catatan.
Timothy C. Quinn

1
Np. Saya menghapus komentar saya.
Dan Dascalescu

-2

Dari jawaban, tampaknya tidak ada dukungan API resmi untuk ini (seperti dalam pemeriksaan langsung dan eksplisit). Banyak jawaban mengatakan menggunakan stat, namun tidak ketat. Sebagai contoh, kita tidak dapat berasumsi bahwa kesalahan yang dibuat oleh stat berarti ada sesuatu yang tidak ada.

Katakanlah kita mencobanya dengan sesuatu yang tidak ada:

$ node -e 'require("fs").stat("god",err=>console.log(err))'
{ Error: ENOENT: no such file or directory, stat 'god' errno: -2, code: 'ENOENT', syscall: 'stat', path: 'god' }

Mari kita coba dengan sesuatu yang ada tetapi kita tidak memiliki akses ke:

$ mkdir -p fsm/appendage && sudo chmod 0 fsm
$ node -e 'require("fs").stat("fsm/appendage",err=>console.log(err))'
{ Error: EACCES: permission denied, stat 'access/access' errno: -13, code: 'EACCES', syscall: 'stat', path: 'fsm/appendage' }

Paling tidak Anda akan menginginkan:

let dir_exists = async path => {
    let stat;
    try {
       stat = await (new Promise(
           (resolve, reject) => require('fs').stat(path,
               (err, result) => err ? reject(err) : resolve(result))
       ));
    }
    catch(e) {
        if(e.code === 'ENOENT') return false;
        throw e;
    }

    if(!stat.isDirectory())
        throw new Error('Not a directory.');

    return true;
};

Pertanyaannya tidak jelas apakah Anda benar-benar ingin sinkron atau jika Anda hanya ingin itu ditulis seolah-olah sinkron. Contoh ini menggunakan await / async sehingga hanya ditulis secara sinkron tetapi berjalan secara asinkron.

Ini berarti Anda harus menyebutnya seperti itu di tingkat atas:

(async () => {
    try {
        console.log(await dir_exists('god'));
        console.log(await dir_exists('fsm/appendage'));
    }
    catch(e) {
        console.log(e);
    }
})();

Alternatif menggunakan .then dan .catch pada janji yang dikembalikan dari panggilan async jika Anda membutuhkannya lebih jauh.

Jika Anda ingin memeriksa apakah ada sesuatu maka itu praktik yang baik untuk juga memastikan itu adalah jenis yang tepat seperti direktori atau file. Ini termasuk dalam contoh. Jika tidak diizinkan menjadi symlink, Anda harus menggunakan lstat daripada stat karena stat akan secara otomatis melintasi tautan.

Anda dapat mengganti semua async untuk menyinkronkan kode di sini dan menggunakan statSync sebagai gantinya. Namun berharap bahwa begitu async dan menunggu menjadi universal mendukung panggilan Sync akan menjadi berlebihan pada akhirnya akan didepresiasi (jika tidak, Anda harus mendefinisikannya di mana-mana dan menaiki rantai seperti halnya async sehingga membuatnya benar-benar tidak ada gunanya).


1
Pertanyaan aslinya tidak menjelaskan hal itu. Saya juga mendemonstrasikan bagaimana melakukan sesuatu dengan jelas. Banyak jawaban yang mungkin menyebabkan bug karena kurang jelas. Orang-orang sering ingin memprogram hal-hal sehingga tampak sinkron tetapi tidak ingin eksekusi sinkron. statSync tidak sama dengan kode yang saya tunjukkan. Entah akun yang diinginkan sebenarnya ambigu, sehingga Anda hanya memaksakan interpretasi pribadi Anda. Jika Anda menemukan jawaban yang tidak Anda pahami, mungkin lebih baik bertanya dalam komentar atau PM untuk mencari tahu apa yang dibutuhkan untuk diedit.
jgmjgm

1
Jika mau, Anda juga dapat mencuri sampel kode saya, beri nama dengan tepat, letakkan di github, tambahkan ke npm dan kemudian jawabannya hanya akan menjadi satu baris / tautan: D.
jgmjgm

Sebagai contoh, kode ini singkat tetapi Anda dapat mengirimkan saran edit untuk menyertakan &&! IsFile atau cek untuk symlink, dll. (Sekali lagi meskipun pertanyaannya tidak pernah secara eksplisit menyatakan bahkan itu yang mereka inginkan). Seperti yang telah saya tunjukkan, jawaban saya memuaskan satu interpretasi dari pertanyaan dan tidak melakukan hal yang sama dengan proposal satu baris Anda.
jgmjgm
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.