Discussion :

[Mananjo17]

bonjour
j'ai un petit problème et je n'arrive pas à le résoudre
j'ai un mis dans un fichiers txt tout les internationalisations de mon projet (traductions qui se trouvaient dans les fichier html et ts) et dans un autre fichier txt aussi les clé permettant l'internationalisation (clé dans les fichiers JSON)
ce que je veux faire c'est de trouver quels sont les clé utilisé et non utilisé

ex d'internationalisation: PERS.ADRESSE.RUE
ex dans les fichier JSON:

Code JSON :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
                                      {
                                          "PERS":{
                                                  "ADRESSE":{
                                                         "RUE": blabla,
                                                          "AVENUE": azeaze;
                                                    }

en sortie il liste ceux qui sont utilisés, et séparer par un trait ceux qui sont non utilisés

Merci

[dfgs]

Bonjour,

Le format des données en entrée ne me parait pas le plus simple pour traiter ce genre de problème. Est ce que les deux fichiers sont imposés ou bien est ce un choix personnel ?

Cordialement

[Mananjo17]

bonjour
elle sont imposées
tu as une petite idée de comment procédé?
Merci

[dfgs]

Oui dans les grandes lignes (et avec une partie de pseudo code à remplacer )

Dans la méthode "main" il faut initialiser un certain nombre de variables avant d'appeler une fonction récursive qui va lire le fichier JSON

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
StringReader reader;
// ouvre le fichier JSON et initialize le StringReader
 
// découper la clé en plusieurs parties
string[] keyItems=key.Split('.'); // => {"PERS","ADRESSE","RUE"}
 
 
bool result=CheckIfKeyExists(Reader,keyItems,0);

La méthode récursive qui cherche les segments de clé dans le fichier

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
bool CheckIfKeyExists(StringReader Reader,string[] keyItems,int keyItemIndex)
{
	string lineToSearch;
	string lineFound;
 
	lineToSearch= "...." // l'idée c'est de rechercher la valeur  "keyItems[keyItemIndex]":{ dans le fichier "
	tant que la fin du fichier n'est pas atteinte
	{
		lineFound=Reader.ReadLine();
		// si on rencontre la partie de clé dans le fichier on essaye de rechercher la partie de clé suivante de façon récursive: Il faudra traiter les espaces, indentation ....
		if (lineToSearch==lineFound)
		{
                        // si on a trouvé toutes les parties de clé
                        if (keyItemIndex==keyItemIndex.Length-1) return true;
                        // sinon on poursuit la recherche
                        return CheckIfKeyExists(Reader,keyItems,keyItemIndex+1);
                }
 
	}
	// si la fin de fichier est trouvée alors le résultat est faux
	return false;
}

La fonction récursive est à améliorer pour détecter les fin de balise par ex, mais grosso modo c'est la méthode qui me semble la plus simple

[Mananjo17]

merci pour ta réponse, je suis en train de l'interpréter,
j'ai eu une petite réflexion, est ce que c'est possible de former une clé à partir du fichier JSON et de faire la recherche si cette clé est utilisée ou pas
donc à partir du fichier JSON :

Code JSON :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
                                      {
                                          "PERS":{
                                                  "ADRESSE":{
                                                         "RUE": blabla,
                                                          "AVENUE": azeaze;
                                                    }

on va former les clé PERS.ADRESSE.RUE et PERS.ADRESSE.AVENUE et les mettre dans un fichier text

[dfgs]

Il est possible de créer un fichier texte qui contient les clé PERS.ADRESSE.RUE et PERS.ADRESSE.AVENUE.... Mais de mon point de vue personnel cela revient au même. A un moment donné tu seras obligé de parcourir le fichier JSON pour générer toutes les combinaisons de clé...

L'avantage de ta proposition c'est que tu peux créer un dictionaire en mémoire (au lieu d'un troisième fichier) avec toutes les clés. Si le fichier txt en entrée contient beaucoup de valeurs à vérifier, le traitement sera plus rapide.

[Mananjo17]

je cherche déjà une solution sur ça, mais à chaque tentative j'ai aucun résultat satisfaisant, tu peux m'aider

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
            string pattern = "\"\"(([A-Z)+\.)*[A-Z]+)\";
            string[] JSFile = Directory.GetFiles(@"C:\...\liste", "*.json", SearchOption.AllDirectories);
            foreach (string filePath in JSFile)
            {
                string[] line = System.IO.File.ReadAllLines(filePath);
                foreach (string mot in line)
                {
                    foreach(Match match in Regex.Matches(mot, pattern))
                    do
                    {
                        Console.WriteLine(mot);
                    } while (line.Contains(pattern));
                }
            }
 
            using (System.IO.StreamWriter filedest =
                    new System.IO.StreamWriter(path: @"C:\...\dico.txt"))
            {
                foreach (string filePath in JSFile)
                {
                    string[] lines = System.IO.File.ReadAllLines(filePath);
                    foreach (string line in lines)
                    {
                        Console.WriteLine(mot);
                        filedest.WriteLine(mot);
                    }
                }
            }