Perbincangan ringkas tentang modul laluan dan kaedah biasa dalam Node.js

Artikel ini akan membawa anda melalui modul Path dalam Node.js, memperkenalkan penggunaan modul Path dan kaedah Path yang biasa digunakan.

Node.js modul laluan ialah modul terbina dalam yang membantu anda bekerja dengan laluan sistem fail dalam cara bebas sistem pengendalian. Modul Path adalah penting jika anda ingin membina alat CLI yang menyokong OSX, Linux dan Windows. [Pembelajaran yang disyorkan: "tutorial nodejs"]

Walaupun anda sedang membina perkhidmatan hujung belakang yang hanya berjalan pada Linux, modul laluan masih membantu mengelakkan kes tepi apabila memanipulasi laluan.

Di bawah ini kami menerangkan beberapa corak biasa untuk menggunakan modul laluan dan sebab anda perlu menggunakan modul laluan dan bukannya memanipulasi laluan menjadi rentetan.

Menggunakan modul Path dalam Node

Kaedah yang paling biasa digunakan dalam modul laluan ialah path.join(). Kaedah ini menggabungkan satu atau lebih segmen laluan ke dalam satu rentetan, seperti yang ditunjukkan di bawah:

const path = require('path')

path.join('/path', 'to', 'test.txt') // '/path/to/test.txt'

Anda mungkin tertanya-tanya mengapa anda perlu menggunakan kaedah path.join() dan bukannya penggabungan rentetan.

'/path' + '/' + 'to' + '/' + 'test.txt' // '/path/to/test.txt'

['/path', 'to', 'test.txt'].join('/') // '/path/to/test.txt'

Terdapat dua sebab utama:

• Untuk sokongan Windows. Windows menggunakan garis miring ke belakang () dan bukannya garis miring ke hadapan (/) sebagai pemisah laluan. path.join() akan mengendalikan ini untuk kami. Kerana path.join('data', 'test.txt') mengembalikan 'data/test.txt' pada Linux dan OSX serta Windows.
• digunakan untuk mengendalikan kes tepi . Terdapat banyak kes tepi yang muncul apabila menggunakan laluan sistem fail. Contohnya, jika anda cuba menggabungkan dua laluan secara manual, anda mungkin mendapat pemisah laluan pendua secara tidak sengaja. Kaedah path.join() mengendalikan garis miring di hadapan dan di belakang untuk kami, seperti berikut:

path.join('data', 'test.txt') // 'data/test.txt'
path.join('data', '/test.txt') // 'data/test.txt'
path.join('data/', 'test.txt') // 'data/test.txt'
path.join('data/', '/test.txt') // 'data/test.txt'

Kaedah Laluan yang biasa digunakan

Modul laluan juga mempunyai Beberapa kaedah untuk mengekstrak komponen laluan, seperti sambungan fail atau direktori. Kaedah

path.extname() mengembalikan sambungan fail sebagai rentetan:

path.extname('/path/to/test.txt') // '.test'

Sama seperti menggabungkan dua laluan, mendapatkan sambungan fail adalah lebih rumit daripada yang kelihatan pada mulanya.

Jika laluan berakhir dengan ., . akan dikembalikan. Jika fail tidak mempunyai sambungan dan tidak berakhir dengan ., atau fail tidak mempunyai sambungan, nilai nol akan dikembalikan.

path.extname('/path/to/index.') // '.'

path.extname('/path/to/README') // ''

path.extname('/path/to/.gitignore') // ''

modul laluan juga mempunyai kaedah path.basename() dan path.dirname() untuk mendapatkan nama fail (termasuk sambungan) dan direktori masing-masing. Kaedah

path.basename('/path/to/test.txt') // 'test.txt'

path.dirname('/path/to/test.txt') // '/path/to'

path.parse() mengembalikan objek yang mengandungi laluan yang dibahagikan kepada lima komponen berbeza, termasuk sambungan dan direktori. Kaedah path.parse() juga merupakan cara untuk mendapatkan nama fail tanpa sebarang sambungan.

path.parse('/path/to/test.txt')

/*
{
  root: '/',
  dir: '/path/to',
  base: 'test.txt',
  ext: '.txt',
  name: 'test'
}
*/

Menggunakan path.relative()

Kaedah seperti path.join() dan path.extname() meliputi kebanyakan kes penggunaan bekerja dengan laluan fail. Tetapi modul laluan mempunyai beberapa kaedah yang lebih maju, seperti path.relative(). Kaedah

path.relative(from, to) mengembalikan laluan relatif daripada from kepada to berdasarkan direktori kerja semasa. Jika from dan to kedua-duanya menyelesaikan ke laluan yang sama (selepas memanggil path.resolve() masing-masing), rentetan panjang sifar dikembalikan.

// 返回相对于第一条路径的第二条路径的路径
path.relative('/app/views/home.html', '/app/layout/index.html') // '../../layout/index.html'

Kaedah path.relative() berguna jika anda diberi laluan relatif kepada satu direktori, tetapi memerlukan laluan relatif kepada direktori lain. Contohnya, pustaka pemantauan sistem fail popular Chokidar menyediakan laluan berbanding dengan direktori yang dipantau.

const watcher = chokidar.watch('mydir')

// 如果用户添加 mydir/path/to/test.txt，则会打印 mydir/path/to/test.txt
watcher.on('add', path => console.log(path))

Itulah sebabnya alat Chokidar banyak digunakan. Contohnya, Gatsby atau webpack biasa juga menggunakan kaedah path.relative() secara meluas secara dalaman.

Sebagai contoh, Gatsby menggunakan kaedah path.relative() untuk membantu menyegerakkan direktori fail statik.

export const syncStaticDir = (): void => {
  const staticDir = nodePath.join(process.cwd(), `static`)
  chokidar
    .watch(staticDir)
    .on(`add`, path => {
      const relativePath = nodePath.relative(staticDir, path)
      fs.copy(path, `${process.cwd()}/public/${relativePath}`)
    })
    .on(`change`, path => {
      const relativePath = nodePath.relative(staticDir, path)
      fs.copy(path, `${process.cwd()}/public/${relativePath}`)
    })
}

Sekarang, andaikan pengguna menambah fail baharu static pada direktori main.js. Chokidar memanggil pengendali acara on('add') dengan laluan ditetapkan kepada static/main.js. Walau bagaimanapun, apabila anda menyalin fail ke /public, static/ tambahan tidak diperlukan.

Memanggil path.relative('static', 'static/main.js') mengembalikan laluan static/main.js berbanding static , iaitu laluan yang anda mahu salin kandungan static ke public .

跨操作系统路径和 URL

默认情况下，path 模块会根据 Node 进程运行的操作系统自动在 POSIX（OSX、Linux）和 Windows 模式之间切换。

但是，path 模块确实可以在 POSIX 上使用 Windows path 模块，反之亦然。path.posix 和 path.win32 属性分别包含 path 模块的 Posix 和 Windows 版本。

// 返回 'path\to\test.txt'，与操作系统无关
path.win32.join('path', 'to', 'test.txt')

// 返回 'path/to/test.txt'，与操作系统无关
path.posix.join('path', 'to', 'test.txt')

在大多数情况下，根据检测到的操作系统自动切换 path 模块是正确的行为。但是，使用 path.posix 和 path.win32 属性对于总是希望输出 Windows 或 Linux 样式路径的测试或应用程序可能会有所帮助。

例如，一些应用程序使用 path.join() 和 path.extname() 等方法处理 URL 路径。

// 'https://api.mydomain.app/api/v2/me'
'https://api.mydomain.app/' + path.join('api', 'v2', 'me')

这种方法适用于 Linux 和 OSX，但如果有人试图将您的应用程序部署到一些无服务器上会发生什么？

你最终会得到 https://api.mydomain.app/api\v2\me，这不是有效的 URL！如果使用 path 模块操作 URL，则应使用 path.posix。

原文地址：https://juejin.cn/post/6997799224213504037

作者：lio_zero

更多编程相关知识，请访问：编程视频！！

Atas ialah kandungan terperinci Perbincangan ringkas tentang modul laluan dan kaedah biasa dalam Node.js. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!