Ankündigung

Einklappen
Keine Ankündigung bisher.

Dateien in Ordner auf Änderungen prüfen...

Einklappen

Neue Werbung 2019

Einklappen
Dieses Thema ist geschlossen.
X
X
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • Dateien in Ordner auf Änderungen prüfen...

    Hallo zusammen,

    ich stehe aktuell vor einem Problem, bezüglich oben genanntes Thema. Konkret ehr, eine Datei zu erkennen, die gerade bearbeitet werden soll.
    Ich hoffe, ich bin im richtigen Thema, da es hier auch um "Node.JS" handelt oder ehr eine Konsolenanwendung am ende ist, die im Hintergrund auf das hören soll, was im Code halt definiert ist.

    Hier einmal mein aktueller Code:
    Code:
    const fs = require('fs');
    const path = require('path');
    const config = JSON.parse(fs.readFileSync('config.json', 'utf8'));
    const watchedFile = 'test.txt';
    const cacheFileName = watchedFile;
    const pathToWatch = config.read_verzeichnis;
    const cachePath = path.join(pathToWatch, config.cache_verzeichnis);
    if (!fs.existsSync(cachePath)) {
        try {
            fs.mkdirSync(cachePath, { recursive: true });
        } catch (error) {
            console.log(`Fehler beim Erstellen des Cache-Verzeichnisses: ${error}`);
        }
    }
    function readContent(filePath) {
        try {
            return fs.readFileSync(filePath, 'utf8');
        } catch (err) {
            console.error(`Fehler beim Lesen der Datei ${filePath}: ${err}`);
            return null;
        }
    }
    function copyDirectoryStructure(sourceDir, targetDir) {
        try {
            const items = fs.readdirSync(sourceDir);
            for (const item of items) {
                if (item !== config.cache_verzeichnis) {
                    const sourcePath = path.join(sourceDir, item);
                    const targetPath = path.join(targetDir, item);
                    const stats = fs.statSync(sourcePath);
       
                    if (stats.isDirectory()) {
                        if (!fs.existsSync(targetPath)) {
                            fs.mkdirSync(targetPath);
                        }
                        copyDirectoryStructure(sourcePath, targetPath);
                    } else if (stats.isFile()) {
                        if (!fs.existsSync(targetPath)) {
                            fs.copyFileSync(sourcePath, targetPath);
                        }
                    }
                }
            }
        } catch (error) {
            console.log(`Fehler beim Kopieren der Verzeichnisstruktur: ${error}`);
        }
    }
    copyDirectoryStructure(pathToWatch, cachePath);
    let currentContent = readContent(path.join(pathToWatch, watchedFile));
    fs.watch(pathToWatch, (eventType, filename) => {
        if (filename === watchedFile && eventType === 'change') {
            if (!fs.existsSync(cachePath)) {
                fs.mkdirSync(cachePath);
            }
            const filePath = path.join(pathToWatch, filename);
            const newContent = readContent(filePath);
           
            if (newContent !== null && newContent !== currentContent) {
                const cacheFilePath = path.join(cachePath, cacheFileName);
                fs.writeFileSync(cacheFilePath, currentContent, 'utf8');
                console.log(`Die Datei ${cacheFileName} wurde gespeichert.`);
                currentContent = newContent;
            }
        }
    });
    Es wird hier (aktuell fest) "test.txt" als zu prüfende Datei genommen. Das alles funktioniert auch einwandfrei. Es wird die Ordnerstruktur, sowie die Dateien Kopiert und ignoriert wird natürlich das "cache_verzeichnis" damit keine Endlosschleife entsteht.

    Am ende ist ein "fs.watch" der darauf wartet, im angegebenen "read_verzeichnis" eine Änderung zu erkennen. Hier aktuell leider nur "test.txt".
    Wenn "test.txt" abgeändert wurde, wird der alte Inhalt in die Datei im "cache_verzeichnis" gespeichert. Der Nutzen ist, wenn man bspw. keine Möglichkeit mehr hat "Strg + Z" zu machen, dass man diese Datei einfach wieder nehmen kann.

    Wie man sicher erkennen konnte, geht es mir darum, dass ich gerne den Teil mit >>
    Code:
    const watchedFile = 'test.txt';
    << so haben möchte, dass auch wirklich jede Datei in dem zu überprüfenden Ordner ("read_verzeichnis") auf Änderung geprüft wird und der alte Inhalt in die richtige Datei im "cache_verzeichnis" gespeichert wird.

    Ich hatte schon versucht das im "fs.watch" durch "filename" zu ermitteln, aber hier wäre es schon zu spät, da er dann den gespeicherten Inhalt einfach nimmt und auch in die Datei bei "cache_verzeichnis" schreibt. Also wäre es hier nur eine "Kopie" von einer Datei die ich eh schon habe.

    Wichtig noch zu sagen:
    Es ist nicht immer eine .txt ... Es kann auch mal eine .log oder .csv oder .mapx Datei sein. Nur damit sich nicht auf ".txt" festgehalten wird.

    Ich hoffe ihr könnt mir folgen, was genau mein Anliegen ist und habt vielleicht auch eine Lösung oder eine bessere Idee?!

    Vielen Dank.

  • #2
    Crossposting: https://www.html.de/threads/dateien-...pruefen.61782/

    Kommentar


    • #3
      Nach 323 Beiträgen sollte man die Forenregeln langsam kennen.

      MOD: Geschlossen

      Kommentar

      Lädt...
      X