Lire des JSON

**Sylvain255** · 01/06/2022, 12h16

Bonjour,
je voudrais lire un JSON en Delphi, son format est le suivant :

Code JSON :

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
{
    "img073.jpg_0.jpg331941": {
        "fileref": "",
        "size": 331941,
        "filename": "img073.jpg_0.jpg",
        "base64_img_data": "",
        "file_attributes": {},
        "regions": {
            "0": {
                "shape_attributes": {
                    "name": "point",
                    "cx": 750,
                    "cy": 155
                },
                "region_attributes": {}
            }
        }
    },
    "img073.jpg_1.jpg289472": {
        "fileref": "",
        "size": 289472,
        "filename": "img073.jpg_1.jpg",
        "base64_img_data": "",
        "file_attributes": {},
        "regions": {
            "0": {
                "shape_attributes": {
                    "name": "point",
                    "cx": 650,
                    "cy": 134
                },
                "region_attributes": {}
            }
        }
    },
    "img073.jpg_2.jpg375774": {
        "fileref": "",
        "size": 375774,
        "filename": "img073.jpg_2.jpg",
        "base64_img_data": "",
        "file_attributes": {},
        "regions": {
            "0": {
                "shape_attributes": {
                    "name": "point",
                    "cx": 181,
                    "cy": 132
                },
                "region_attributes": {}
            }
        }
    },
    "img073.jpg_3.jpg369305": etc.
}

pour les points et :

Code JSON :

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
{
    "feuille003.jpg2163382": {
        "fileref": "",
        "size": 2163382,
        "filename": "feuille003.jpg",
        "base64_img_data": "",
        "file_attributes": {},
        "regions": {
            "0": {
                "shape_attributes": {
                    "name": "polygon",
                    "all_points_x": [
                        434, 523, 567
                    ],
                    "all_points_y": [
                        263, 307, 350, 526, 706, 794, 803, 805, 804, 784, 772, 774
                    ]
                },
                "region_attributes": {}
            },
            "1": {
                "shape_attributes": {
                    "name": "polygon",
                    "all_points_x": [
                        1126, 1172, 1242, 1278, 1292, 1292
                    ],
                    "all_points_y": [
                        72, 89, 139, 179, 108, 72
                    ]
                },
                "region_attributes": {}
            },
            "2": {
                "shape_attributes": {
                    "name": "polygon",
                    "all_points_x": [
                        2211, 2259, 2224
                    ],
                    "all_points_y": [
                        2414, 2416, 2261, 2330, 2414
                    ]
                },
                "region_attributes": {}
            },
            "3": {
                "shape_attributes": {
                    "name": "polygon",
                    "all_points_x": [
                        440, 482, 530, 440
                    ],
                    "all_points_y": [
                        2712, 2721, 2729, 2722, 2712
                    ]
                },
                "region_attributes": {}
            }
        }
    },
    "feuilles016.jpg2052164": {
        "fileref": "",
        "size": 2052164,
        "filename": "feuilles016.jpg",
        "base64_img_data": "",
        "file_attributes": {},
        "regions": {
            "0": {
                "shape_attributes": {
                    "name": "polygon",
                    "all_points_x": [
                        1117, 1140, 1162
                    ],
                    "all_points_y": [
                        1232, 1197
                    ]
                },
                "region_attributes": {}
            },
            "1": {
                "shape_attributes": {
                    "name": "polygon",
                    "all_points_x": [
                        517, 497, 498, 495, 494, 478, 485, 461
                    ],
                    "all_points_y": [
                        465, 470, 590, 800, 826, 876, 965
                    ]
                },
                "region_attributes": {}
            },
            "2": {
                "shape_attributes": {
                    "name": "polygon",
                    "all_points_x": [
                        1789, 1828
                    ],
                    "all_points_y": [
                        101, 115, 132, 157, 237
                    ]
                },
                "region_attributes": {}
            }
        }
    },
    "feuilles017.jpg2233353": {
        "fileref": "",
        "size": 2233353,
        "filename": "feuilles017.jpg",
        "base64_img_data": "",
        "file_attributes": {},
        "regions": {
            "0": {
                "shape_attributes": {
                    "name": "polygon",
                    "all_points_x": [
                        1314, 1171, 1062, 990, 960, 960, 937
                    ]
                }
            }
        }
    }
}

pour les polygones

je souhaiterais récupérer pour chaque image (exemple : "filename":"img073.jpg_0.jpg") ses points ({"name":"point","cx":650,"cy":134}) ou ses polygones ({"name":"polygon","all_points_x":[2211,2259,2224],"all_points_y":[2414,2416,2261,2330,2414]}) je souhaiterais récupérer chaque coordonnée de point ou de polygone.
J'ai déjà un type polygone qui est un TList de Tpoint et les all_points_x sont tous les x des points à la suite et les all_points_y sont tous les y à la suite.
Merci de m'aider car je n'ai jamais parsé de JSON en Delphi et n'y arrive pas, j'ai cherché des tutos sur Internet mais ne comprends pas.
Merci
Bien cordialement

**Sylvain255** · 01/06/2022, 12h26

et une fois que j'ai chaque image, ses points et ses polygones pouvoir réécrire le JSON

**blonde** · 01/06/2022, 14h15

J'ai essayé de mettre en forme ta première chaîne JSON.

Si je comprends bien, tu as un tableau de imgxxxx ? Est-ce qu'il ne manque pas les indicateur [ et ] pour indiquer que c'est un tableau ?
Pour chaque "imgxx', il y a plusieurs points dans ta baliser "regions" ? Donc idem, il manquerait les crochets pour indiquer un tableau ?

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
{
   "img073.jpg_0.jpg331941":{
      "fileref":"",
      "size":331941,
      "filename":"img073.jpg_0.jpg",
      "base64_img_data":"",
      "file_attributes":{
         
      },
      "regions":{
         "0":{
            "shape_attributes":{
               "name":"point",
               "cx":750,
               "cy":155
            },
            "region_attributes":{
               
            }
         }
      }
   },
   "img073.jpg_1.jpg289472":{
      "fileref":"",
      "size":289472,
      "filename":"img073.jpg_1.jpg",
      "base64_img_data":"",
      "file_attributes":{
         
      },
      "regions":{
         "0":{
            "shape_attributes":{
               "name":"point",
               "cx":650,
               "cy":134
            },
            "region_attributes":{
               
            }
         }
      }
   },
   "img073.jpg_2.jpg375774":{
      "fileref":"",
      "size":375774,
      "filename":"img073.jpg_2.jpg",
      "base64_img_data":"",
      "file_attributes":{
         
      },
      "regions":{
         "0":{
            "shape_attributes":{
               "name":"point",
               "cx":181,
               "cy":132
            },
            "region_attributes":{
               
            }
         }
      }
   }
}

**Sylvain255** · 01/06/2022, 14h18

mon JSON est formé comme ça. Oui il y a plusieurs images et plusieurs points et polygones par image.

**Sylvain255** · 01/06/2022, 14h20

apparemment c'est des tableaux associatifs indexés par des chaînes et donc enserrés dans des { et }

**Sylvain255** · 01/06/2022, 15h48

peux-tu STP me donner un exemple de lecture d'un tableau associatif JSON en Delphi et vice versa l'écriture d'un tableau associatif en Delphi en JSON, je pense que je pourrais me débrouiller avec ça, si j'y arrive je posterai mon code ici pour la postérité

**Paul TOTH** · 01/06/2022, 16h59

ça c'est tordu de mettre un nom variable !

il aurait été plus logique de faire ceci

Code json :

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
[{
      "fileref":"",
      "size":331941,
      "filename":"img073.jpg_0.jpg",
      "base64_img_data":"",
      "file_attributes":{
 
      },
      "regions":{
         "0":{
            "shape_attributes":{
               "name":"point",
               "cx":750,
               "cy":155
            },
            "region_attributes":{
 
            }
         }
      }
   },
   {
      "fileref":"",
      "size":289472,
      "filename":"img073.jpg_1.jpg",
      "base64_img_data":"",
      "file_attributes":{
 
      },
      "regions":{
         "0":{
            "shape_attributes":{
               "name":"point",
               "cx":650,
               "cy":134
            },
            "region_attributes":{
 
            }
         }
      }
   },
   {
      "fileref":"",
      "size":375774,
      "filename":"img073.jpg_2.jpg",
      "base64_img_data":"",
      "file_attributes":{
 
      },
      "regions":{
         "0":{
            "shape_attributes":{
               "name":"point",
               "cx":181,
               "cy":132
            },
            "region_attributes":{
 
            }
         }
      }
   }
]

qui aurait pu être traduit en un TArray<TImage>...du coup il faut passer par un Parser JSON, il n'est pas possible de désérialiser ce truc...enfin pas facilement.

remarque, sur Execute.JSON il est possible de définir une méthode de lecture...donc ça reste possible

dans la function JSONParseField(const Name: string; Parser: TJSONParser): Boolean;, Name contiendra "img073.jpg_0.jpg331941" et le Parser pourra alors lire une structure prédéfinie...mais pas le temps là de faire le test

**SergioMaster** · 01/06/2022, 17h13

Envoyé par Paul TOTH

ça c'est tordu de mettre un nom variable !

je plussoie
j'ai tenté un truc rapide en réduisant le JSON

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
unit JSONUnit;
 
interface
 
uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.ComCtrls, Vcl.StdCtrls,
  System.JSON;
 
type
  TForm23 = class(TForm)
    Button1: TButton;
    TreeView1: TTreeView;
    procedure Button1Click(Sender: TObject);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;
const jsontexte = '{"img073.jpg_0.jpg331941":{"fileref":"","size":331941,"filename":"img073.jpg_0.jpg"}}';
 
var
  Form23: TForm23;
 
implementation
 
{$R *.dfm}
 
procedure TForm23.Button1Click(Sender: TObject);
var J : TJSONValue;
    Ja : TJSonObject;
    p : TJsonPair;
    aNode : TTreeNode;
begin
Treeview1.Items.Clear;
J:= TJSonObject.ParseJSONValue(jsonTexte);
Ja:=TJsonObject(J);
for p in ja do
 begin
   anode:=Treeview1.Items.Add(nil,p.JsonString.Value);
   anode:=Treeview1.Items.AddChild(anode,P.JsonValue.ToString);
   Treeview1.Items.AddChild(anode,P.JsonValue.GetValue<String>('filename'));
   Treeview1.Items.AddChild(anode,P.JsonValue.GetValue<String>('size'));
 end;
treeview1.FullExpand;
end;
 
end.

Mais impossible de faire avec plus d'un élément.
Ces fichiers JSON sont de ton cru ou récupérés quelque part ?

**Sylvain255** · 01/06/2022, 17h32

ces fichiers JSON ne sont pas de mon cru mais d'un logiciel de labélisation pour le deep learning appelé "via", je n'ai aucun problème pour les parser en Python
je suis en train de programmer un programme de labélisation avancé et je dois pouvoir importer des JSON créés par VIA et les exporter dans ce format aussi
ces JSON sont tout à fait valides, c'est bizarre que ce soit si compliqué en Delphi !

**SergioMaster** · 01/06/2022, 17h32

Bon, je me disais qu'il n'était pas possible de ne pas avoir plus d'un élément
Un nouveau test sur

Code :

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

1
2
3
4
5
const jsontexte = '['+
                   '{"img073.jpg_0.jpg331941":{"fileref":"","size":331941,"filename":"img073.jpg"}}'+
                   ','+
                   '{"img073.jpg_0.jpg331941":{"fileref":"","size":331941,"filename":"img073.jpg"}}'+
                   ']';

et avec ce code

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
procedure TForm23.Button1Click(Sender: TObject);
var J : TJSONValue; // quelque chose à parser
    Ja : TJSonObject; // un objet JSON
    a : TJSonArray;  // un array
    av : TJsonValue; // élément d'un array
    p : TJsonPair; // une paire 
    aNode : TTreeNode;
begin
Treeview1.Items.Clear;
J:= TJSonObject.ParseJSONValue(jsonTexte); // parse le "texte"
a:= J As TJSONArray; // récupère le tableau
for av in a do  // pour chaque élement
begin
J:=TJsonObject.ParseJSONValue(av.ToJSON); // aprse l'élément
ja:=J as TJSONObject; // récupére l'élement (comme une paire)
for p in ja do
 begin
   anode:=Treeview1.Items.Add(nil,p.JsonString.Value);
   anode:=Treeview1.Items.AddChild(anode,P.JsonValue.ToString);
   Treeview1.Items.AddChild(anode,P.JsonValue.GetValue<String>('filename'));
   Treeview1.Items.AddChild(anode,P.JsonValue.GetValue<String>('size'));
 end;
end;
treeview1.FullExpand;
end;

je récupère bien les deux éléments
Nom : Capture.PNG
Affichages : 966
Taille : 7,0 Ko

**Paul TOTH** · 01/06/2022, 17h47

Envoyé par Sylvain255

ces fichiers JSON ne sont pas de mon cru mais d'un logiciel de labélisation pour le deep learning appelé "via", je n'ai aucun problème pour les parser en Python
je suis en train de programmer un programme de labélisation avancé et je dois pouvoir importer des JSON créés par VIA et les exporter dans ce format aussi
ces JSON sont tout à fait valides, c'est bizarre que ce soit si compliqué en Delphi !

je n'ai pas dit qu'ils n'étaient pas valides, mais qu'ils sont tordus

que ce soit plus compliqué sous Delphi est lié au fait que Delphi est un langage compilé, donc une structure avec des membres aux noms variables c'est douteux...d'autant que ce nom est une concaténation de deux membres de l'objet (filename + size)...c'est pour le moins inhabituel.

de même file_attributes et region_attributes sont des objets vides (dans l'exemple que tu donnes)...là aussi c'est étonnant.
les régions ont un index numérique...ce devrait être un tableau et non un objet.

encore une fois, le fichier respecte le format JSON, mais sa structure est des plus inhabituelle...ça ne simplifie pas son traitement.

pour le coup, je n'utiliserais par mon unité qui est pensée pour une sérialisation bidirectionnelle RECORD <-> JSON, mais avec un JSON structuré de façon habituelle où un TArray<> correspond à un array JSON [] et un Record (ou un objet, mais je les utilisent peu dans le cadre de JSON) correspond à une structure JSON {}

il faut donc partir sur un code inspiré de celui de Sergio.

**Sylvain255** · 01/06/2022, 17h49

merci à vous tous, je suis en train de tenter d'écrire un code complet, je le posterai quand il sera fini

**Sylvain255** · 01/06/2022, 18h36

Voici mon code :

déclarations de l'unité :

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
type
  tpolygon=record
    points:TList<TPoint>;
    classe:string;
  end;
  tpoint_=record
    point:tpoint;
    classe:string;
  end;
  timagesPolygons=record
    polygones:TList<tpolygon>;
  end;
  timagesPoints=record
     points:TList<tpoint_>;
  end;
var
  Form1: TForm1;
  directory:string;//le répertoire des images
  images,dir_ : TStringList;//la liste des images et un TStringList pour stocker le répertoire
  labelsImages:tobjectlist<TLabel>;//les TLabel des images
  indexImage:integer; //l'index de l'image ouverte
  polygone:tpolygon;//le polygone en cours de dessin
  imagesContent:Tlist<timagesPolygons>;//les polygones des images
  pointsImages:TList<timagesPoints>; //les points des images

code de l'ouverture du JSON (je n'ai géré que les points pour l'instant) :

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
procedure TForm1.ImporterunJSONauformatVIA1Click(Sender: TObject);
var
   json,jsonImage,jsonRegions,regions : TJSONValue; // quelque chose à parser
    jsonImageArray,regionsArray : TJSonObject; // un objet JSON
    jsonArray : TJSONArray;  // un array
    imageJSON : TJSONValue; // élément d'un array
    paireImage : TJSONPair; // une paire
   st:string;
   Branch: string;
   filename:string;
   attributRegion:TJSONPair;
   shapeAttributes:TJSONArray;
   forme,classePoints,classePolygones:string;
   indexImage:integer;
   i,x,y:integer;
   point_:TPoint_;
begin
   if images.Count=0 then  //images est un TStringList contenant l'ensemble des noms de fichiers des images ouvertes
   begin
     showmessage('Erreur ! Aucune image d''ouverte !');
     exit;
   end;
   if opendialog2.execute then
   begin
     try
       jsonfile.loadfromfile(opendialog2.filename);
       //form2 est une fiche de choix de la classe des points (pointsDialog=true) ou des polygones (pointsDialog=false)
       //le format VIA ne gère pas les classes c'est pourquoi on en prend par défaut
       pointsDialog:=true;
       form2.ShowModal;
       classePoints:=unit2.classe_;
       pointsDialog:=false;
       form2.ShowModal;
       classePolygones:=unit2.classe_;
       st:='';
       for I := 0 to jsonfile.Count-1 do
           st:=st+jsonfile[i];
       json := TJSonObject.ParseJSONValue(st);
       jsonArray:= json As TJSONArray; // récupère le tableau
        for imageJSON in jsonArray do  // pour chaque élement
        begin
        jsonImage:=TJsonObject.ParseJSONValue(imageJSON.ToJSON); // parse l'élément
        jsonImageArray:=jsonImage as TJSONObject; // récupére l'élement (comme une paire)
        for paireImage in jsonImageArray do
         begin
           filename:=paireImage.JsonValue.GetValue<String>('filename');
           //recherche de l'index de l'image
           indexImage:=-1;
           for I := 0 to images.Count-1 do
           begin
             if filename=images[i] then
             begin
               indeximage:= i;
               break;
             end;
           end;
           if indexImage=-1 then
           begin
             continue;//l'image est dans le JSON mais pas ouverte donc on passe
           end;
           //on vide les points et les polygones de l'image en cours
           pointsImages[indexImage].points.clear;
           imagesContent[indexImage].polygones.Clear;
           //recherche des régions
           regions:=paireImage.JsonValue.GetValue<TJSONValue>('regions');
           jsonRegions:=TJsonObject.ParseJSONValue(regions.ToJSON); // parse l'élément
           regionsArray:=jsonRegions as TJSONObject;
           for attributRegion in regionsArray do
           begin
              if attributRegion.JsonString.Value='shape_attributes' then
              begin
                 forme:=attributRegion.JsonValue.GetValue<string>('name');
                 if forme='point' then
                 begin
                    x:= strtoint(attributRegion.JsonValue.GetValue<string>('cx'));
                    y:= strtoint(attributRegion.JsonValue.GetValue<string>('cy'));
                    point_.point:=Point(x,y);
                    point_.classe:=classePoints;
                    pointsImages[indexImage].points.add(point_);
                 end;
              end;
           end;
         end;
       end;
       jsonfile.Free;
       paintbox1.Repaint;
 
     except
       on E: Exception do
        showmessage('Erreur ! Le fichier JSON n''est pas au bon format !'+#13+e.message);
 
     end;
   end;
end;

j'ai une erreur "transtypage d'objets incorrect" à la ligne :

Code :

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

jsonArray:= json As TJSONArray; // récupère le tableau

**Sylvain255** · 01/06/2022, 18h44

ah oui j'ai compris c'est que tu as ajouté des [] autour du JSON

**Sylvain255** · 01/06/2022, 18h46

mais mon format n'est pas du tout :

Code :

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

1
2
3
4
5
6
 
const jsontexte = '['+
                   '{"img073.jpg_0.jpg331941":{"fileref":"","size":331941,"filename":"img073.jpg"}}'+
                   ','+
                   '{"img073.jpg_0.jpg331941":{"fileref":"","size":331941,"filename":"img073.jpg"}}'+
                   ']';

mais :

Code :

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

1
2
3
4
5
 
const jsontexte = 
                   '{"img073.jpg_0.jpg331941":{"fileref":"","size":331941,"filename":"img073.jpg"}'+
                   ','+
                   '"img073.jpg_0.jpg331941":{"fileref":"","size":331941,"filename":"img073.jpg"}}';

la première accolade ne se ferme pas après chaque image mais à la fin du fichier, c'est un tableau associatif

**pprem** · 01/06/2022, 18h57

Bon, c'est vrai qu'utiliser un nom de champ correspondant à un nom de fichier qui est dans ses propriétés, c'est chelou, car il faut le connaître pour accéder à son contenu, que ça aurait été plus intelligent dele faire sous forme de tableau pour simplifier l'accès quoique selon le nombre d'éléments, accéder à l'un d'eux est plus facile par son nom si on le connaît, donc par l'objet), mais rien de bien compliqué.

Ce JSON est un TJSONObject qui a des propriétés à récupérer pour accéder aux TJSONObject en dessous.

Donc la question est de savoir si on connaît la liste des fichiers au départ ou s'il faut parcourir l'objet pour avoir la liste puis ensuite accéder aux caractéristiques de chaque.

**pprem** · 01/06/2022, 18h59

Envoyé par Sylvain255

c'est un tableau associatif

En pratique on parle de tableau associatif, mais cette notion n'existe pas en JSON, c'est un objet, tout bêtement. Donc pas de TJSONArray dans cette histoire (puisque parler de tableau ça voudrait dire qu'il est entre crochets).

**Sylvain255** · 01/06/2022, 18h59

la clé du tableau associatif est le nom de fichier suivi de sa taille car il peut y avoir plusieurs images différentes de même nom mais de taille différente dans VIA mais pas dans mon programme

**pprem** · 01/06/2022, 19h15

Envoyé par Sylvain255

la clé du tableau associatif est le nom de fichier suivi de sa taille car il peut y avoir plusieurs images différentes de même nom mais de taille différente dans VIA mais pas dans mon programme

Ok, du coup tu peux les connaître ou il te faut parcourir la liste pour savoir où piocher ?

Si tu les connais, tu as juste à faire un TJSONObject.ParseJSON() de ta chaîne, puis un TryGetValue ou GetValue sur le nom du fichier+taille qui t'intéresse pour obtenir aussi un TJSONObject.
https://docwiki.embarcadero.com/Libr...ue.TryGetValue

Si tu ne connais pas, tu peux parcourir le tableau Pairs de l'objet global pour lister les noms de fichier et leur contenu.
https://docwiki.embarcadero.com/Libr...ONObject.Pairs

**Sylvain255** · 01/06/2022, 19h16

je vais les découvrir, je tente un code, je le reposte avec ses messages d'erreur éventuels

Lire des JSON

Delphi

Discussions similaires

Partager

Partager