Bonsoir,

j'essaye de faire des opérations sur des fichiers, mais les opérations ne se font pas dans le bon ordre.

La gestion du syncrhone asynachone a toujours été ma bête noire, et je sens que c'est mal partie pour que ça s'améliore

//Création des variables path
let original_grammar_path=__dirname+"\\viseo-bot-project\\data\\org_grammar\\";
let my_grammar_path=__dirname+"\\viseo-bot-project\\data\\my_grammar\\";
let grammar_path=__dirname+"\\viseo-bot-project\\data\\grammar\\";

//ouverture du fichier config.ini

//Chargement des librairies
const path = require('path');
const fs = require('fs');

async function read_config() {
    console.log("Lecture du fichier config")
    //ouverture du fichier config.ini
    const extract = fs.readFileSync("./config.ini",'utf8', (err, ini_content) => {
        //si le fichier ini n'existe pas on arrête le prg, on ne poura pas allez plus loin
        if (err) {
            console.error(err);
            return;
        }
    });

    let swan_name=""
    let last_swan_name=""

    let ini_string = extract.toString();
    let ini_data=[]
    //on le décompose ligne par ligne
    ini_data= ini_string.split(/\r?\n/);
    //on parcours les lignes pour trouver swan_name et last_swan_name
    for(let i = 0 ; i< ini_data.length;i++)
    {
        //si la ligne ne commence pas par # (sinon c'est du commentaire et on s'en fou)
        if(!ini_data[i].startsWith('#')){
            //on décompose les lignes en nom de variable (line_data[0]), valeur de variable (line_data[1])
            let line_data=ini_data[i].split('=');
            //si la variable s'apelle swan_name
            if(ini_data[i].includes("swan_name") && !ini_data[i].includes("last_swan_name"))
            {
                swan_name=line_data[1]
            }
            //si la variable s'apelle last_swan_name
            if(ini_data[i].includes("last_swan_name"))
            {
                last_swan_name =line_data[1]
            }
        }
    }
    let data=[__dirname,swan_name,last_swan_name]

    console.log("       Lecture terminé")
    return data
}

async function delete_grammar(grammar_path){
    console.log("Suppresion du dictionnaire:")
    //on efface le dictionnaire de swan avant de lui générer un nouveau
    fs.readdir(grammar_path, (err, files) => {
        if (err) throw err;
        for (const file of files) {
            fs.unlink(path.join(grammar_path, file), (err) => {
                if (err){
                    console.log("Error Found:", err);
                }
            });
        }
    });
    console.log("       Suppresion terminé.")
}

async function copy_grammar(source,dest){
    console.log("Copie des fichiers dictionnaires:")
    //on copie les nouveaux fichiers
    fs.readdir(source, (err, files) => {
        if (err) throw err;
        for (const file of files) {
            fs.copyFile(source+file, dest+file , (err) => {
                if (err) {
                    console.log("copie de "+source+file+" vers "+dest+file)
                    console.log("Error Found:", err);
                    return
                }
                else {
                    console.log("copie de "+source+file+" vers "+dest+file)
                }
            });
        }
    });
    console.log("       Copie terminé.")
}
async function rename(swan_name,last_swan_name)
{
    console.log("info de recherche "+swan_name+" ou "+last_swan_name)
    //on va chercher les fichiers master
    const directoryPath = original_grammar_path;
    //passsing directoryPath and callback function
    const files = await fs.readdirSync(directoryPath)

    //listing all files using forEach
    for (const file of files){
        //on vérifie que ce sont bien des fichier XML
        if (file.endsWith('.xml'))
        {
            let fileContents = await fs.readFileSync(original_grammar_path+file)

            let newfile_content ="";
            fileContents=fileContents.toString()
            console.log(fileContents)
            console.log("recherche "+swan_name+" ou "+last_swan_name)

            //si l'identifiant est différent de la variable swan_name, on lui donne le nouvel identifiant
            if (!fileContents.includes("<item>" + swan_name + "</item>")) {
                fileContents = fileContents.replace("<item>SWAN</item>", "<item>" + swan_name + "</item>")
                fileContents = fileContents.replace("<item>" + last_swan_name+ "</item>", "<item>" + swan_name + "</item>")
                console.log("coucou les loulous")

            }
            //si l'identifiant est différent de la variable swan_name, on lui donne le nouvel identifiant
            if (!fileContents.includes('<item weight="2">' + swan_name + '</item>')) {
                fileContents = fileContents.replace('<item weight="2">SWAN</item>', '<item weight="2">' + swan_name + '</item>')
                fileContents = fileContents.replace('<item weight="2">' + last_swan_name + '</item>', '<item weight="2">' + swan_name + '</item>')
                console.log("coucou les loulous 2")

            }

            //on réécrie le fichier
            newfile_content= fileContents;
            console.log(grammar_path+file)
            const contens = await fs.writeFile(grammar_path+file, newfile_content, function (err) {
                if (err) {
                    console.log("au secours")
                    return console.log(err);
                }

            });
        }
        console.log(file); 
    };

}

async function go()
{
    ident= await read_config();
    console.log(ident)

    await delete_grammar(grammar_path);
    await copy_grammar(my_grammar_path,grammar_path)
    await copy_grammar(original_grammar_path,grammar_path)
    await rename(ident[1],ident[2])
}

go();

Toutes les fonctions dans le go fonctionne parfaitement indépendament

Mais quand j'essaie de les faire toutes fonctionner ensemble dans l'ordre donné, plus rien ne vas, un coup c'est pas copier, un autre c'est pas modifié....

le problême je le connais, mais je suis en réelle difficulté avec cette notion.
un petit coup de main c'est posssible?

merci d'avance?

PS, si quelqu'un est dispo avec un fouet ou une batte de baseball un soir, pour que ça renter dans le crane cette notion, je suis preneur.

2 réponses


Kareylo
Réponse acceptée

Le soucis vient du fait que tu utilises des méthodes asynchrones dans des méthodes synchrones.
La plupart du temps, FS possède des méthodes synchrones de ses méthodes asynchrone et son sufficées par Sync.
Ces méthodes ne sont pas des promesses, elles sont bloquantes, ce qui peut ralentir ces méthode. (Ce qui veut dire que tu n'as pas besoin des async/await dans ton code)

Voici ton fichier "corrigé". Je ne l'ai aps testé, possible qu'il y ait des erreurs de syntaxes, d'identations et autre.

//Création des variables path
let original_grammar_path=__dirname+"\\viseo-bot-project\\data\\org_grammar\\";
let my_grammar_path=__dirname+"\\viseo-bot-project\\data\\my_grammar\\";
let grammar_path=__dirname+"\\viseo-bot-project\\data\\grammar\\";

//ouverture du fichier config.ini

//Chargement des librairies
const path = require('path');
const fs = require('fs');

function read_config() {
    console.log("Lecture du fichier config")

    if (!fs.existsSync("./config.ini"))
        return false;

    //ouverture du fichier config.ini
    const extract = fs.readFileSync("./config.ini",'utf8');

    let swan_name=""
    let last_swan_name=""

    let ini_string = extract.toString();
    let ini_data=[]
    //on le décompose ligne par ligne
    ini_data= ini_string.split(/\r?\n/);
    //on parcours les lignes pour trouver swan_name et last_swan_name
    for(let i = 0 ; i< ini_data.length;i++)
    {
        //si la ligne ne commence pas par # (sinon c'est du commentaire et on s'en fou)
        if(!ini_data[i].startsWith('#')){
            //on décompose les lignes en nom de variable (line_data[0]), valeur de variable (line_data[1])
            let line_data=ini_data[i].split('=');
            //si la variable s'apelle swan_name
            if(ini_data[i].includes("swan_name") && !ini_data[i].includes("last_swan_name"))
            {
                swan_name=line_data[1]
            }
            //si la variable s'apelle last_swan_name
            if(ini_data[i].includes("last_swan_name"))
            {
                last_swan_name =line_data[1]
            }
        }
    }
    let data=[__dirname,swan_name,last_swan_name]

    console.log("       Lecture terminé")
    return data
}

function delete_grammar(grammar_path){
    console.log("Suppresion du dictionnaire:")
    //on efface le dictionnaire de swan avant de lui générer un nouveau
    let files = fs.readdirSync(grammar_path);

    for (const file of files) {
        fs.unlinkSync(path.join(grammar_path, file));
    }

    console.log("       Suppresion terminé.")
}

function copy_grammar(source,dest){
    console.log("Copie des fichiers dictionnaires:")
    //on copie les nouveaux fichiers
    const files = fs.readdirSync(source);
    for (const file of files) {
        console.log("copie de "+source+file+" vers "+dest+file);
        fs.copyFileSync(source+file, dest+file);
    }

    console.log("       Copie terminé.")
}

function rename(swan_name,last_swan_name)
{
    console.log("info de recherche "+swan_name+" ou "+last_swan_name)
    //on va chercher les fichiers master
    const directoryPath = original_grammar_path;
    //passsing directoryPath and callback function
    const files = fs.readdirSync(directoryPath)

    //listing all files using forEach
    for (const file of files){
        //on vérifie que ce sont bien des fichier XML
        if (file.endsWith('.xml'))
        {
            let fileContents = fs.readFileSync(original_grammar_path+file)

            let newfile_content ="";
            fileContents=fileContents.toString()
            console.log(fileContents)
            console.log("recherche "+swan_name+" ou "+last_swan_name)

            //si l'identifiant est différent de la variable swan_name, on lui donne le nouvel identifiant
            if (!fileContents.includes("<item>" + swan_name + "</item>")) {
                fileContents = fileContents.replace("<item>SWAN</item>", "<item>" + swan_name + "</item>")
                fileContents = fileContents.replace("<item>" + last_swan_name+ "</item>", "<item>" + swan_name + "</item>")
                console.log("coucou les loulous")

            }
            //si l'identifiant est différent de la variable swan_name, on lui donne le nouvel identifiant
            if (!fileContents.includes('<item weight="2">' + swan_name + '</item>')) {
                fileContents = fileContents.replace('<item weight="2">SWAN</item>', '<item weight="2">' + swan_name + '</item>')
                fileContents = fileContents.replace('<item weight="2">' + last_swan_name + '</item>', '<item weight="2">' + swan_name + '</item>')
                console.log("coucou les loulous 2")

            }

            //on réécrie le fichier
            newfile_content= fileContents;
            console.log(grammar_path+file)
            const contens = fs.writeFileSync(grammar_path+file, newfile_content);
        }

        console.log(file); 
    };

}

function go()
{
    ident= read_config();
    if (!ident)
        return;
    console.log(ident)

    delete_grammar(grammar_path);
    copy_grammar(my_grammar_path,grammar_path)
    copy_grammar(original_grammar_path,grammar_path)
    rename(ident[1],ident[2])
}

go();

Les méthodes de FS que j'ai utilisé :

Hésite pas d'utiliser des try/catch autour des méthodes sync qui peuvent planter.

Déjà merci pour la correction elle est parfaitement fonctionnel.

Si je comprend bien, toutes les méthodes de fichier n'était pas apprioprié. Mais ma structure avait elle quelque chose de cohérent (même si moche)?