fcl-json/ru: what changed
Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.
| Old | New | Line | |
|---|---|---|---|
| 1 | 1 | # Информация | |
| 2 | 2 | ||
| 3 | 3 | fcl-json реализация стандарта [[JSON]]. | |
| 4 | 4 | ||
| 5 | 5 | Пакет содержит юниты: | |
| 6 | 6 | ||
| 7 | 7 | - fpjson: базовый юнит, который реализует TJsonData и их потомков, например TJsonObject | |
| 8 | 8 | - JsonParser: реализует TJsonParser, используется в примере ниже | |
| 9 | 9 | - jsonConf: реализует TJsonConfig, что удобно для чтения/записи данных файлов приложения | |
| 10 | 10 | - jsonScanner: лексический анализатор исходников json | |
| 11 | 11 | ||
| 12 | 12 | > **Note:** В fpjson, доступ, например, `SomeJSONObject.Integers['цена']` может дать Нарушение SIGSEGV/Access, если это целая переменная не существует. Это, очевидно, сделано намеренно, см [[http://bugs.freepascal.org/view.php?id=22273]]. | |
| 13 | 13 | ||
| 14 | 14 | Вы должны были бы использовать метод Find (доступен в FPC 2.6.2), чтобы сначала проверить, существует ли элемент ('цена' в данном примере). | |
| 15 | 15 | ||
| 16 | 16 | # Маршаллинг | |
| 17 | 17 | ||
| 18 | 18 | fcl-json содержит юнит "fpjsonrtti", который используется для загрузки из объектов или сохранения их в формате JSON(экземпляров TObject). | |
| 19 | 19 | ||
| 20 | 20 | Смотрите [[Streaming JSON/ru|Streaming JSON]] для короткого примера. | |
| 21 | 21 | ||
| 22 | 22 | # Примеры | |
| 23 | 23 | ||
| 24 | 24 | ## Итак, начнём | |
| 25 | 25 | ||
| 26 | 26 | ``` Pascal | |
| 27 | 27 | ||
| 28 | 28 | USES fpjson, jsonparser; | |
| 29 | 29 | ||
| 30 | 30 | PROCEDURE JSONTest; | |
| 31 | 31 | VAR | |
| 32 | 32 | jData : TJSONData; | |
| 33 | 33 | jObject : TJSONObject; | |
| 34 | 34 | jArray : TJSONArray; | |
| 35 | 35 | s : string; | |
| 36 | 36 | BEGIN | |
| 37 | 37 | // это лишь минимальный пример того, что можно сделать с помощью этого API | |
| 38 | 38 | ||
| 39 | 39 | // создать строки JSON | |
| 40 | 40 | jData := GetJSON('{"поле1" : "Привет", "поле2" : 42, "Цвет" : ["Красный", "Зелёный", "Голубой"]}'); | |
| 41 | 41 | ||
| 42 | 42 | // вывести как плоскую строку | |
| 43 | 43 | s := jData.AsJSON; | |
| 44 | 44 | ||
| 45 | 45 | // вывести замечательно-отформатированный JSON | |
| 46 | 46 | s := jData.FormatJSON; | |
| 47 | 47 | ||
| 48 | 48 | // передан как TJSONObject для простого доступа | |
| 49 | 49 | jObject := TJSONObject(jData); | |
| 50 | 50 | ||
| 51 | 51 | // передача значения ключа "поле1" | |
| 52 | 52 | s := jObject.Get('поле1'); | |
| 53 | 53 | ||
| 54 | 54 | // установка значения ключа "поле2" | |
| 55 | 55 | jObject.Integers['поле2'] := 123; | |
| 56 | 56 | ||
| 57 | 57 | // передача второго цвета | |
| 58 | 58 | s := jData.FindPath('Цвет[1]').AsString; | |
| 59 | 59 | ||
| 60 | 60 | // добавить новый элемент | |
| 61 | 61 | jObject.Add('Happy', True); | |
| 62 | 62 | ||
| 63 | 63 | // передать новый подмассив | |
| 64 | 64 | jArray := TJSONArray.Create; | |
| 65 | 65 | jArray.Add('Север'); | |
| 66 | 66 | jArray.Add('Юг'); | |
| 67 | 67 | jArray.Add('Восток'); | |
| 68 | 68 | jArray.Add('Запад'); | |
| 69 | 69 | jObject.Add('Направление', jArray); | |
| 70 | 70 | ||
| 71 | 71 | END; | |
| 72 | 72 | ``` | |
| 73 | 73 | ||
| 74 | 74 | ## Перемещение пунктов | |
| 75 | 75 | ||
| 76 | 76 | ``` pascal | |
| 77 | 77 | uses | |
| 78 | 78 | Classes, TypInfo, fpjson, jsonparser; | |
| 79 | 79 | ||
| 80 | 80 | procedure JSONItems(Info: TStrings); | |
| 81 | 81 | var | |
| 82 | 82 | jData : TJSONData; | |
| 83 | 83 | jItem : TJSONData; | |
| 84 | 84 | i, j: Integer; | |
| 85 | 85 | object_name, field_name, field_value, object_type, object_items: String; | |
| 86 | 86 | begin | |
| 87 | 87 | jData := GetJSON('{"A":{"field1":0, "field2": false},"B":{"field1":0, "field2": false}}'); | |
| 88 | 88 | ||
| 89 | 89 | for i := 0 to jData.Count - 1 do | |
| 90 | 90 | begin | |
| 91 | 91 | jItem := jData.Items[i]; | |
| 92 | 92 | ||
| 93 | 93 | object_type := GetEnumName(TypeInfo(TJSONtype), Ord(jItem.JSONType)); | |
| 94 | 94 | object_name := TJSONObject(jData).Names[i]; | |
| 95 | 95 | WriteStr(object_items, jItem.Count); | |
| 96 | 96 | ||
| 97 | 97 | Info.Append('object type: ' + object_type + '|object name: ' + object_name + '|number of fields: ' + object_items); | |
| 98 | 98 | ||
| 99 | 99 | for j := 0 to jItem.Count - 1 do | |
| 100 | 100 | begin | |
| 101 | 101 | field_name := TJSONObject(jItem).Names[j]; | |
| 102 | 102 | field_value := jItem.FindPath(TJSONObject(jItem).Names[j]).AsString; | |
| 103 | 103 | ||
| 104 | 104 | Info.Append(field_name + '|' + field_value); | |
| 105 | 105 | end; | |
| 106 | 106 | end; | |
| 107 | 107 | ||
| 108 | 108 | jData.Free; | |
| 109 | 109 | end; | |
| 110 | 110 | ``` | |
| 111 | 111 | ||
| 112 | 112 | ## Сохранение/загрузка позиции/размера диалога | |
| 113 | 113 | ||
| 114 | 114 | ``` Pascal | |
| 115 | 115 | USES jsonConf; | |
| 116 | 116 | ||
| 117 | 117 | PROCEDURE TfmMain.SaveOptionsPos; | |
| 118 | 118 | VAR | |
| 119 | 119 | c: TJSONConfig; | |
| 120 | 120 | BEGIN | |
| 121 | 121 | c:= TJSONConfig.Create(nil); | |
| 122 | 122 | TRY | |
| 123 | 123 | c.Filename:= GetAppPath(cFileHistory); | |
| 124 | 124 | c.SetValue('/dialog/max', WindowState=wsMaximized); | |
| 125 | 125 | if WindowState<>wsMaximized then | |
| 126 | 126 | BEGIN | |
| 127 | 127 | c.SetValue('/dialog/posx', Left); | |
| 128 | 128 | c.SetValue('/dialog/posy', Top); | |
| 129 | 129 | c.SetValue('/dialog/sizex', Width); | |
| 130 | 130 | c.SetValue('/dialog/sizey', Height); | |
| 131 | 131 | END; | |
| 132 | 132 | FINALLY | |
| 133 | 133 | c.Free; | |
| 134 | 134 | END; | |
| 135 | 135 | END; | |
| 136 | 136 | ||
| 137 | 137 | procedure TfmMain.LoadOptionsPos; | |
| 138 | 138 | var | |
| 139 | 139 | nLeft, nTop, nW, nH: integer; | |
| 140 | 140 | c: TJSONConfig; | |
| 141 | 141 | begin | |
| 142 | 142 | c:= TJSONConfig.Create(nil); | |
| 143 | 143 | try | |
| 144 | 144 | c.Filename:= GetAppPath(cFileHistory); | |
| 145 | 145 | ||
| 146 | 146 | nLeft:= c.GetValue('/dialog/posx', Left); | |
| 147 | 147 | nTop:= c.GetValue('/dialog/posy', Top); | |
| 148 | 148 | nW:= c.GetValue('/dialog/sizex', Width); | |
| 149 | 149 | nH:= c.GetValue('/dialog/sizey', Height); | |
| 150 | 150 | SetBounds(nLeft, nTop, nW, nH); | |
| 151 | 151 | ||
| 152 | 152 | if c.GetValue('/dialog/max', false) then | |
| 153 | 153 | WindowState:= wsMaximized; | |
| 154 | 154 | finally | |
| 155 | 155 | c.Free; | |
| 156 | 156 | end; | |
| 157 | 157 | end; | |
| 158 | 158 | ``` | |
| 159 | 159 | ||
| 160 | 160 | ## Сохранение/загрузка TStringList | |
| 161 | 161 | ||
| 162 | 162 | ``` Pascal | |
| 163 | 163 | //Пример пути: '/list_find' | |
| 164 | 164 | ||
| 165 | 165 | PROCEDURE SLoadStringsFromFile(cfg: TJsonConfig; const path: string; List: TStrings); | |
| 166 | 166 | VAR | |
| 167 | 167 | i: integer; | |
| 168 | 168 | s: UnicodeString; | |
| 169 | 169 | BEGIN | |
| 170 | 170 | List.Clear; | |
| 171 | 171 | FOR i:= 0 TO OptMaxHistoryItems-1 DO | |
| 172 | 172 | BEGIN | |
| 173 | 173 | s:= cfg.GetValue(path+'/'+inttostr(i), ''); | |
| 174 | 174 | IF s='' THEN break; | |
| 175 | 175 | List.Add(Utf8Encode(s)); | |
| 176 | 176 | END; | |
| 177 | 177 | END; | |
| 178 | 178 | ||
| 179 | 179 | PROCEDURE SSaveStringsToFile(cfg: TJsonConfig; const path: string; List: TStrings); | |
| 180 | 180 | VAR | |
| 181 | 181 | i: integer; | |
| 182 | 182 | s: string; | |
| 183 | 183 | BEGIN | |
| 184 | 184 | FOR i:= 0 TO OptMaxHistoryItems-1 DO | |
| 185 | 185 | BEGIN | |
| 186 | 186 | IF i<List.Count THEN | |
| 187 | 187 | s:= List[i] | |
| 188 | 188 | ELSE | |
| 189 | 189 | s:= ''; | |
| 190 | 190 | cfg.SetDeleteValue(path+'/'+inttostr(i), Utf8Decode(s), ''); | |
| 191 | 191 | END; | |
| 192 | 192 | END; | |
| 193 | 193 | ``` | |
| 194 | 194 | ||
| 195 | 195 | ## Использование JsonViewer | |
| 196 | 196 | ||
| 197 | 197 | Пример использования можно найти в инструментах Lazarus: jsonviewer (расположенный в lazarus/tools/jsonviewer). В частности, эта часть инструмента показывает, как использовать JSON: | |
| 198 | 198 | ||
| 199 | 199 | ``` Pascal | |
| 200 | 200 | PROCEDURE TMainForm.OpenFile(Const AFileName : String); | |
| 201 | 201 | VAR | |
| 202 | 202 | S : TFileStream; | |
| 203 | 203 | P : TJSONParser; | |
| 204 | 204 | D : TJSONData; | |
| 205 | 205 | BEGIN | |
| 206 | 206 | S:=TFileStream.Create(AFileName,fmOpenRead); | |
| 207 | 207 | TRY | |
| 208 | 208 | P:=TJSONParser.Create(S); | |
| 209 | 209 | TRY | |
| 210 | 210 | P.Strict:=FStrict; | |
| 211 | 211 | D:=P.Parse; | |
| 212 | 212 | FINALLY | |
| 213 | 213 | P.Free; | |
| 214 | 214 | END; | |
| 215 | 215 | FINALLY | |
| 216 | 216 | S.Free; | |
| 217 | 217 | END; | |
| 218 | 218 | FFileName:=AFileName; | |
| 219 | 219 | SetCaption; | |
| 220 | 220 | FreeAndNil(FRoot); | |
| 221 | 221 | FRoot:=D; | |
| 222 | 222 | ShowJSONDocument; | |
| 223 | 223 | END; | |
| 224 | 224 | ||
| 225 | 225 | PROCEDURE TMainForm.ShowJSONDocument; | |
| 226 | 226 | BEGIN | |
| 227 | 227 | WITH TVJSON.Items DO | |
| 228 | 228 | BEGIN | |
| 229 | 229 | BeginUpdate; | |
| 230 | 230 | TRY | |
| 231 | 231 | TVJSON.Items.Clear; | |
| 232 | 232 | SHowJSONData(Nil,FRoot); | |
| 233 | 233 | WITH TVJSON DO | |
| 234 | 234 | IF (Items.Count>0) AND Assigned(Items[0]) THEN | |
| 235 | 235 | BEGIN | |
| 236 | 236 | Items[0].Expand(False); | |
| 237 | 237 | Selected:=Items[0]; | |
| 238 | 238 | END; | |
| 239 | 239 | FINALLY | |
| 240 | 240 | EndUpdate; | |
| 241 | 241 | END; | |
| 242 | 242 | END; | |
| 243 | 243 | END; | |
| 244 | 244 | ||
| 245 | 245 | PROCEDURE TMainForm.ShowJSONData(AParent : TTreeNode; Data : TJSONData); | |
| 246 | 246 | VAR | |
| 247 | 247 | N,N2 : TTreeNode; | |
| 248 | 248 | I : Integer; | |
| 249 | 249 | D : TJSONData; | |
| 250 | 250 | C : String; | |
| 251 | 251 | S : TStringList; | |
| 252 | 252 | BEGIN | |
| 253 | 253 | N:=Nil; | |
| 254 | 254 | IF Assigned(Data) THEN | |
| 255 | 255 | BEGIN | |
| 256 | 256 | CASE Data.JSONType OF | |
| 257 | 257 | jtArray, | |
| 258 | 258 | jtObject: | |
| 259 | 259 | BEGIN | |
| 260 | 260 | IF (Data.JSONType=jtArray) THEN | |
| 261 | 261 | C:=SArray | |
| 262 | 262 | ELSE | |
| 263 | 263 | C:=SObject; | |
| 264 | 264 | N:=TVJSON.Items.AddChild(AParent,Format(C,[Data.Count])); | |
| 265 | 265 | S:=TstringList.Create; | |
| 266 | 266 | TRY | |
| 267 | 267 | FOR I:=0 TO Data.Count-1 DO | |
| 268 | 268 | IF Data.JSONtype=jtArray THEN | |
| 269 | 269 | S.AddObject(IntToStr(I),Data.items[i]) | |
| 270 | 270 | ELSE | |
| 271 | 271 | S.AddObject(TJSONObject(Data).Names[i],Data.items[i]); | |
| 272 | 272 | IF FSortObjectMembers and (Data.JSONType=jtObject) THEN | |
| 273 | 273 | S.Sort; | |
| 274 | 274 | FOR I:=0 TO S.Count-1 DO | |
| 275 | 275 | BEGIN | |
| 276 | 276 | N2:=TVJSON.Items.AddChild(N,S[i]); | |
| 277 | 277 | D:=TJSONData(S.Objects[i]); | |
| 278 | 278 | N2.ImageIndex:=ImageTypeMap[D.JSONType]; | |
| 279 | 279 | N2.SelectedIndex:=ImageTypeMap[D.JSONType]; | |
| 280 | 280 | ShowJSONData(N2,D); | |
| 281 | 281 | END | |
| 282 | 282 | FINALLY | |
| 283 | 283 | S.Free; | |
| 284 | 284 | END; | |
| 285 | 285 | END; | |
| 286 | 286 | jtNull: | |
| 287 | 287 | N:=TVJSON.Items.AddChild(AParent,SNull); | |
| 288 | 288 | ELSE | |
| 289 | 289 | N:=TVJSON.Items.AddChild(AParent,Data.AsString); | |
| 290 | 290 | END; | |
| 291 | 291 | IF Assigned(N) THEN | |
| 292 | 292 | BEGIN | |
| 293 | 293 | N.ImageIndex:=ImageTypeMap[Data.JSONType]; | |
| 294 | 294 | N.SelectedIndex:=ImageTypeMap[Data.JSONType]; | |
| 295 | 295 | N.Data:=Data; | |
| 296 | 296 | END; | |
| 297 | 297 | END; | |
| 298 | 298 | END; | |
| 299 | 299 | ``` | |
| 300 | 300 | ||
| 301 | 301 | Библиотека [[Components and Code examples]] использует JSON для передачи/приема данных. | |
| 302 | 302 | ||
| 303 | 303 | ## Изменение формата чисел с плавающей запятой | |
| 304 | 304 | ||
| 305 | 305 | Вопрос: моя программа генерирует и записывает данные в файл JSON. Я использую метод `FormatJSON()`, чтобы сделать вывод более читабельным. Меня не совсем устраивает, как выглядят числа с плавающей точкой: | |
| 306 | 306 | ||
| 307 | - | ||
| 308 | - | ||
| 309 | - | ||
| 310 | - | ||
| 307 | + | ```text | |
| 308 | + | "coordinates" : [ | |
| 309 | + | 5.5978631048365003E+001, | |
| 310 | + | 2.2100000000000000E+002 | |
| 311 | + | ] | |
| 312 | + | ``` | |
| 311 | 313 | ||
| 312 | 314 | Я хочу видеть нормальную форму: | |
| 313 | 315 | ||
| 314 | - | ||
| 315 | - | ||
| 316 | - | ||
| 317 | - | ||
| 316 | + | ```text | |
| 317 | + | "coordinates" : [ | |
| 318 | + | 55.978631048365003, | |
| 319 | + | 221.0 | |
| 320 | + | ] | |
| 321 | + | ``` | |
| 318 | 322 | ||
| 319 | 323 | Ответ: (пользователи форума **y.ivanov**, **rvk**, **wp**): | |
| 320 | 324 | ||
| 321 | 325 | ``` pascal | |
| 322 | 326 | {$mode objfpc}{$h+} | |
| 323 | 327 | uses | |
| 324 | 328 | fpjson, | |
| 325 | 329 | jsonparser, | |
| 326 | 330 | SysUtils; | |
| 327 | 331 | ||
| 328 | 332 | type | |
| 329 | 333 | TJSONFloat4Number = class(TJSONFloatNumber) | |
| 330 | 334 | protected | |
| 331 | 335 | function GetAsString: TJSONStringType; override; | |
| 332 | 336 | end; | |
| 333 | 337 | ||
| 334 | 338 | function TJSONFloat4Number.GetAsString: TJSONStringType; | |
| 335 | 339 | var | |
| 336 | 340 | F: TJSONFloat; | |
| 337 | 341 | fs: TFormatSettings; | |
| 338 | 342 | begin | |
| 339 | 343 | fs := DefaultFormatSettings; | |
| 340 | 344 | fs.DecimalSeparator := '.'; | |
| 341 | 345 | F := GetAsFloat; | |
| 342 | 346 | Result := FormatFloat('0.0###############', F, fs); // форматирование с вашими предпочтениями | |
| 343 | 347 | end; | |
| 344 | 348 | ||
| 345 | 349 | procedure JSONTest; | |
| 346 | 350 | var | |
| 347 | 351 | jData: TJSONData; | |
| 348 | 352 | begin | |
| 349 | 353 | jData := GetJSON('{"coordinates": [5.5978631048365003E+001, 2.2100000000000000E+002]}'); | |
| 350 | 354 | writeln(jData.FormatJSON); | |
| 351 | 355 | jData.Free; | |
| 352 | 356 | end; | |
| 353 | 357 | ||
| 354 | 358 | begin | |
| 355 | 359 | SetJSONInstanceType(jitNumberFloat, TJSONFloat4Number); | |
| 356 | 360 | JSONTest; | |
| 357 | 361 | Readln; | |
| 358 | 362 | end. | |
| 359 | 363 | ``` | |
| 360 | 364 | ||
| 361 | 365 | ## Смотрите также | |
| 362 | 366 | ||
| 363 | 367 | - Статья охватывает использование XML и JSON в Free Pascal: [PDF](http://www.freepascal.org/~michael/articles/webdata/webdata.pdf) | |
| 364 | 368 | - [[Package List]] | |
| 365 | 369 | ||
| 366 | 370 | --- | |
| 367 | 371 | *From the Free Pascal wiki, page "fcl-json/ru", as it stood on 2022-10-06 after a change by Zoltanleo, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).* |
