JSON einlesen - Hilfe für Anfänger

[venice2]

Zitat:

Grins. Kann es sein, das der Ursprung von mir stammt ?

Klar stammt der von dir hast ihn mir doch geschickt.

Destotrotz arbeite ich mit dem parsen der *.json und nicht wie du alles von Hand -> Auseinandergebröselt. Pos, PosEx und Konsorte.
In meiner Pas befindet sich minimalistischer Code von dir da ich hier mit Json arbeite und nicht so wie du mit wie schon gesagt PosNext, Pos, PosEx.

Zitat:

Ich möchte ja auch keine spezielle Hilfe beim Auseinanderbröseln von Zattoo-Daten, sondern lediglich diesen JSON String (oder auch den der Channels, EPG-Details, ....)

Ach...
Schau dir doch den Source an da wird nix Auseinandergebröselt sondern der Json string geparst.
Wenn du das nicht erkennst sorry dann kann ich dir da auch nicht weiter helfen.

Viel spaß noch damit.
Bin raus da mich Zattoo nicht wirklich noch irgendwie interessiert.

[Aviator]

Also ich weiß nicht was man da sonst noch zu schreiben soll. Ich habe dir doch auch schon ein Beispiel gemacht. Oder hast du das etwa komplett überlesen?

[Uwe Raabe]

Zitat von Aviator:

Also ich weiß nicht was man da sonst noch zu schreiben soll. Ich habe dir doch auch schon ein Beispiel gemacht.

Das compiliert aber so nicht. Wenn man sich damit dann nicht auskennt, wirft man es halt schnell gleich wieder weg.

Bis auf den Dateinamen für die JSON-Datei sollte es so gehen:

Delphi-Quellcode:

program TestJSON1;

{$APPTYPE CONSOLE}

uses
  System.SysUtils,
  System.IOUtils,
  REST.Json.Types,
  REST.Json;

type
  TBlock = class
  private
    FListe1: TArray<string>;
    FListe4: TArray<Integer>;
    FInt_1: Integer;
    FTxt_1: string;
    FBool_1: Boolean;
    FReal_1: Real;
  public
    property Liste1: TArray<string> read FListe1;
    property Liste4: TArray<Integer> read FListe4;
    property Int_1: Integer read FInt_1;
    property Txt_1: string read FTxt_1;
    property Bool_1: Boolean read FBool_1;
    property Real_1: Real read FReal_1;
  end;

  TContainer = class
  private
    { ja, wir könnten hier auch FBlöcke schreiben, aber das sind so Dinge, die bringe ich einfach nicht übers Herz. }
    [JSONName('Blöcke')] // needs REST.Json.Types
    FBloecke: TArray<TBlock>;
  public
    destructor Destroy; override;
    property Bloecke: TArray<TBlock> read FBloecke;
  end;

destructor TContainer.Destroy;
var
  item: TBlock;
begin
  for item in FBloecke do
    item.Free;

  inherited;
end;

procedure ParseJson();
var
  block: TBlock;
  FileContent: String;
  Container: TContainer;
begin
  FileContent := TFile.ReadAllText('<path\to\file.json>');
  Container := TJson.JsonToObject<TContainer>(FileContent);
  try
    for block in Container.Bloecke do
      Writeln(block.Txt_1);
  finally
    Container.Free;
  end;
end;

begin
  try
    ParseJson;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;

end.

[Aviator]

Zitat von Uwe Raabe:

Das compiliert aber so nicht. Wenn man sich damit dann nicht auskennt, wirft man es halt schnell gleich wieder weg.

Naja ich bin mal davon ausgegangen, dass er die Klasse und die Prozedur selbst in eine Unit an die richtige Stelle schreiben kann. 😉

Was ich jetzt so beim Schreiben im Editor nicht mehr im Kopf hatte war, dass man wohl eine weitere Klasse mit einem Feld bauen muss in dass das Objekt dann konvertiert wird. 😅

Aber mit den vielen Beispielen hätte er das sicherlich hinbekommen können. 🙂

[TERWI]

@Aviator
Nein das habe ich nicht überlesen, sondern gut eine 1/2 Stunde drüber gegrübelt, wie das funktiert. Ohne Ergebnis.
Dein JSON ist auch leicht anders als meiner - siehe auch mein Anhang in #9 mit dem reellen JSON.
Ich denke der Unterschied und die Art das zu parsen ist hier sehr wichtig ?!

Problem bzw. wichtig ist:
- ich will alle Einträge (Bloack_A -> _Z) durchlaufen und deren Namen lesen
- Nicht alle (Array- ?) Eintäge sind dabei wichtig und können übersprungen werden
- Auch sind nicht alle Werte (Pairs, Arrays ?!) datunter notwendig
- Teilweise brauche ich jeweils auch unterschiedliche "Sätze" (z.B. A] Liste_1 und Int_1, B] Liste_2 und Int_2)

Ich müsste das also sozusagen schon zeilenweise in Loop's "durchkauen".

@Uwe
.... hat er aber eben nicht.

[TERWI]

Ich versuche noch mal, das reelle JSON in Post #9 zu beschreiben und wie ich es bisher "zu Fuß" in vorherigen Datenversion gelesen habe:

Das 'äußere' Objekt namens "channels" interessiert mich nicht.
Eine äußere Schleife liest dann alle TV-Sendernamen durch (bis ca. 150)
Die brauche ich nicht alle, nur bestimmte.

Unterhalb der jeweiligen Sendernamen liegen dann sozusagen Listen aus Records mit Daten, welche die jeweilige Sendung beschreiben. (Name, Start-/Sop-Zeit, ID's mit Verweisen auf Logos und EPG-Detail-Daten, etc.)
Auch die brauche ich nicht immer alle.

In dem Beispiel mit TBlocks müsste ich dann z.B. wissen, wie der Block heisst.

Da Zatto nicht maximale Anzahl von Daten (Sendungen für mehrere Tage) hergibt, muss man "brückchenweise" (am besten in 6-Atunden Abschnitten) wiederholte die Daten ziehen.
Daraus puzzle ich mir dann meinen EPG für ca. 2 Wochen zusammen und / oder mache Updates bei Änderungen.

So viel zum Sinn und Zweck der Veranstaltung.

[Delphi.Narium]

Irgendwie verstehe ich was Du meinst, ich verstehe jedoch nicht, wo konkret das Problem liegt.

Da ich nur ein olles Delphi 7 habe, nix JSon und passende Klassen schon mitgeliefert, hab' ich mir mal für ein konkretes "JSon-Problem" folgende Hilfroutine geschrieben:

Delphi-Quellcode:

procedure MyJSonSplit(sl : TStringList);
var
  input  : TMemoryStream;
  output : TMemoryStream;
  ch     : Char;
  ch2    : Char;
  cr     : Char;
  lf     : Char;
  i      : Integer;
begin
  input  := TMemoryStream.Create;
  output := TMemoryStream.Create;
  for i := 0 to sl.Count - 1 do sl[i] := AnsiReplaceText(sl[i],'"','"');
  sl.SaveToStream(input);
  input.Position := 0;
  if input.Size > 0 then begin
    cr := #13;
    lf := #10;
    if input.Read(ch,1) > 0 then begin
      repeat
        case ch of
          '{','[',']','}' : begin
                              output.Write(cr,1);
                              output.Write(lf,1);
                              output.Write(ch,1);
                              output.Write(cr,1);
                              output.Write(lf,1);
                            end;
          ','             : begin
                              input.Read(ch2,1);
                              case ch2 of
                                '"' : begin
                                        output.Write(cr,1); // eventuell ersten 3 Zeilen weglassen?
                                        output.Write(lf,1);
                                        output.Write(ch,1);
                                        output.Write(cr,1);
                                        output.Write(lf,1);
                                        output.Write(ch2,1);
                                      end;
                              else
                                output.Write(ch,1);
                                input.Position := input.Position - 1;
                              end;
                            end;
        else
          output.Write(ch,1);
        end;
        if input.Position mod 1000 = 0 then Application.ProcessMessages;
      until input.Read(ch,1) = 0;
    end;
    output.Position := 0;
    sl.LoadFromStream(output);
  end;
  output.Free;
  input.Free;
end;

Stringliste rein, Stringliste raus.

Damit sind alle Daten zeilenweise aufgebröselt.

Wenn man nun diese Struktur kennt, kann man das auch entsprechend in 'ner For-Schleife auswerten, Bereiche überlesen, ...

Eventuell wäre das ja ein Ansatz für Dich.

Und nein: Eine professionelle Lösung ist das nicht, für's Hobbyprogrammieren aber ausreichend

[jobo]

Der Ansatz, JSON 'per Hand' zu zerlegen, scheint mir nicht sinnvoll oder viel zu mühevoll.
Ich habe hier ein Beispiel für Postgres SQL gemacht.

https://dbfiddle.uk/?rdbms=postgres_...04c5eefd41b168

Dort werden ein paar Beispieldaten in eine Tabelle eingefügt und zerlegt. Es sind anfangs ein paar Statements aufgeführt, die die grobe Zerlegung zeigen, am Ende dann ein paar "Anwendungsfälle".

Dort im Browser ist es etwas lahm, auf einer normalen DB geht es zumindest mit den Beispieldaten aber flott.

[TiGü]

Ausgehend von Uwes Konsolenprogramm und den richtigen Daten aus #9 aus dem Archiv schnell was zusammengezimmert.
Ganzes Projekt mit Beispieldaten im Anhang als ZIP-Archiv.

Mir ist bewusst, dass in diesem Ansatz die Sendernamen fehlen, da es sich hier um eine 1:1-Umsetzung der Json-Daten handelt.
Die Transformation in das gewünschte Datenformat steht noch aus, da uns dies unbekannt ist TERWI.
Kann aber ggf. durch RTTI geholt werden (https://stackoverflow.com/questions/...ss-at-run-time).
Dies überbleibt dem geneigten Leser als Fingerübung und Hausaufgabe.

Delphi-Quellcode:

program JsonZattoo;

{$APPTYPE CONSOLE}


uses
    System.SysUtils,
    System.IOUtils,
    REST.Json,
    ZattooTypes in 'ZattooTypes.pas';

procedure ParseJson();
var
    Root: TRoot;
    LChannels: TChannels;
    LChannelInfo: TChannelInfo;
    LEPGInfo: TEPGInfo;
    FileContent: string;
    Txt: string;
begin
    FileContent := TFile.ReadAllText('EPG_GUIDE.json');
    Root := TJson.JsonToObject<TRoot>(FileContent);
    try
        LChannels := Root.ChannelContainer.Channels;
        for LChannelInfo in LChannels do
        begin
            for LEPGInfo in LChannelInfo do
            begin
                Writeln('ID: ', LEPGInfo.id);
                Writeln('Title: ', LEPGInfo.title);

                if not LEPGInfo.episode_title.IsEmpty then
                begin
                    Writeln('Episode: ', LEPGInfo.episode_title);
                end;

                if Length(LEPGInfo.genre) > 0 then
                begin
                    Writeln('  Genre(s):');
                    for Txt in LEPGInfo.genre do
                    begin
                        Writeln('    ' + Txt);
                    end;
                end;
                Writeln('--------------------');
            end;
        end;
    finally
        Root.Free;
    end;
end;

begin
    ReportMemoryLeaksOnShutdown := True;
    try
        ParseJson;
    except
        on E: Exception do
                Writeln(E.ClassName, ': ', E.Message);
    end;
    Readln

end.

Delphi-Quellcode:

unit ZattooTypes;

interface

uses
    REST.Json.Types;

type
    TEPGInfo = class
    private
        Fid: Integer;
        [JSONName('t')]
        FTitle: string;
        [JSONName('et')]
        FEpisode_title: string;
        [JSONName('g')]
        FGenre: TArray<string>;
    public
        property id: Integer read Fid write Fid;
        property title: string read FTitle write FTitle;
        property episode_title: string read FEpisode_title write FEpisode_title;
        property genre: TArray<string> read FGenre write FGenre;
    end;

    TChannelInfo = TArray<TEPGInfo>;
    TChannels = TArray<TChannelInfo>;

    TChannelContainer = class
    private
        Fsixx_deutschland: TChannelInfo;
        Fard: TChannelInfo;
        Fdeutschesmusikfernsehen: TChannelInfo;
        F3sat: TChannelInfo;
        function GetChannels: TChannels;
    public
        destructor Destroy; override;

        property Channels: TChannels read GetChannels;

        { // optional, wenn du nur eine Handvoll Sender brauchst und den direkten Zugriff willst, ansonsten per Channels-Property
          property deutschesmusikfernsehen: TChannelInfo read Fdeutschesmusikfernsehen write Fdeutschesmusikfernsehen;
          property ard: TChannelInfo read Fard write Fard;
          property _3sat: TChannelInfo read F3sat write F3sat;
          property sixx_deutschland: TChannelInfo read Fsixx_deutschland write Fsixx_deutschland;
        }
    end;

    TRoot = class
    private
        [JSONName('channels')]
        FChannels: TChannelContainer;
    public
        destructor Destroy; override;
        property ChannelContainer: TChannelContainer read FChannels;
    end;

implementation

destructor TRoot.Destroy;
begin
    FChannels.Free;

    inherited;
end;

destructor TChannelContainer.Destroy;
var
    ChannelInfo: TChannelInfo;
    EPGInfo: TEPGInfo;
begin
    for ChannelInfo in Self.Channels do
    begin
        for EPGInfo in ChannelInfo do
        begin
            EPGInfo.Free;
        end;
    end;
    inherited;
end;

function TChannelContainer.GetChannels: TChannels;
begin
    Result := [Fsixx_deutschland, Fard, Fdeutschesmusikfernsehen, F3sat];
end;

end.

Beispielausgabe:

Code:

ID: 238874757
Title: Charmed - Zauberhafte Hexen
Episode: Vergissmeinnicht
  Genre(s):
    Drama
    Fantasy
    Mystery
--------------------
ID: 239947163
Title: Charmed - Zauberhafte Hexen
Episode: Die Ohnmacht der Drei
  Genre(s):
    Drama
    Fantasy
    Mystery
--------------------
ID: 238874759
Title: Charmed - Zauberhafte Hexen
Episode: Tödliche Liebe
  Genre(s):
    Drama
    Fantasy
    Mystery
--------------------
ID: 238874760
Title: Charmed - Zauberhafte Hexen
Episode: Opfer der Sehnsucht
  Genre(s):
    Drama
    Fantasy
    Mystery
--------------------
ID: 238906082
Title: ZDF-Mittagsmagazin
  Genre(s):
    News
    Magazine
    Society
--------------------
ID: 238906083
Title: Tagesschau
Episode: vom 21.12.2021, 14:00 Uhr
  Genre(s):
    News
    Politics
    Weather
--------------------
ID: 238906084
Title: Rote Rosen
Episode: Folge 3475
  Genre(s):
    Drama
    Soap
--------------------
ID: 238906085
Title: Tagesschau
Episode: vom 21.12.2021, 15:00 Uhr
  Genre(s):
    News
    Politics
    Weather
--------------------
ID: 238906086
Title: Sturm der Liebe
Episode: Folge 3742
  Genre(s):
    Romance & Love
    Soap
--------------------
ID: 238906087
Title: Tagesschau
Episode: vom 21.12.2021, 16:00 Uhr
  Genre(s):
    News
    Politics
    Weather
--------------------
ID: 238906088
Title: Verrückt nach Meer
Episode: Abenteuer am Öresund
  Genre(s):
    Travel
--------------------
ID: 240036356
Title: Das große Wunschkonzert
Episode: Kastelruther Spatzen
  Genre(s):
    Music
--------------------
ID: 240036357
Title: Musiktipps
  Genre(s):
    Music
--------------------
ID: 240036358
Title: Teleshopping
  Genre(s):
    Talk Show
    Home Shopping
--------------------
ID: 240036359
Title: Bianca: Ihre schönsten Lieder
  Genre(s):
    Music
--------------------
ID: 240036360
Title: Musiktipps
  Genre(s):
    Music
--------------------
ID: 240036361
Title: Teleshopping
  Genre(s):
    Talk Show
    Home Shopping
--------------------
ID: 238905942
Title: Von Sibirien nach Japan
Episode: Wildes Kamtschatka
--------------------
ID: 238905944
Title: Von Sibirien nach Japan
Episode: Im Banne der Inseln
  Genre(s):
    Nature
--------------------
ID: 238879507
Title: Spitzbergen - Leben in Europas Kühlschrank
  Genre(s):
    Nature
--------------------
ID: 238879508
Title: Zimtstern und Halbmond
  Genre(s):
    Romance & Love
    Travel
--------------------