Podstawowy przewodnik po manipulowaniu systemem plików w Node.js

Jedną z wbudowanych funkcji Node.js jest manipulacja systemem plików systemu operacyjnego za pomocą modułu fs. Ten moduł Node.js zawiera wiele przydatnych funkcji do pracy z plikami i katalogami.

Pliki są po prostu określane jako utrwalone obiekty lub fragmenty danych, które są zwykle przechowywane na twardym nośniku zwanym dyskiem lub pamięcią. Pliki mogą być różnego rodzaju, od plików tekstowych po pliki graficzne, pliki audio i wiele innych.

MAKEUSEOF WIDEO DNIA

Czym więc jest system plików i jak łatwo wchodzić w interakcję z systemem plików systemu operacyjnego w Node.js?

Telefon LG nie łączy się z komputerem

Co to jest system plików?

System plików definiuje, w jaki sposób system operacyjny może identyfikować, organizować, przechowywać i uzyskiwać dostęp do plików, a także inne operacje.

jak podłączyć airpody do okien laptopa 10

System plików systemu operacyjnego wykonuje również zadanie grupowania plików w kolekcje znane jako katalogi lub foldery. Zwykłe pliki i katalogi są najczęstszymi częściami systemu plików, które często wchodzą w interakcję z wieloma innymi.

Niektóre przykłady systemów plików obejmują system plików nowej technologii (NTFS), system plików UNIX (UFS) i hierarchiczny system plików (HFS).

Co to jest moduł Node.js fs?

Node.js fs module to wbudowana biblioteka dostarczana przez Node.js do pracy z systemem plików dowolnego systemu operacyjnego obsługującego Node. The fs moduł jest łatwo dostępny i jest biblioteką, do której można przejść do operacji na plikach, takich jak czytanie z plików lub zapisywanie danych do plików w Node.js .

Jest bardzo często używany z ścieżka oraz ty moduły do wykonywania różnych operacji na plikach. Aby użyć fs w swoich programach, możesz go zaimportować do swojego kodu źródłowego, jak pokazano w poniższym kodzie.

przekazywanie wiadomości tekstowych na inny iPhone

// CommonJS 
const fs = require('fs') 
  
// ES6 
import fs from 'fs'

Co to jest moduł ścieżki Node.js?

Możesz użyć Node.js ścieżka moduł do manipulowania ścieżkami plików. Zawiera narzędzia do łatwej interakcji ze ścieżkami plików i katalogów. Używając fs oraz ścieżka moduły w tandemie w celu wykonania zadania to standardowa praktyka. Dzieje się tak, ponieważ większość fs funkcje modułu zależą od ścieżek do plików lub katalogów docelowych do działania.

Możesz zaimportować ścieżka do kodu z poniższą składnią:

// CommonJS 
const path = require('path') 
  
// ES6 
import path from 'path'

Typowe funkcje dostępu do systemu plików w Node.js

Oto najczęściej używane Node.js fs oraz ścieżka funkcje modułów i jak ich używać do interakcji z plikami i katalogami.

Praca ze ścieżkami

ścieżka.resolve: Jest to funkcja do rozwiązywania ścieżki z listy instrukcji ścieżki przekazanych jako parametry. Na przykład:

path.resolve('home', 'projects', 'web'); 
// returns <path_to_current_directory>/home/projects/web 
  
path.resolve('home/projects/web', '../mobile'); 
// returns <path_to_current_directory>/home/projects/mobile

ścieżka.normalizuj: The normalizować funkcja zwraca poprawną i znormalizowaną ścieżkę z podanej ścieżki wejściowej. Na przykład:
```
path.normalize('home/projects/web/../mobile/./code'); 
// returns home/projects/mobile/code 
```
ścieżka.dołącz: Ta funkcja buduje ścieżkę z kilku segmentów. Na przykład:
```
path.join('home', 'projects', '../', 'movies'); 
// returns home/movies 
```

ścieżka.nazwa bazy: The nazwa podstawowa funkcja zwraca ostatni segment ścieżki. Możesz go używać na dwa sposoby:

path.basename('home/projects/web/index.js'); 
// returns index.js 
  
path.basename('home/projects/web/index.js', '.js'); 
// removes the extension and returns 'index'

ścieżka.dirname: Ta funkcja zwraca ścieżkę do ostatniego katalogu w podanej ścieżce. Przykład:
```
path.dirname('home/projects/web/index.js'); 
// returns home/projects/web 
```
ścieżka.extname: Dzięki tej funkcji możesz uzyskać rozszerzenie pliku z podanej ścieżki.
```
path.extname('home/projects/web/index.js'); 
// returns '.js' 
```

Otwieranie i zamykanie plików

fs.otwarty: Jest to funkcja do synchronicznego otwierania lub tworzenia pliku w Node.js. Synchroniczna forma fs.otwarty jest fs.openSync . fs.otwórz a akceptuje cztery argumenty, którymi są ścieżka pliku, flagi, tryb otwarty i funkcja zwrotna. Flagi oraz otwarty tryb mają wartość domyślną i możesz dowiedzieć się więcej na ich temat z Node.js fs.open dokumentacja.

const filePath = path.join(__dirname, '/videos/newVideo.mp4'); 
// __dirname returns the path to the current working directory. 
// filePath = <path_to_current_directory>/videos/newVideo.mp4 
  
fs.open(filePath, (error, fileDescriptor) => { 
    // handle errors 
    console.log(fileDescriptor); // prints an integer representing the file descriptor 
})

fs.zamknij: Dobrą praktyką jest zawsze zamykanie otwartych plików, gdy nie są już potrzebne. Node.js ma fs.zamknij Funkcja do tego:

fs.open(filePath, (error, fileDescriptor) => { 
    // handle errors, such as 'file/directory does not exist' 
    console.log(fileDescriptor); 
  
    // close the file 
    fs.close(fileDescriptor, (error) => { 
        // handle errors 
        console.log('File closed successfully'); 
    }); 
})

Tworzenie i usuwanie

fs.mkdir: Działa to tak samo jak mkdir polecenie terminala, które tworzy nowy katalog. Jako parametry przyjmuje ścieżkę, tryb (opcjonalnie) i funkcję zwrotną. Możesz go użyć w ten sposób:
```
const dirPath = path.join(__dirname, 'newDirectory'); 
fs.mkdir(dirPath, (error) => { 
    // handle errors 
    console.log('New directory created successfully'); 
}); 
```

fs.unlink: Ta funkcja usuwa lub usuwa plik w ścieżce przekazanej jako argument. Rozważ poniższy przykład kodu:

const filePath = path.join(_dirname, 'oldFile.js'); 
  
fs.unlink(filePath, (error) => { 
    // handle errors 
    console.log('File has been deleted successfully'); 
});

fs.rmdir: Ta metoda usuwa katalog w podanej ścieżce. Jest bardzo podobny w użyciu do metody odłączania:

const dirPath = path.resolve('home', 'projects', 'web'); 
  
fs.rmdir(dirPath, (error) => { 
    // handle errors 
    console.log('Directory successfully deleted'); 
})

Metadane pliku

fs.istnieje: The istnieje metoda sprawdza, czy plik w podanej ścieżce istnieje. Implementacja wygląda następująco:

let filePath = path.join(__dirname, 'index.html'); 
  
fs.exists(filePath, (exists) => { 
    console.log(exists) // true or false 
})

fs.stat: Jest to funkcja synchroniczna, która zwraca właściwości pliku. Wraca i fs.Statystyki obiekt, który udostępnia niektóre metody dostępu do właściwości pliku. Oto przykład:

fs.stat('index.js', (error, stats) => { 
    console.log(stats); // prints low level properties of the file 
    stats.isFile(); // returns true 
    stats.isDirectory(); // returns false 
})