JSON iterieren, aber wie?

[Pfaffe]

Wie lese ich denn das aus?
"length": [
0,
"mm"
].
Sowas verstehe ich:
"important_information": {
"hazard_warnings": null
}
subobj_important_information := (subobj as TJSONObject).Values['important_information'] as TJSONObject;
Memo1.Lines.Add(subobj_important_information.Value s['hazard_warnings'].Value);

[himitsu]

Die [] ist ein TJSONArray,
und {} ein TJSONObject.

Über .P['abc'] kann man aber auch einen ganzen Pfad angeben (ähnlich dem XPath von XML)
Ich weiß, die Hilfe TJSONObject.P ist wieder mal unterirdisch,
https://docwiki.embarcadero.com/Libr...N.TJSONValue.P
aber hier mal was aus den Sourcen.

https://docwiki.embarcadero.com/Libr...er#Description

Code:

  /// <summary> Parses a JSON path with names and indexes.</summary>
  /// <remarks>
  ///  The syntax to write paths is similar to XPath but in a Json way.
  ///  The following XPath expression:
  ///    /entities/urls[0]/indices[1]
  ///  would look like
  ///    entities.urls[0].indices[1]   (dot notation)
  ///  or
  ///    entities["urls"][0]["indices"][1]   (bracket notation)
  ///
  ///  The dot (.) token is used to access the object elements:
  ///    ex: object.key
  ///
  ///  The bracket ([]) token is used to access array or object elements:
  ///    In array: cities[0]
  ///    In object: city["name"] or city['name']
  ///    In object: ["city"]["name"] or ['city']['name']
  ///
  ///  The quote (" or ') is used to introduce a literal when the element is being written in bracket notation:
  ///    ex:["first"]["second"] or ['first']['second']
  ///
  ///  To escape the quote in a literal use backslash (\): \"
  ///    ex: ["quotes(\").should.be.escaped"] or ['quotes(\').should.be.escaped']
  ///
  ///  Note: The backslash will only escape quotes within a literal. Bracket notation can be useful when
  ///  names can not be written in dot notation, like the objects keys with dot characters:
  ///    ex: object["key.with.dots"] or object['key.with.dots']
  ///
  /// </remarks>
  TJSONPathParser = record

[Pfaffe]

So gehts:

Delphi-Quellcode:

// subobj: TJSONObject;
subobj_dimensions := subobj.Values['dimensions'] as TJSONObject;
var subobj_length := subobj_dimensions.Values['length'] as TJSONArray;
Memo1.Lines.Add('length = ' + subobj_length.Items[0].Value + ' ' + subobj_length.Items[1].Value);
var subobj_width := subobj_dimensions.Values['width'] as TJSONArray;
Memo1.Lines.Add('width = ' + subobj_width.Items[0].Value + ' ' + subobj_width.Items[1].Value);
var subobj_height := subobj_dimensions.Values['height'] as TJSONArray;
Memo1.Lines.Add('height = ' + subobj_height.Items[0].Value + ' ' + subobj_height.Items[1].Value);

[Incocnito]

Zitat von Pfaffe:

Wie lese ich denn das aus?
"length": [
0,
"mm"
].
Sowas verstehe ich:
"important_information": {
"hazard_warnings": null
}...

Oha, das hatte ich gar nicht gesehen. Wenn man sowas als Klasse (für TJson.JsonToObject<TMyClass>(sValue)) abbilden will, wie soll das denn gehen?
Mit Variant?

Delphi-Quellcode:

type TWhatever_DimVals = Array of Variant;

type 
  TWhatever_Dimensions : class
  private
    FLength : TWhatever_DimVals;
    FWidth  : TWhatever_DimVals;
    FHeight : TWhatever_DimVals;
  public
    ....
  end;

Das fände ich jetzt aber auch nicht so geil.

LG Incocnito

[mytbo]

Zitat von Pfaffe:

Wie lese ich denn das aus?
"length": [
0,
"mm"
]

Mit Hilfe von mORMot lassen sich einzelne Wert auslesen, oder die gesamte Struktur als Objekt/Record abbilden.

Der Zugriff auf einzelne Werte erfolgt so:

Delphi-Quellcode:

uses
  mormot.core.base,
  mormot.core.text,
  mormot.core.variants;

var
  doc: TDocVariantData;
  item: PDocVariantData;
  itemDim: PDocVariantData;
begin
  doc.InitJsonFromFile('data.json', JSON_[mFastFloat]);
  for item in doc.A['data'].Objects do
  begin
    itemDim := item.O['article'].O['dimensions'];
    with itemDim.A['length']^ do
      ShowMessage(Utf8ToString(FormatUtf8('Length: %%', [Value[0], Value[1]])));
  end;

Die JSON Daten als Record abbilden, gelingt so:

Delphi-Quellcode:

uses
  mormot.core.base,
  mormot.core.json,
  mormot.core.text,
  mormot.core.os;
  
type
  TDataRec = record
    data: array of record
      article: record
        id: Integer;
        dimensions: record
          length: array of Variant;
          width: array of Variant;
          height: array of Variant;
        end;
      end;
    end;
    meta: record
      pagination: record
        total: Integer;
        count: Integer;
      end;
    end;
  end;

var
  i: Integer;
  rec: TDataRec;
  json: RawJson;
begin
  json := StringFromFile('data.json');
  if RecordLoadJson(rec, json, TypeInfo(TDataRec)) then
  begin
    for i := 0 to High(rec.data) do
    begin
      with rec.data[i].article.dimensions do
        ShowMessage(Utf8ToString(FormatUtf8('Length: %%', [length[0], length[1]])));
    end;
  end;

Die Record Definition muss die JSON Werte nicht vollständig abbilden, wenn zum Einlesen der Mode Tolerant gewählt wird.

Bis bald...
Thomas

[LoZe]

mach doch einfach ne Klasse von dem Json dann kannst du einfach aus der Klasse die Informationen auslesen.

https://jsontodelphi.com/

Der Aufruf

Delphi-Quellcode:

uses RootUnit;

procedure UseJson(pJson:string);
var
  Root: TRoot;
  Data: TData;
begin
  Root := TRoot.Create;
  try
    Root.AsJson := pJson;
    // in Root.Data sind alle Items aus dem Array drin
    for Data in Root.Data do
    begin
      Data.Article....
    end;

  finally
    Root.Free;
  end;
end;

Die Klasse

Delphi-Quellcode:

unit RootUnit;

interface

uses
  Pkg.Json.DTO, System.Generics.Collections, REST.Json.Types;
{$M+}

type
  TArticle = class;
  TDimensions = class;
  TImportantInformation = class;
  TLinks = class;
  TPagination = class;
  TUnit = class;

  TLinks = class
  end;
  
  TPagination = class
  private
    FCount: Integer;
    [JSONName('current_page')]
    FCurrentPage: Integer;
    FLinks: TLinks;
    [JSONName('per_page')]
    FPerPage: Integer;
    FTotal: Integer;
    [JSONName('total_pages')]
    FTotalPages: Integer;
  published
    property Count: Integer read FCount write FCount;
    property CurrentPage: Integer read FCurrentPage write FCurrentPage;
    property Links: TLinks read FLinks;
    property PerPage: Integer read FPerPage write FPerPage;
    property Total: Integer read FTotal write FTotal;
    property TotalPages: Integer read FTotalPages write FTotalPages;
  public
    constructor Create;
    destructor Destroy; override;
  end;
  
  TMeta = class
  private
    FPagination: TPagination;
  published
    property Pagination: TPagination read FPagination;
  public
    constructor Create;
    destructor Destroy; override;
  end;
  
  TImportantInformation = class
  end;
  
  TDimensions = class(TJsonDTO)
  private
    [JSONName('height')]
    FHeightArray: TArray<Integer>;
    [JSONMarshalled(False)]
    FHeight: TList<Integer>;
    [JSONName('length')]
    FLengthArray: TArray<Integer>;
    [JSONMarshalled(False)]
    FLength: TList<Integer>;
    [JSONName('width')]
    FWidthArray: TArray<Integer>;
    [JSONMarshalled(False)]
    FWidth: TList<Integer>;
    function GetHeight: TList<Integer>;
    function GetLength: TList<Integer>;
    function GetWidth: TList<Integer>;
  protected
    function GetAsJson: string; override;
  published
    property Height: TList<Integer> read GetHeight;
    property Length: TList<Integer> read GetLength;
    property Width: TList<Integer> read GetWidth;
  public
    destructor Destroy; override;
  end;
  
  TUnit = class
  private
    FAmount: Double;
    FUnit: string;
  published
    property Amount: Double read FAmount write FAmount;
    property &Unit: string read FUnit write FUnit;
  end;
  
  TArticle = class
  private
    [JSONName('created_at')]
    FCreatedAt: string;
    FDimensions: TDimensions;
    FId: Integer;
    [JSONName('important_information')]
    FImportantInformation: TImportantInformation;
    FManufacturer: string;
    FName: string;
    FPrice: Double;
    FQuality: string;
    FSku: string;
    FStock: Integer;
    FUnit: TUnit;
    FWeight: Double;
  published
    property CreatedAt: string read FCreatedAt write FCreatedAt;
    property Dimensions: TDimensions read FDimensions;
    property Id: Integer read FId write FId;
    property ImportantInformation: TImportantInformation read FImportantInformation;
    property Manufacturer: string read FManufacturer write FManufacturer;
    property Name: string read FName write FName;
    property Price: Double read FPrice write FPrice;
    property Quality: string read FQuality write FQuality;
    property Sku: string read FSku write FSku;
    property Stock: Integer read FStock write FStock;
    property &Unit: TUnit read FUnit;
    property Weight: Double read FWeight write FWeight;
  public
    constructor Create;
    destructor Destroy; override;
  end;
  
  TData = class
  private
    FArticle: TArticle;
  published
    property Article: TArticle read FArticle;
  public
    constructor Create;
    destructor Destroy; override;
  end;
  
  TRoot = class(TJsonDTO)
  private
    [JSONName('data'), JSONMarshalled(False)]
    FDataArray: TArray<TData>;
    [GenericListReflect]
    FData: TObjectList<TData>;
    FMeta: TMeta;
    function GetData: TObjectList<TData>;
  protected
    function GetAsJson: string; override;
  published
    property Data: TObjectList<TData> read GetData;
    property Meta: TMeta read FMeta;
  public
    constructor Create; override;
    destructor Destroy; override;
  end;
  
implementation

{ TPagination }

constructor TPagination.Create;
begin
  inherited;
  FLinks := TLinks.Create;
end;

destructor TPagination.Destroy;
begin
  FLinks.Free;
  inherited;
end;

{ TMeta }

constructor TMeta.Create;
begin
  inherited;
  FPagination := TPagination.Create;
end;

destructor TMeta.Destroy;
begin
  FPagination.Free;
  inherited;
end;

{ TDimensions }

destructor TDimensions.Destroy;
begin
  GetHeight.Free;
  GetLength.Free;
  GetWidth.Free;
  inherited;
end;

function TDimensions.GetHeight: TList<Integer>;
begin
  Result := List<Integer>(FHeight, FHeightArray);
end;

function TDimensions.GetLength: TList<Integer>;
begin
  Result := List<Integer>(FLength, FLengthArray);
end;

function TDimensions.GetWidth: TList<Integer>;
begin
  Result := List<Integer>(FWidth, FWidthArray);
end;

function TDimensions.GetAsJson: string;
begin
  RefreshArray<Integer>(FHeight, FHeightArray);
  RefreshArray<Integer>(FLength, FLengthArray);
  RefreshArray<Integer>(FWidth, FWidthArray);
  Result := inherited;
end;

{ TArticle }

constructor TArticle.Create;
begin
  inherited;
  FUnit := TUnit.Create;
  FDimensions := TDimensions.Create;
  FImportantInformation := TImportantInformation.Create;
end;

destructor TArticle.Destroy;
begin
  FUnit.Free;
  FDimensions.Free;
  FImportantInformation.Free;
  inherited;
end;

{ TData }

constructor TData.Create;
begin
  inherited;
  FArticle := TArticle.Create;
end;

destructor TData.Destroy;
begin
  FArticle.Free;
  inherited;
end;

{ TRoot }

constructor TRoot.Create;
begin
  inherited;
  FMeta := TMeta.Create;
end;

destructor TRoot.Destroy;
begin
  FMeta.Free;
  GetData.Free;
  inherited;
end;

function TRoot.GetData: TObjectList<TData>;
begin
  Result := ObjectList<TData>(FData, FDataArray);
end;

function TRoot.GetAsJson: string;
begin
  RefreshArray<TData>(FData, FDataArray);
  Result := inherited;
end;

end.

[himitsu]

Zitat:

Delphi-Quellcode:

    [JSONName('height')]
    FHeightArray: TArray<Integer>;

@LoZe: du mußt aufpassen, denn es sind keine "einheitlichen" Arrays.

also kein "length": [ 0, 1, 2 ], sondern jeweils Wert und Einheit ala "length": [ 0, "mm" ], statt als Array wäre es wohl in zwei Feldern angebrachter
Length: Integer;
LengthUnit: string; // oder Enum

oder ein nur Feld und beim Lesen in eine Grundeinheit umgerechnet

[LoZe]

@himitsu war nur Copy and Paste von der Webseite... ich bin nicht über die Daten gegangen das könnte man natürlich als String einlesen

[Incocnito]

Zitat von LoZe:

... das könnte man natürlich als String einlesen

Ja, ne, nicht wirklich! Wie himitsu schon schreibt, die Werte sind gemischt im Array.
Wer auch immer das Json designed hat.
Wäre ja schon kein Problem in Delphi mehr, wenn es

Code:

"length": { 0, "mm" },

statt

Code:

"length": [ 0, "mm" ],

wäre.

LG Incocnito

[Uwe Raabe]

Zitat von Incocnito:

Wäre ja schon kein Problem in Delphi mehr, wenn es

Code:

"length": { 0, "mm" },

Das ist aber kein gültiges JSON. Dann schon

Code:

"length": { "value": 0, "unit": "mm" },

Aber, wie du schon sagst

Zitat von Incocnito:

Wer auch immer das Json designed hat.

Es ist leider so, dass viele Entwickler beim Design solcher offenen Schnittstellen nicht über den Tellerrand ihrer Programmierumgebung hinausschauen. Das gilt auch für Delphi-Entwickler und ich bekenne mich selbst dessen (zumindest in der Vergangenheit) auch für schuldig.